Add files using upload-large-folder tool

parse/train/1G6jPa9SKYG/1G6jPa9SKYG.md

@@ -0,0 +1,268 @@
+# ABC: Auxiliary Balanced Classifier for Class-Imbalanced Semi-Supervised Learning
+
+Hyuck Lee Seungjae Shin Heeyoung Kim Department of Industrial and Systems Engineering, KAIST {dlgur0921, tmdwo0910, heeyoungkim}@kaist.ac.kr
+
+# Abstract
+
+Existing semi-supervised learning (SSL) algorithms typically assume classbalanced datasets, although the class distributions of many real-world datasets are imbalanced. In general, classifiers trained on a class-imbalanced dataset are biased toward the majority classes. This issue becomes more problematic for SSL algorithms because they utilize the biased prediction of unlabeled data for training. However, traditional class-imbalanced learning techniques, which are designed for labeled data, cannot be readily combined with SSL algorithms. We propose a scalable class-imbalanced SSL algorithm that can effectively use unlabeled data, while mitigating class imbalance by introducing an auxiliary balanced classifier (ABC) of a single layer, which is attached to a representation layer of an existing SSL algorithm. The ABC is trained with a class-balanced loss of a minibatch, while using high-quality representations learned from all data points in the minibatch using the backbone SSL algorithm to avoid overfitting and information loss. Moreover, we use consistency regularization, a recent SSL technique for utilizing unlabeled data in a modified way, to train the ABC to be balanced among the classes by selecting unlabeled data with the same probability for each class. The proposed algorithm achieves state-of-the-art performance in various class-imbalanced SSL experiments using four benchmark datasets.
+
+# 1 Introduction
+
+Recently, numerous deep neural network (DNN)-based semi-supervised learning (SSL) algorithms have been proposed to improve the performance of DNNs by utilizing unlabeled data when only a small amount of labeled data is available. These algorithms have shown effective performance in various tasks. However, most existing SSL algorithms assume class-balanced datasets, whereas the class distributions of many real-world datasets are imbalanced. It is well known that classifiers trained on class-imbalanced data tend to be biased toward the majority classes. This issue can be more problematic for SSL algorithms that use predicted labels of unlabeled data for their training, because the labels predicted by the algorithm trained on class-imbalanced data become even more severely imbalanced [18]. For example, Figure 1 (b) presents biased predictions of ReMixMatch [3], a recent SSL algorithm, trained on CIFAR-10-LT, which is a class-imbalanced dataset with the amount of Class 0 being 100 times more than that of Class 9, as depicted in Figure 1 (a). Although there are various class-imbalanced learning techniques, they are usually designed for labeled data, and thus cannot be simply combined with SSL algorithms under class-imbalanced SSL (CISSL) scenarios. Recently, a few CISSL algorithms have been proposed, but the CISSL problem is still underexplored.
+
+We propose a new CISSL algorithm that can effectively use unlabeled data, while mitigating class imbalance by using an existing DNN-based SSL algorithm [3, 29] as the backbone and introducing an auxiliary balanced classifier (ABC) of a single layer. The ABC is attached to a representation layer immediately preceding the classification layer of the backbone, based on the argument that a classification algorithm (i.e., backbone) can learn high-quality representations even if its classifier is biased toward the majority classes [17]. The ABC is trained to be balanced across all classes by using a mask that rebalances the class distribution, similar to re-sampling in previous SSL studies [2, 7, 13, 16]. Specifically, the mask stochastically regenerates a class-balanced subset of a minibatch on which the ABC is trained. The ABC is trained simultaneously with the backbone, so that the ABC can use high-quality representations learned from all data points in the minibatch using the backbone. In this way, the ABC can overcome the limitations of the previous resampling techniques, overfitting on minority-class data or loss of information on majority-class data [6, 27].
+
+![](images/df2c958978da5885a0a028742c684c3549f043f86764924177c5704a1f1a45ba.jpg)  
+Figure 1: Predictions on a class-balanced test set using ReMixMatch (b) and the proposed algorithm (c) trained on a class-imbalanced training set (a).
+
+Moreover, to place decision boundaries in low-density regions by utilizing unlabeled data, we use consistency regularization, a recent SSL technique, which enforces the classification outputs of two augmented or perturbed versions of the same unlabeled example to remain unchanged. In particular, we encourage the ABC to be balanced across classes when using consistency regularization by selecting unlabeled examples with the same probability for each class using a mask. Figure 1 (c) illustrates that compared to the results of ReMixMatch in Figure 1 (b), the class distribution of the predicted labels becomes more balanced using the proposed algorithm trained on the same dataset. Our experimental results under various scenarios demonstrate that the proposed algorithm achieves state-of-the-art performance. Through qualitative analysis and an ablation study, we further investigate the contribution of each component of the proposed algorithm. The code for the proposed algorithm is available at https://github.com/LeeHyuck/ABC.
+
+# 2 Related Work
+
+Semi-supervised learning (SSL) Recently, several SSL techniques that utilize unlabeled data have been proposed. Entropy minimization [12] encourages the classifier outputs to have low entropy for unlabeled data, as in pseudo-labels [22]. Mixup regularization [4, 32] makes the decision boundaries farther away from the data clusters by encouraging the prediction for an interpolation of two inputs to be the same as the interpolation of the prediction for each input. Consistency regularization [26, 24, 30] encourages a classifier to produce similar predictions for perturbed versions of the same unlabeled input. To create perturbed unlabeled inputs, various data augmentation techniques have been used. For example, FixMatch [29] and ReMixMatch [3] used strong augmentation methods such as Cutout [10] and RandomAugment [8]. FixMatch and ReMixMatch are used as the backbone of the proposed algorithm; they are described in Section 3.2.
+
+Class-imbalanced learning (CIL) As a popular approach for CIL, re-sampling techniques [16, 7, 2, 13] balance the number of training samples for each class in the training set. As another popular approach, re-weighting techniques [23, 14, 33] re-weight the loss for each class by a factor inversely proportional to the number of data points belonging to that class. Although these approaches are simple, they have some drawbacks. For example, oversampling from minority classes can cause overfitting, whereas undersampling from majority classes can cause information loss [6]. In the case of re-weighting, gradients can be calculated to be abnormally large when the class imbalance is severe, resulting in unstable training [6, 1]. Many attempts have been made to alleviate these problems, such as effective re-weighting [9] and meta-learning-based re-weighting [28, 15]. New forms of losses have also been proposed [6, 27]. In [36, 19], knowledge is transferred from the data of majority classes to the data of minority classes. These CIL algorithms were designed for labeled data and require label information; thus, they are not applicable to unlabeled data. In [17], it was found that biased classification is mainly due to the classification layer and that a classification algorithm can learn meaningful representations even from a class-imbalanced training set. Based on this finding, we design the ABC to use high-quality representations learned from class-imbalanced data utilizing FixMatch [29] and ReMixMatch [3].
+
+Class-imbalanced semi-supervised learning (CISSL) There have been few studies on CISSL. In [35], it was found that more accurate decision boundaries can be obtained in class-imbalanced settings through self-supervised learning and semi-supervised learning. DARP [18] refines biased pseudolabels by solving a convex optimization problem. CReST [34], a recent self-training technique, mitigates class imbalance by using pseudo-labeled unlabeled data points classified as minority classes with a higher probability than those classified as majority classes.
+
+# 3 Methodology
+
+# 3.1 Problem setting
+
+Suppose that we have a labeled dataset $\mathcal { X } = \{ ( x _ { n } , y _ { n } ) : n \in ( 1 , . . . , N ) \}$ , where $x _ { n } \in \mathbb { R } ^ { d }$ is the nth labeled data point and $y _ { n } \in \{ 1 , \ldots , L \}$ is the corresponding label. We also have an unlabeled dataset $\mathcal { U } = \{ ( u _ { m } ) : m \in ( 1 , \ldots , M ) \}$ , where $u _ { m } \in \mathbb { R } ^ { d }$ is the mth unlabeled data point. We express the ratio of the amount of labeled data as $\begin{array} { r } { \beta = \frac { N } { M + N } } \end{array}$ NM+N . Generally, β < 0.5, because label acquisition is costly and laborious. We denote the number of labeled data points of class $l$ as $N _ { l }$ , i.e., $\begin{array} { r } { \sum _ { l = 1 } ^ { L } N _ { l } = N } \end{array}$ , and assume that the $L$ classes are sorted according to cardinality in descending order, i.e., $N _ { 1 } \geq N _ { 2 } \geq \cdot \cdot \cdot \geq N _ { L }$ . We denote the ratio of the class imbalance as $\begin{array} { r } { \gamma = \frac { N _ { 1 } } { N _ { L } } } \end{array}$ N1 . Under class-imbalanced scenarios, $\gamma \gg 1$ . Following previous CIL studies, we define the half of the classes containing a large amount of data as the majority classes, and the other half of the classes, containing a small amount of data, as the minority classes. Following [34], we assume that $\mathcal { X }$ and $\mathcal { U }$ share the same class distribution, i.e., the labeled and unlabeled datasets are class-imbalanced to the same extent. From $\mathcal { X }$ and $\mathcal { U }$ , we generate minibatches $\mathcal { M B } _ { \mathcal { X } } = \{ ( x _ { b } , y _ { b } ) : b \in ( 1 , . . . , B ) \} \subset \mathcal { X }$ and $\mathcal { M B } _ { \mathcal { U } } = \{ ( u _ { b } ) : b \in ( 1 , \ldots , \bar { B } ) \} \subset \mathcal { U }$ for each iteration of training, where $B$ is the minibatch size. Using these minibatches for training, we aim to learn a model $f : \mathbb { R } ^ { d }  \{ 1 , . . . L \}$ that performs effectively on a class-balanced test set.
+
+# 3.2 Backbone SSL algorithm
+
+We attach the ABC to the backbone’s representation layer, so that it can utilize the high-quality representations learned by the backbone. We use FixMatch [29] or ReMixMatch [3] as the backbone, as these two have achieved state-of-the-art SSL performance. FixMatch uses the classification loss calculated from the weakly augmented labeled data point $\alpha \left( { { x } _ { b } } \right)$ generated by flipping and cropping the image, and the consistency regularization loss calculated from the weakly augmented unlabeled data point $\alpha \left( u _ { b } \right)$ and strongly augmented unlabeled data point $\mathcal { A } \left( u _ { b } \right)$ generated by Cutout [10] and RandomAugment [8]. ReMixMatch predicts the class label of the weakly augmented unlabeled data point $\alpha \left( u _ { b } \right)$ using distribution alignment and sharpening, and assigns the predicted label to the strongly augmented unlabeled data point $\mathcal { A } \left( u _ { b } \right)$ . These strongly augmented unlabeled data point $\mathcal { A } \left( u _ { b } \right)$ and strongly augmented labeled data point $\boldsymbol { \mathcal { A } } \left( \boldsymbol { x } _ { b } \right)$ are used to conduct mixup regularization. ReMixMatch also conducts consistency regularization in a manner similar to FixMatch and selfsupervised learning using the rotation of the image [11, 39]. FixMatch and ReMixMatch have greatly improved the SSL performance by learning high-quality representations using strong data augmentation. However, these algorithms can be significantly biased toward the majority classes in class-imbalanced settings.
+
+Using FixMatch and ReMixMatch as the backbone of the proposed algorithm, we ensure that the ABC enjoys high-quality representations learned by the backbone, while replacing the backbone’s biased classifier. To train the ABC, we reuse the weakly augmented data and strongly augmented data used by the backbone to decrease the computational cost. Although we use FixMatch and ReMixMatch as the backbone in this study, the ABC can also be combined with other DNN-based SSL algorithms, as long as they use weakly augmented data and strongly augmented data.
+
+# 3.3 ABC for class-imbalanced Semi-supervised learning
+
+To train the ABC to be balanced, we first generate $0 / 1$ mask $M \left( x _ { b } \right)$ for each labeled data point $x _ { b }$ using a Bernoulli distribution $B \left( \cdot \right)$ with the parameter set to be inversely proportional to the number of data points of each class. This setting makes $B \left( \cdot \right)$ generate mask 1 with high probability for the data points in the minority classes, but with low probability for those in the majority classes. Then, the classification loss is multiplied by the generated mask, so that the ABC can be trained with a balanced classification loss. Multiplying the classification loss by the $0 / 1$ mask can be interpreted as oversampling of the data points in the minority classes, whereas it can be interpreted as undersampling of those in the majority classes. In representation learning, oversampling and undersampling techniques have shown overfitting and information loss problems, respectively. In contrast, the ABC can overcome these problems because it uses the representations learned by the backbone, which is trained on all data points in the minibatch. The use of the $0 / 1$ mask to construct the balanced loss, instead of directly creating a balanced subset, allows the backbone and the ABC to be trained from the same minibatches. Therefore, the representations of minibatches calculated for training the backbone can be used again for training the ABC. Consequently, the proposed algorithm only requires a slightly increased time cost compared to training the backbone alone. This is confirmed in Section 4.3. The overall procedure of balanced training with $0 / 1$ mask for the ABC attached to a representation layer of the backbone is presented in Figure 2. The classification loss for the ABC, $L _ { c l s }$ , with $0 / 1$ mask $M \left( \cdot \right)$ is expressed as
+
+$$
+L _ { c l s } = \frac { 1 } { B } \sum _ { b = 1 } ^ { B } M \left( x _ { b } \right) { \bf H } \left( p _ { s } \left( y | \alpha \left( x _ { b } \right) \right) , p _ { b } \right) ,
+$$
+
+$$
+M \left( x _ { b } \right) = B \left( \frac { N _ { L } } { N _ { y _ { b } } } \right) ,
+$$
+
+where $\mathbf { H }$ is the standard cross-entropy loss, $\alpha \left( { { x } _ { b } } \right)$ is an augmented labeled data point, $p _ { s } \left( y | \alpha \left( x _ { b } \right) \right)$ is the predicted class distribution using the ABC for $\alpha \left( \boldsymbol { x } _ { b } \right)$ , and $p _ { b }$ is the one-hot label for $x _ { b }$ .
+
+![](images/5a9db9f1d3e2324da36a716913047efaf57865391e43e3a60375b541bff55eaf.jpg)  
+Figure 2: Overall procedure for balanced training of the ABC with a $0 / 1$ mask
+
+# 3.4 Consistency regularization for ABC
+
+To increase the margin between the decision boundary and the data points using unlabeled data, we conduct consistency regularization for the ABC, similar to the way in FixMatch. Specifically, we first obtain the predicted class distribution $p _ { s } \left( y | \alpha \left( u _ { b } \right) \right)$ for a weakly augmented unlabeled data point $\alpha \left( u _ { b } \right)$ using the ABC and use it as a soft pseudo-label $q _ { b }$ . Then, for two strongly augmented unlabeled data points $\mathcal { A } _ { 1 } \left( u _ { b } \right)$ and $\mathcal { A } _ { 2 } \left( u _ { b } \right)$ , we train the ABC to produce their predicted class distributions, $p _ { s } \left( y | \mathcal { A } _ { 1 } \left( u _ { b } \right) \right)$ and $p _ { s } \left( y | \mathcal { A } _ { 2 } \left( u _ { b } \right) \right)$ , to be close to $q _ { b }$ .
+
+In class-imbalanced settings, because most unlabeled data points belong to majority classes, most weakly augmented unlabeled data points can be predicted as the majority classes. Then, consistency regularization would be conducted with a higher frequency for the majority classes, which can cause a classifier to be biased toward the majority classes. To prevent this issue, we conduct consistency regularization in a modified manner that is suitable for class-imbalance problems. Specifically, whereas FixMatch minimizes entropy by converting the predicted class distribution for a weakly augmented data point into a one-hot pseudo-label, we directly use the predicted class distribution as a soft pseudo-label. We do not pursue entropy minimization for the ABC because it can accelerate biased classification toward certain classes. Moreover, we once again generate $0 / 1$ mask $M \left( \cdot \right)$ for each unlabeled data point $u _ { b }$ based on a soft pseudo label $q _ { b }$ , and multiply the consistency regularization loss for $u _ { b }$ by the generated mask, so that the ABC can be trained with a class-balanced consistency regularization loss. Note that existing resampling techniques are not applicable to unlabeled data, because they require a label for each data point. In contrast, we make it possible to resample unlabeled data by using the soft pseudo-label and the $0 / 1$ mask. The consistency regularization loss, $L _ { c o n }$ , with $0 / 1$ mask $M \left( \cdot \right)$ is expressed as
+
+$$
+L _ { c o n } = \frac { 1 } { B } \sum _ { b = 1 } ^ { B } \sum _ { k = 1 } ^ { 2 } M \left( u _ { b } \right) { \bf I } \left( \operatorname* { m a x } \left( q _ { b } \right) \geq \tau \right) { \bf H } \left( p _ { s } \left( y | \mathcal { A } _ { k } \left( u _ { b } \right) \right) , q _ { b } \right) ,
+$$
+
+$$
+{ \cal M } \left( u _ { b } \right) = { \cal B } \left( \frac { N _ { L } } { N _ { \widehat { q } _ { b } } } \right) ,
+$$
+
+where $\mathbf { I }$ is the indicator function, $\operatorname* { m a x } \left( q _ { b } \right)$ is the highest predicted assignment probability for any class, representing the confidence of prediction, and $\tau$ is the confidence threshold. To avoid the unwanted effects of inaccurate soft pseudo-labels during consistency regularization, we only use the weakly augmented unlabeled data points whose confidence is higher than the threshold $\tau$ , similar to that in FixMatch. To take full advantage of few unlabeled data points with prediction confidence values that are higher than the confidence threshold $\tau$ in the early stage of training, we gradually decrease the parameter of the Bernoulli distribution $B \left( \cdot \right)$ for $u _ { b }$ from 1 to $N _ { L } / N _ { \widehat { q } b }$ , where $\widehat { q _ { b } }$ is the one-hot pseudo-label obtained from $q _ { b }$ b. Following previous studies [3, 24, 29, 4], we do bnot backpropagate gradients for pseudo-label prediction. The overall procedure for consistency regularization for the ABC is shown in Appendix A.
+
+# 3.5 End-to-end training
+
+Unlike a recent CIL trend to finetune a classifier in a balanced manner after representation learning is completed (i.e., decoupled learning of representations and a classifier) [17, 27], we obtain a balanced classifier by training the proposed algorithm end-to-end. We train the proposed algorithm with the sum of losses from Sections 3.3 and 3.4, and the loss for the backbone, $L _ { b a c k }$ . The total loss function $L _ { t o t a l }$ is expressed as
+
+$$
+L _ { t o t a l } = L _ { c l s } + L _ { c o n } + L _ { b a c k } .
+$$
+
+Whereas we use the sum of the losses for the backbone and ABC for training the proposed algorithm, we predict the class labels of new data points using only the ABC. In our experiments in Sections 4.4 and 4.5, we show that the proposed algorithm trained end-to-end produces better performance than competing algorithms with decoupled learning of representations and a classifier, and we analyze possible reasons. We present the pseudo code of the proposed algorithm in Appendix B.
+
+# 4 Experiments
+
+# 4.1 Experimental setup
+
+We created class-imbalanced versions of CIFAR-10, CIFAR-100 [21], and SVHN [25] datasets to conduct experiments under various ratios of class imbalance $\gamma$ and various ratios of the amount of labeled data $\beta$ . For class-imbalance types, we first consider long-tailed (LT) imbalance in which the number of data points exponentially decreases from the largest to the smallest class, i.e., $N _ { k } = N _ { 1 } \times \gamma ^ { - \frac { k - 1 } { L - 1 } }$ , where $\begin{array} { r } { \gamma = \frac { N _ { 1 } } { N _ { L } } } \end{array}$ N1 . We also consider step imbalance [5] in which the whole majority classes have the same amount of data and the whole minority classes also have the same amount of data. Two types of class imbalance for the considered datasets are illustrated in Appendix C. For the main setting, we set $\gamma = 1 0 0$ , $N _ { 1 } = 1 0 0 0$ , and $\beta = 2 0 \%$ for CIFAR-10 and SVHN, and $\gamma = 2 0$ , $N _ { 1 } = 2 0 0$ and $\beta = 4 0 \%$ for CIFAR-100. Similar to [18], we set $\gamma$ of CIFAR-100 to be relatively small because CIFAR-100 has only 500 training data points for each class. To evaluate the performance of the proposed algorithm on large-scale datasets, we also conducted experiments on 7.5M data points of 256 by 256 images from the LSUN dataset [37].
+
+We compared the performance of the proposed algorithm with that of various baseline algorithms. Specifically, we considered the following baseline algorithms:
+
+• Deep CNN (vanilla algorithm): This is trained on only labeled data with the cross-entropy loss.   
+• BALMS [27] (CIL algorithm): This state-of-the-art CIL algorithm does not use unlabeled data.   
+• VAT [24], ReMixMatch [3], and FixMatch [29] (SSL algorithms): These are state-of-the-art SSL algorithms, but do not consider class imbalance.   
+• FixMatch+CReST+PDA and ReMixMatch+CReST $^ +$ PDA (CISSL algorithms): CReST $^ { + }$ PDA [34] mitigates class imbalance by using unlabeled data points classified as the minority classes with a higher probability than those classified as the majority classes.   
+• ReMixMatch+DARP and FixMatch $+$ DARP (CISSL algorithms): These algorithms use DARP [18] to refine the pseudo labels obtained from ReMixMatch or FixMatch.   
+ReMixMatch+DARP $+ ($ cRT and FixMatch+DARP $+ \mathrm { c }$ RT (CISSL algorithms): Compared to ReMixMatch+DARP and FixMatch $+$ DARP, these algorithms finetune the classifier using cRT [17].
+
+For the structure of the deep CNN used in the proposed and baseline algorithms, we used Wide ResNet-28-2 [38]. We trained the proposed algorithm for 250, 000 iterations with a batch size of 64. The confidence threshold $\tau$ was set to 0.95 based on experiments with various values of $\tau$ in Appendix D. We used the Adam optimizer [20] with a learning rate of 0.002, and used Cutout [10] and RandomAugment [8] for strong data augmentation, following [18]. Similar to [3, 4], we evaluated the performance of the proposed algorithm using an exponential moving average of the parameters over iterations with a decay rate of 0.999, instead of scheduling the learning rate. In Tables 1-5, we used the overall accuracy and the accuracy only for minority classes as performance measures. We repeated the experiments five times under the main setting, and three times under the step imbalance and other settings of $\beta$ and $\gamma$ . We report the average and standard deviation of the performance measures over repeated experiments. For the vanilla algorithm, FixMatch+DARP $+ \mathrm { c R T }$ , and ReMixMatch $+$ DARP+cRT, which suffered from overfitting, we measured performance every 500 iterations and recorded the best performance. Further details of the experimental setup are described in Appendix E.
+
+# 4.2 Experimental results
+
+The performance of the competing algorithms under the main setting are summarized in Table 1. We can observe that the proposed algorithm achieved the highest overall performance, with improved performance for minority classes. Interestingly, VAT, an SSL algorithm, showed similar performance to the vanilla algorithm, and worse performance than BALMS, a CIL algorithm. Similarly, FixMatch and ReMixMatch, which do not consider class imbalance, showed poor performance for minority classes. Although BALMS mitigated class imbalance, it produced poor overall performance, as it did not use unlabeled data for training. This demonstrates the importance of using unlabeled data for training, even in the class-imbalanced setting. FixMatch+CReST $^ { + }$ PDA and ReMixMatch $^ +$ CReST $^ +$ PDA mitigated class imbalance by using unlabeled data points classified as the minority classes with a higher probability, but produced lower performance than the proposed algorithm. This may be because even if all unlabeled data points classified as minority classes are additionally used for training, their amount is still less than that of the data in majority classes, while the proposed algorithm uses class-balanced minibatches by generating the $0 / 1$ mask. Fixmatch+DARP and ReMixMatch+DARP slightly mitigated class imbalance by refining biased pseudo-labels, but resulted in lower performance than the proposed algorithm. This may be because even perfect pseudo labels cannot change the underlying class-imbalanced distribution of the training data. By additionally using a rebalancing technique cRT, FixMatch(ReMixMatch) ${ \bf \Lambda } + { \bf D } { \bf A } { \bf R } { \bf P } { \bf + c } { \bf R } { \bf T }$ performed better than FixMatch(ReMixMatch)+DARP. However, FixMatch(ReMixMatch) $\scriptstyle \mathbf { \Lambda } + \mathbf { D } \mathbf { A } \mathbf { R } \mathbf { P } + \mathbf { c } \mathbf { R } \mathbf { T }$ still performed worse than FixMatch(ReMixMatch) $+$ ABC, although it also uses high-quality representations learned by FixMatch(ReMixMatch) and techniques for mitigating class imbalance. The superior performance of FixMatch(ReMixMatch) $+$ ABC over FixMatch(ReMixMatch)+DARP+cRT is probably because FixMatch(ReMixMatch) $^ { + }$ ABC was trained end-to-end, and the ABC was also trained using unlabeled data. We discuss this in more detail in Sections 4.4 and 4.5. Overall, the algorithms combined with
+
+ReMixMatch performed better than the algorithms combined with FixMatch. In addition to the overall accuracy and minority-class-accuracy, we also compared the performance of the competing algorithms in terms of the geometric mean (G-mean) of class-wise accuracy under the main setting in Appendix F.
+
+Table 1: Overall accuracy/minority-class-accuracy under the main setting   
+
+<table><tr><td></td><td>CIFAR-10-LT</td><td>SVHN-LT</td><td>CIFAR-100-LT</td></tr><tr><td>Algorithm</td><td>γ = 100,β= 20%</td><td>γ = 100,β= 20%</td><td>γ = 20,β= 40%</td></tr><tr><td>Vanilla</td><td>55.3±1.30/33.9±1.88</td><td>77.0±0.67/63.3±1.25</td><td>40.1±1.15/ 25.2±0.95</td></tr><tr><td>VAT [24]</td><td>55.3±0.88/28.2±1.55</td><td>81.3±0.47/68.2±0.88</td><td>40.4±0.34/24.8±0.38</td></tr><tr><td>BALMS [27]</td><td>70.7±0.59/69.8±1.03</td><td>87.6±0.53/85.0±0.67</td><td>50.2±0.54/42.9±1.03</td></tr><tr><td>FixMatch [29]</td><td>72.3±0.33/ 53.8±0.63</td><td>88.0±0.30/ 79.4±0.54</td><td>51.0±0.20/32.8±0.41</td></tr><tr><td>w/CReST+PDA[34]</td><td>76.6±0.46/61.4±0.85</td><td>89.1±0.69/81.7±1.18</td><td>51.6±0.29/36.4±0.46</td></tr><tr><td>w/DARP[18]</td><td>73.7±0.98/57.0±2.12</td><td>88.6±0.19/80.5±0.54</td><td>51.4±0.37/33.9±0.77</td></tr><tr><td>w/DARP+cRT[18]</td><td>78.1±0.89/66.6±1.55</td><td>89.9±0.44/ 83.5±0.61</td><td>54.7±0.46/41.2±0.42</td></tr><tr><td>w/ ABC</td><td>81.1±0.82/ 72.0±1.77</td><td>92.0±0.38/ 87.9±0.73</td><td>56.3±0.19/43.4±0.42</td></tr><tr><td>ReMixMatch [3]</td><td>73.7±0.39/ 55.9±0.87</td><td>89.8±0.42/82.8±0.68</td><td>54.0±0.29/37.1±0.37</td></tr><tr><td>w/CReST+PDA[34]</td><td>75.7±0.34/59.6±0.76</td><td>90.9±0.20/85.2±0.39</td><td>54.6±0.48/38.1±0.69</td></tr><tr><td>w/DARP[18]</td><td>74.4±0.41/56.9±0.67</td><td>90.2±0.22/83.5±0.40</td><td>54.5±0.33/37.7±0.58</td></tr><tr><td>w/DARP+cRT[18]</td><td>78.5±0.61/66.4±1.68</td><td>92.1±0.48/87.6±0.75</td><td>55.1±0.45/43.6±0.58</td></tr><tr><td>w/ ABC</td><td>82.4±0.45/ 75.7±1.18</td><td>93.9±0.16/92.5±0.4</td><td>57.6±0.26/ 46.7±0.50</td></tr></table>
+
+To evaluate the performance of the proposed algorithm in various settings, we conducted experiments using ReMixMatch, FixMatch, and the CISSL algorithms considered in Table 1, while changing the ratio of class imbalance $\gamma$ and the ratio of the amount of labeled data $\beta$ . The results for CIFAR-10 are presented in Table 2, and the results for SVHN and CIFAR-100 are presented in Appendix G. In Table 2, we can observe that the proposed algorithm achieved the highest overall accuracy with greatly improved performance for minority classes for all settings. Because FixMatch+DARP+cRT and ReMixMatch+DARP+cRT do not use unlabeled data for classifier tuning, the difference in performance between FixMatch(ReMixMatch)+DARP+cRT and the proposed algorithm increased as the ratio of the amount of labeled data $\beta$ decreased and as the ratio of class imbalance $\gamma$ increased. In addition, the difference in performance between FixMatch(ReMixMatch)+CReST+PDA and the proposed algorithm tended to increase as the ratio of class imbalance $\gamma$ increased, because the difference between the number of labeled data points belonging to the majority classes and the number of unlabeled data points classified as the minority classes increases with $\gamma$ .
+
+Table 2: Overall accuracy/minority-class accuracy for CIFAR-10 under various settings   
+
+<table><tr><td colspan="5">CIFAR-10-LT</td></tr><tr><td>Algorithm</td><td>γ= 100,β = 10%</td><td>γ=100,β=30%</td><td>γ = 50,β= 20%</td><td>γ = 150,β= 20%</td></tr><tr><td>FixMatch [29]</td><td>70.0±0.59/ 48.9±1.04</td><td>74.9±0.63/ 58.2±1.28</td><td>81.2±0.07/ 70.7±0.36</td><td>68.5±0.60/ 45.8±1.15</td></tr><tr><td>w/CReST+PDA[34]</td><td>73.9±0.40/ 58.9±1.14</td><td>77.6±0.73/64.0±1.39</td><td>83.3±0.10/ 75.7±0.39</td><td>70.0±0.82/49.4±1.52</td></tr><tr><td>w/DARP+cRT[18]</td><td>74.6±0.98/ 59.2±2.12</td><td>79.0±0.25/67.7±0.95</td><td>83.6±0.42/77.1±1.19</td><td>73.2±0.85/ 57.1±1.13</td></tr><tr><td>w/ ABC</td><td>77.2±1.60/ 65.7±2.85</td><td>81.5±0.29/ 72.9±0.96</td><td>85.2±0.51/ 80.2±0.64</td><td>77.1±0.46/ 64.4±0.92</td></tr><tr><td>ReMixMatch [3]</td><td>71.5±0.51/ 52.2±1.08</td><td>75.8±0.10/ 59.4±0.17</td><td>81.5±0.17/70.7±0.32</td><td>69.9±0.23/48.4±0.60</td></tr><tr><td>w/CReST+PDA [34]</td><td>73.8±0.32/ 56.6±0.43</td><td>78.6±0.73/64.8±1.49</td><td>83.9±0.26/ 75.4±0.52</td><td>71.3±0.77/ 50.8±1.59</td></tr><tr><td>w/DARP+cRT[18]</td><td>75.9±1.20/62.1±3.10</td><td>81.0±0.16/70.7±0.72</td><td>84.5±0.80/ 77.8±1.67</td><td>73.9±0.59/ 57.4±1.45</td></tr><tr><td>w/ ABC</td><td>79.8±0.36/ 70.8±0.92</td><td>84.3±1.03/ 80.6±0.97</td><td>87.5±0.31/ 84.6±1.19</td><td>80.6±0.66/ 72.1±1.51</td></tr></table>
+
+We also conducted experiments under a step-imbalance setting, where the class imbalance was more noticeable. This setting assumes a more severely imbalanced class distribution than the LT imbalance settings, because half of the classes have very scarce data. The experimental results for CIFAR-10 are presented in Table 3, and the results for SVHN and CIFAR-100 are presented in Appendix H. In Table 3, we can see that the proposed algorithm achieved the best performance, and the performance margin is greater than that of the LT imbalance settings. ReMixMatch+CReST $^ +$ PDA showed relatively low performance compared to the other algorithms.
+
+Table 3: Overall accuracy/minority-class accuracy on CIFAR-10 under a step imbalance setting   
+
+<table><tr><td></td><td colspan="4">CIFAR-10-Step， γ= 100, β=20%</td></tr><tr><td>Algorithm</td><td>w/-</td><td>w/ CReST+PDA [34]</td><td>w/DARP+cRT[18]</td><td>w/ ABC</td></tr><tr><td>FixMatch [29]</td><td>54.0±0.84/ 11.8±1.71</td><td>71.1±0.78/48.2±2.26</td><td>69.8±1.51/ 45.1±2.70</td><td>75.9±0.49/ 57.0±1.07</td></tr><tr><td>ReMixMatch [3]</td><td>60.8±0.10/ 25.1±1.28</td><td>64.6±0.97/33.5±2.05</td><td>72.3±1.77/ 50.6±3.53</td><td>76.4±1.70/ 65.7±1.30</td></tr></table>
+
+To evaluate the performance of the proposed algorithm on a large-scale dataset, we also conducted experiments on the LSUN dataset [37], which is naturally a long-tailed dataset. Among the algorithms considered in Tables 2 and 3, those combined with CReST were excluded for comparison, because CReST requires loading of the whole unlabeled data in the repeated process of updating pseudolabels, which is not possible for the large-scale LSUN dataset. Instead, we additionally considered FixMatch $+ \mathrm { c R T }$ and ReMixMatch $+ \mathrm { c R T }$ for comparison. The experimental results are presented in Table 4. The proposed algorithm showed better performance than the other baseline algorithms. DARP resulted in degradation of the performance, possibly because the scale of the LSUN dataset is very large. Specifically, DARP solves a convex optimization with all unlabeled data points to refine the pseudo labels. As the scale of the unlabeled dataset increases, this optimization problem becomes more difficult to solve and, consequently, the pseudo-labels could be refined inaccurately. Unlike the results for other datasets, the algorithms combined with FixMatch performed better than the algorithms combined with ReMixMatch.
+
+Table 4: Overall accuracy/minority-class accuracy for the large-scale LSUN dataset   
+
+<table><tr><td></td><td>LSUN,</td><td colspan="4">γ=100, β=20%</td></tr><tr><td>Algorithm</td><td>w/-</td><td>w/ cRT[17]</td><td>w/ DARP [18]</td><td>w/ DARP+cRT[18]</td><td> w/ ABC</td></tr><tr><td>FixMatch [29]</td><td>73.1/ 55.3</td><td>77.0/71.5</td><td>71.0/ 51.8</td><td>75.8/ 69.5</td><td>78.9 / 75.5</td></tr><tr><td>ReMixMatch [3]</td><td>69.4/49.1</td><td>75.4/ 69.5</td><td>65.6 /44.1</td><td>72.1/67.5</td><td>76.9 / 69.5</td></tr></table>
+
+# 4.3 Complexity of the proposed algorithm
+
+The proposed algorithm requires additional parameters for the ABC, but the number of the additional parameters is negligible compared to the number of parameters of the backbone. For example, the ABC additionally required only $0 . 0 9 \%$ and $0 . 8 7 \%$ of the number of backbone parameters for CIFAR-10 with 10 classes and CIFAR-100 with 100 classes, respectively. Moreover, because the ABC shares the representation layer of the backbone, it does not significantly increase the memory usage and training time. Furthermore, we could train the proposed algorithm on the large-scale LSUN dataset without a significant increase in computation cost, because the entire training procedure could be carried out using minibatches of data. In contrast, the algorithms combined with DARP required convex optimization for all pseudo-labels, which significantly increased the computation cost as the number of classes or the amount of data increased. Similarly, it required significant time to train the algorithms combined with CReST, because CReST requires iterative re-training with a labeled set expanded by adding unlabeled data points with pseudo-labels. We present the floating point operations per second (FLOPS) for each algorithm using Nvidia Tesla-V100 in Appendix I.
+
+# 4.4 Qualitative analysis of high-quality representations and balanced classification
+
+The ABC can use high-quality representations learned by the backbone when performing balanced classification. To verify this, in Figure 3, we present t-distributed stochastic neighbor embedding (t-SNE) [31] of the representations of the CIFAR-10 test set learned by the ABC (without SSL backbone), FixMatch+ABC, and ReMixMatch+ABC on CIFAR-10-LT under the main setting. Different colors indicate different classes. As expected, “ABC (without SSL backbone)" failed to learn class-separable representations because sufficient data were not used for training while using the $0 / 1$ mask. In contrast, by training the backbone (FixMatch or ReMixMatch) together with the ABC, the proposed algorithm could use the entire data and learn high-quality representations. In this example, ReMixMatch produced more separable representations than FixMatch, which shows that the choice of the backbone affects the performance of the proposed algorithm, as expected.
+
+![](images/99227d1cab7c7773431bcec650838ce8292a71f841ed6eb6e75b912c4f996a19.jpg)  
+Figure 3: t-SNE of the proposed algorithm and the ABC (without SSL backbone)
+
+The proposed algorithm can also mitigate class imbalance by using the ABC. To verify this, we compare the confusion matrices of the predictions on the test set of CIFAR-10 using ReMixMatch, ReMixMatch $^ +$ DARP+cRT, and ReMiMatch $^ { 1 + }$ ABC trained on CIFAR-10 under the main setting in Figure 4. In the confusion matrices, the value in the ith row and the $j$ th column represents the ratio of the amount of data belonging to the ith class to the amount of data predicted as the $j$ th class. Each cell has a darker red color when the ratio is larger. We can see that ReMixMatch often misclassified data points in the minority classes (e.g., classes 8 and 9 into classes 0 and 1). This may be because ReMixMatch does not consider class imbalance, and thus biased pseudo-labels were used for training. ReMixMatch+DARP+cRT produced a more balanced class-distribution compared to ReMixMatch by additionally using DARP $+ \mathrm { c R T }$ . However, a significant number of data points in the minority classes were still misclassified as majority classes. In contrast, ReMixMatch+ABC classified the test data points in the minority classes with higher accuracy, and produced a significantly more balanced class distribution than ReMixMatch+DARP $+ \mathrm { c }$ RT, as shown in Figure 4 (c). As both ReMixMatch+DARP+cRT and ReMixMatch $+$ ABC use ReMixMatch to learn representations, the performance gap between these two algorithms results from the different characteristics of the ABC versus DARP $+$ cRT as follows. First, DARP $^ +$ cRT does not use unlabeled data for training its classifier after representations learning is completed, whereas the ABC uses unlabeled data with unbiased pseudo-labels for its training. Second, whereas DARP $+ \mathrm { c }$ RT decouples the learning of representations and training of a classifier, the ABC is trained end-to-end interactively with representations learned by the backbone. We also present the confusion matrices of the predictions on the test set of CIFAR-10 using FixMatch, FixMatch+DARP+cRT, and FixMatch+ABC as well as the confusion matrices of the pseudo-labels on the same dataset using ReMixMatch, ReMixMatch+DARP $+ \mathrm { c }$ RT, ReMixMatch $+$ ABC, FixMatch, FixMatch $+ \mathrm { D A R P + c R T } ,$ , and FixMatch $+$ ABC in Appendix J. Moreover, we compare the ABC and the classifier of DARP+cRT in more detail using the validation loss plots in Appendix K.
+
+![](images/b3b1fb935d28f783a03a39935157713174f789746071a48a7f010399e9aa1a52.jpg)  
+Figure 4: Confusion matrices of the predictions on the test set of CIFAR-10
+
+# 4.5 Ablation study
+
+We conducted an ablation study on CIFAR-10-LT in the main setting to investigate the effect of each element of the proposed algorithm. The results for ReMixMatch+ABC are presented in Table 5, where each row indicates the proposed algorithm with the described conditions in that row. The results are summarized as follows. 1) If we did not gradually decrease the parameter of the Bernoulli distribution $B \left( \cdot \right)$ when conducting consistency regularization, then an overbalance problem occurred because of unlabeled data misclassified as minority classes. 2) Without consistency regularization for the ABC, the decision boundary did not clearly separate each class. 3) Without using the $0 / 1$ mask for $L _ { c l s }$ and $L _ { c o n }$ , the ABC was trained to be biased toward the majority classes. 4) Without confidence threshold $\tau$ for consistency regularization, training became unstable and, consequently, the ABC was trained to be biased toward certain classes. 5) Similarly, if hard pseudo-labels, instead of soft pseudo-labels, were used for consistency regularization, then the ABC was biased toward certain classes. 6) If the ABC was solely used without the backbone, the performance decreased because the ABC could not use high-quality representations learned by the backbone. 7) When we used a re-weighting technique [13] instead of a mask for the ABC, training became unstable because of abnormally large gradients calculated for training on the data of the minority classes. 8) The decoupled training of the backbone and ABC resulted in decreased classification performance, as was also analyzed in Section 4.4. Similarly, we present the results of the ablation study for FixMatch $+$ ABC in Appendix L.
+
+Table 5: Ablation study for ReMixMatch $^ +$ ABC on CIFAR-10-LT, $\gamma = 1 0 0$ , $\beta = 2 0 \%$   
+
+<table><tr><td>Ablation study</td><td>Overall</td><td>Minority</td></tr><tr><td>ReMixMatch+ABC (proposed algorithm)</td><td>82.4</td><td>75.7</td></tr><tr><td>Without gradually decreasing the parameter of B(-) for consistency regularization</td><td>81.8</td><td>74.6</td></tr><tr><td>Without consistency regularization for the ABC</td><td>79.4</td><td>66.9</td></tr><tr><td>Without using the O/1 mask for the consistency regularization loss Lcon</td><td>79.0</td><td>69.2</td></tr><tr><td>Without using the O/1 mask for the classification loss Lcl s</td><td>74.4</td><td>57.8</td></tr><tr><td>Without using the confidence threshold T for consistency regularization</td><td>74.3</td><td>75.4</td></tr><tr><td>Using hard pseudo labels for consistency regularization</td><td>70.2</td><td>75.1</td></tr><tr><td>Without training backbone (ABC without SSL backbone)</td><td>68.7</td><td>56.2</td></tr><tr><td>Training the ABC with a re-weighting technique</td><td>81.2</td><td>74.1</td></tr><tr><td>Decoupled training of the backbone and ABC</td><td>79.5</td><td>72.3</td></tr></table>
+
+# 5 Conclusion
+
+We introduced the ABC, which is attached to a state-of-the-art SSL algorithm, for CISSL. The ABC can utilize high-quality representations learned by the backbone, while being trained to make classbalanced predictions. The ABC also utilizes unlabeled data by conducting consistency regularization in a modified way for class-imbalance problems. The experimental results obtained under various settings demonstrate that the proposed algorithm outperforms the baseline algorithms. We also conducted a qualitative analysis and an ablation study to verify the contribution of each element of the proposed algorithm. The proposed algorithm assumes that the labeled and unlabeled data are class-imbalanced to the same extent. In the future, we plan to release this assumption by adopting a module for estimating class distribution. Deep learning algorithms can be applied to many societal problems. However, if the training data are imbalanced, the algorithms could be trained to make socially biased decisions in favor of the majority groups. The proposed algorithm can contribute to solving these issues. However, there is also a potential risk that the proposed algorithm could be used as a tool to identify minorities and discriminate against them. It should be ensured that the proposed method cannot be used for any purpose that may have negative social impacts.
+
+# Acknowledgments
+
+This work was supported by the National Research Foundation of Korea (NRF) grant funded by the Korea government (MSIT) (2018R1C1B6004511, 2020R1A4A10187747).
+
+# References
+
+[1] An, J., Ying, L., and Zhu, Y. (2021). Why resampling outperforms reweighting for correcting sampling bias with stochastic gradients. In International Conference on Learning Representations. [2] Barandela, R., Rangel, E., Sánchez, J. S., and Ferri, F. J. (2003). Restricted decontamination for the imbalanced training sample problem. In Iberoamerican congress on pattern recognition, pages 424–431. Springer.
+
+[3] Berthelot, D., Carlini, N., Cubuk, E. D., Kurakin, A., Sohn, K., Zhang, H., and Raffel, C. (2019a). Remixmatch: Semi-supervised learning with distribution matching and augmentation anchoring. In International Conference on Learning Representations.
+
+[4] Berthelot, D., Carlini, N., Goodfellow, I., Papernot, N., Oliver, A., and Raffel, C. A. (2019b). Mixmatch: A holistic approach to semi-supervised learning. In Wallach, H., Larochelle, H., Beygelzimer, A., d'Alché-Buc, F., Fox, E., and Garnett, R., editors, Advances in Neural Information Processing Systems, volume 32. Curran Associates, Inc.
+
+[5] Buda, M., Maki, A., and Mazurowski, M. A. (2018). A systematic study of the class imbalance problem in convolutional neural networks. Neural Networks, 106:249–259.
+
+[6] Cao, K., Wei, C., Gaidon, A., Arechiga, N., and Ma, T. (2019). Learning imbalanced datasets with label-distribution-aware margin loss. In Wallach, H., Larochelle, H., Beygelzimer, A., d'Alché-Buc, F., Fox, E., and Garnett, R., editors, Advances in Neural Information Processing Systems, volume 32. Curran Associates, Inc.
+
+[7] Chawla, N. V., Bowyer, K. W., Hall, L. O., and Kegelmeyer, W. P. (2002). Smote: synthetic minority over-sampling technique. Journal of artificial intelligence research, 16:321–357.
+
+[8] Cubuk, E. D., Zoph, B., Shlens, J., and Le, Q. V. (2020). Randaugment: Practical automated data augmentation with a reduced search space. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition Workshops, pages 702–703.
+
+[9] Cui, Y., Jia, M., Lin, T.-Y., Song, Y., and Belongie, S. (2019). Class-balanced loss based on effective number of samples. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 9268–9277.
+
+[10] DeVries, T. and Taylor, G. W. (2017). Improved regularization of convolutional neural networks with cutout. arXiv preprint arXiv:1708.04552.
+
+[11] Gidaris, S., Singh, P., and Komodakis, N. (2018). Unsupervised representation learning by predicting image rotations. In International Conference on Learning Representations.
+
+[12] Grandvalet, Y. and Bengio, Y. (2005). Semi-supervised learning by entropy minimization. In Saul, L., Weiss, Y., and Bottou, L., editors, Advances in Neural Information Processing Systems, volume 17. MIT Press.
+
+[13] He, H. and Garcia, E. A. (2009). Learning from imbalanced data. IEEE Transactions on knowledge and data engineering, 21(9):1263–1284.
+
+[14] Huang, C., Li, Y., Loy, C. C., and Tang, X. (2016). Learning deep representation for imbalanced classification. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 5375–5384.
+
+[15] Jamal, M. A., Brown, M., Yang, M.-H., Wang, L., and Gong, B. (2020). Rethinking classbalanced methods for long-tailed visual recognition from a domain adaptation perspective. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 7610–7619.
+
+[16] JAPKOWICZ, N. (2000). The class imbalance problem: Significance and strategies. In Proc. 2000 International Conference on Artificial Intelligence, volume 1, pages 111–117.
+
+[17] Kang, B., Xie, S., Rohrbach, M., Yan, Z., Gordo, A., Feng, J., and Kalantidis, Y. (2020). Decoupling representation and classifier for long-tailed recognition. In International Conference on Learning Representations.
+
+[18] Kim, J., Hur, Y., Park, S., Yang, E., Hwang, S. J., and Shin, J. (2020a). Distribution aligning refinery of pseudo-label for imbalanced semi-supervised learning. In Larochelle, H., Ranzato, M., Hadsell, R., Balcan, M. F., and Lin, H., editors, Advances in Neural Information Processing Systems, volume 33, pages 14567–14579. Curran Associates, Inc.
+
+[19] Kim, J., Jeong, J., and Shin, J. (2020b). M2m: Imbalanced classification via major-to-minor translation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 13896–13905.
+
+[20] Kingma, D. P. and Ba, J. (2015). Adam: A method for stochastic optimization. In ICLR, 2015.
+
+[21] Krizhevsky, A. (2009). Learning multiple layers of features from tiny images. Technical report, Department of Computer Science, University of Toronto.
+
+[22] Lee, D.-H. et al. (2013). Pseudo-label: The simple and efficient semi-supervised learning method for deep neural networks. In Workshop on challenges in representation learning, ICML, volume 3.
+
+[23] Mikolov, T., Sutskever, I., Chen, K., Corrado, G. S., and Dean, J. (2013). Distributed representations of words and phrases and their compositionality. In Burges, C. J. C., Bottou, L., Welling, M., Ghahramani, Z., and Weinberger, K. Q., editors, Advances in Neural Information Processing Systems, volume 26. Curran Associates, Inc.
+
+[24] Miyato, T., Maeda, S.-i., Koyama, M., and Ishii, S. (2018). Virtual adversarial training: a regularization method for supervised and semi-supervised learning. IEEE transactions on pattern analysis and machine intelligence, 41(8):1979–1993.
+
+[25] Netzer, Y., Wang, T., Coates, A., Bissacco, A., Wu, B., and Ng, A. Y. (2011). Reading digits in natural images with unsupervised feature learning. In NIPS Workshop, 2011.
+
+[26] Park, S., Park, J., Shin, S.-J., and Moon, I.-C. (2018). Adversarial dropout for supervised and semi-supervised learning. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 32.
+
+[27] Ren, J., Yu, C., sheng, s., Ma, X., Zhao, H., Yi, S., and Li, h. (2020). Balanced meta-softmax for long-tailed visual recognition. In Larochelle, H., Ranzato, M., Hadsell, R., Balcan, M. F., and Lin, H., editors, Advances in Neural Information Processing Systems, volume 33, pages 4175–4186. Curran Associates, Inc.
+
+[28] Ren, M., Zeng, W., Yang, B., and Urtasun, R. (2018). Learning to reweight examples for robust deep learning. In International Conference on Machine Learning, pages 4334–4343. PMLR.
+
+[29] Sohn, K., Berthelot, D., Carlini, N., Zhang, Z., Zhang, H., Raffel, C. A., Cubuk, E. D., Kurakin, A., and Li, C.-L. (2020). Fixmatch: Simplifying semi-supervised learning with consistency and confidence. Advances in Neural Information Processing Systems, 33.
+
+[30] Tarvainen, A. and Valpola, H. (2017). Mean teachers are better role models: Weight-averaged consistency targets improve semi-supervised deep learning results. In Guyon, I., Luxburg, U. V., Bengio, S., Wallach, H., Fergus, R., Vishwanathan, S., and Garnett, R., editors, Advances in Neural Information Processing Systems, volume 30. Curran Associates, Inc.
+
+[31] Van der Maaten, L. and Hinton, G. (2008). Visualizing data using t-sne. Journal of machine learning research, 9(11).
+
+[32] Verma, V., Lamb, A., Kannala, J., Bengio, Y., and Lopez-Paz, D. (2019). Interpolation consistency training for semi-supervised learning. In Proceedings of the Twenty-Eighth International Joint Conference on Artificial Intelligence, IJCAI-19, pages 3635–3641. International Joint Conferences on Artificial Intelligence Organization.
+
+[33] Wang, Y.-X., Ramanan, D., and Hebert, M. (2017). Learning to model the tail. In Guyon, I., Luxburg, U. V., Bengio, S., Wallach, H., Fergus, R., Vishwanathan, S., and Garnett, R., editors, Advances in Neural Information Processing Systems, volume 30. Curran Associates, Inc.
+
+[34] Wei, C., Sohn, K., Mellina, C., Yuille, A., and Yang, F. (2021). Crest: A class-rebalancing selftraining framework for imbalanced semi-supervised learning. arXiv preprint arXiv:2102.09559.
+
+[35] Yang, Y. and Xu, Z. (2020). Rethinking the value of labels for improving class-imbalanced learning. In Larochelle, H., Ranzato, M., Hadsell, R., Balcan, M. F., and Lin, H., editors, Advances in Neural Information Processing Systems, volume 33, pages 19290–19301. Curran Associates, Inc.
+
+[36] Yin, X., Yu, X., Sohn, K., Liu, X., and Chandraker, M. (2018). Feature transfer learning for deep face recognition with under-represented data. arXiv e-prints, pages arXiv–1803.
+
+[37] Yu, F., Zhang, Y., Song, S., Seff, A., and Xiao, J. (2015). Lsun: Construction of a large-scale image dataset using deep learning with humans in the loop. arXiv preprint arXiv:1506.03365.   
+[38] Zagoruyko, S. and Komodakis, N. (2016). Wide residual networks. arXiv preprint arXiv:1605.07146.   
+[39] Zhai, X., Oliver, A., Kolesnikov, A., and Beyer, L. (2019). S4l: Self-supervised semi-supervised learning. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 1476–1485.
+
+# Checklist
+
+1. For all authors...
+
+(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   
+(b) Did you describe the limitations of your work? [Yes] See Section 5.   
+(c) Did you discuss any potential negative societal impacts of your work? [Yes] See Section 5.   
+(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes]
+
+2. If you are including theoretical results...
+
+(a) Did you state the full set of assumptions of all theoretical results? [N/A] (b) Did you include complete proofs of all theoretical results? [N/A]
+
+3. If you ran experiments...
+
+(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes] We included the code and instruction in the supplemental material. We will also upload the code at githup with the copyright after the review process.   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] See Section 4.1 and Appendix E.   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes] See Section 4.2.   
+(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] We summarize the resources and FLOPS in Section 4.2 and Appendix I.
+
+4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...
+
+(a) If your work uses existing assets, did you cite the creators? [Yes] We cited the creators of CIFAR-10, SVHN, CIFAR-100, LSUN in Section 4.1.   
+(b) Did you mention the license of the assets? [N/A] In their homepage, the creators of the datasets request to cite their work rather than mentioning the license.   
+(c) Did you include any new assets either in the supplemental material or as a URL? [Yes] We included the code for training the proposed algorithm as the supplemental material. We will also upload it at githup with the copyright after review process.   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A] We used the benchmark datasets cited in Section 4.1   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] We used the benchmark datasets cited in Section 4.1
+
+5. If you used crowdsourcing or conducted research with human subjects...
+
+(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   
+(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   
+(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A]

parse/train/1G6jPa9SKYG/1G6jPa9SKYG_content_list.json

@@ -0,0 +1,1371 @@
+[
+    {
+        "type": "text",
+        "text": "ABC: Auxiliary Balanced Classifier for Class-Imbalanced Semi-Supervised Learning ",
+        "text_level": 1,
+        "bbox": [
+            228,
+            122,
+            772,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Hyuck Lee Seungjae Shin Heeyoung Kim Department of Industrial and Systems Engineering, KAIST {dlgur0921, tmdwo0910, heeyoungkim}@kaist.ac.kr ",
+        "bbox": [
+            295,
+            226,
+            699,
+            268
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            304,
+            535,
+            320
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Existing semi-supervised learning (SSL) algorithms typically assume classbalanced datasets, although the class distributions of many real-world datasets are imbalanced. In general, classifiers trained on a class-imbalanced dataset are biased toward the majority classes. This issue becomes more problematic for SSL algorithms because they utilize the biased prediction of unlabeled data for training. However, traditional class-imbalanced learning techniques, which are designed for labeled data, cannot be readily combined with SSL algorithms. We propose a scalable class-imbalanced SSL algorithm that can effectively use unlabeled data, while mitigating class imbalance by introducing an auxiliary balanced classifier (ABC) of a single layer, which is attached to a representation layer of an existing SSL algorithm. The ABC is trained with a class-balanced loss of a minibatch, while using high-quality representations learned from all data points in the minibatch using the backbone SSL algorithm to avoid overfitting and information loss. Moreover, we use consistency regularization, a recent SSL technique for utilizing unlabeled data in a modified way, to train the ABC to be balanced among the classes by selecting unlabeled data with the same probability for each class. The proposed algorithm achieves state-of-the-art performance in various class-imbalanced SSL experiments using four benchmark datasets. ",
+        "bbox": [
+            233,
+            335,
+            766,
+            584
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            612,
+            310,
+            628
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recently, numerous deep neural network (DNN)-based semi-supervised learning (SSL) algorithms have been proposed to improve the performance of DNNs by utilizing unlabeled data when only a small amount of labeled data is available. These algorithms have shown effective performance in various tasks. However, most existing SSL algorithms assume class-balanced datasets, whereas the class distributions of many real-world datasets are imbalanced. It is well known that classifiers trained on class-imbalanced data tend to be biased toward the majority classes. This issue can be more problematic for SSL algorithms that use predicted labels of unlabeled data for their training, because the labels predicted by the algorithm trained on class-imbalanced data become even more severely imbalanced [18]. For example, Figure 1 (b) presents biased predictions of ReMixMatch [3], a recent SSL algorithm, trained on CIFAR-10-LT, which is a class-imbalanced dataset with the amount of Class 0 being 100 times more than that of Class 9, as depicted in Figure 1 (a). Although there are various class-imbalanced learning techniques, they are usually designed for labeled data, and thus cannot be simply combined with SSL algorithms under class-imbalanced SSL (CISSL) scenarios. Recently, a few CISSL algorithms have been proposed, but the CISSL problem is still underexplored. ",
+        "bbox": [
+            174,
+            643,
+            825,
+            851
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We propose a new CISSL algorithm that can effectively use unlabeled data, while mitigating class imbalance by using an existing DNN-based SSL algorithm [3, 29] as the backbone and introducing an auxiliary balanced classifier (ABC) of a single layer. The ABC is attached to a representation layer immediately preceding the classification layer of the backbone, based on the argument that a classification algorithm (i.e., backbone) can learn high-quality representations even if its classifier is biased toward the majority classes [17]. The ABC is trained to be balanced across all classes by using a mask that rebalances the class distribution, similar to re-sampling in previous SSL studies [2, 7, 13, 16]. Specifically, the mask stochastically regenerates a class-balanced subset of a minibatch on which the ABC is trained. The ABC is trained simultaneously with the backbone, so that the ABC can use high-quality representations learned from all data points in the minibatch using the backbone. In this way, the ABC can overcome the limitations of the previous resampling techniques, overfitting on minority-class data or loss of information on majority-class data [6, 27]. ",
+        "bbox": [
+            176,
+            858,
+            823,
+            900
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/df2c958978da5885a0a028742c684c3549f043f86764924177c5704a1f1a45ba.jpg",
+        "image_caption": [
+            "Figure 1: Predictions on a class-balanced test set using ReMixMatch (b) and the proposed algorithm (c) trained on a class-imbalanced training set (a). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            192,
+            88,
+            810,
+            222
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            291,
+            825,
+            416
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Moreover, to place decision boundaries in low-density regions by utilizing unlabeled data, we use consistency regularization, a recent SSL technique, which enforces the classification outputs of two augmented or perturbed versions of the same unlabeled example to remain unchanged. In particular, we encourage the ABC to be balanced across classes when using consistency regularization by selecting unlabeled examples with the same probability for each class using a mask. Figure 1 (c) illustrates that compared to the results of ReMixMatch in Figure 1 (b), the class distribution of the predicted labels becomes more balanced using the proposed algorithm trained on the same dataset. Our experimental results under various scenarios demonstrate that the proposed algorithm achieves state-of-the-art performance. Through qualitative analysis and an ablation study, we further investigate the contribution of each component of the proposed algorithm. The code for the proposed algorithm is available at https://github.com/LeeHyuck/ABC. ",
+        "bbox": [
+            174,
+            422,
+            825,
+            575
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            595,
+            321,
+            613
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Semi-supervised learning (SSL) Recently, several SSL techniques that utilize unlabeled data have been proposed. Entropy minimization [12] encourages the classifier outputs to have low entropy for unlabeled data, as in pseudo-labels [22]. Mixup regularization [4, 32] makes the decision boundaries farther away from the data clusters by encouraging the prediction for an interpolation of two inputs to be the same as the interpolation of the prediction for each input. Consistency regularization [26, 24, 30] encourages a classifier to produce similar predictions for perturbed versions of the same unlabeled input. To create perturbed unlabeled inputs, various data augmentation techniques have been used. For example, FixMatch [29] and ReMixMatch [3] used strong augmentation methods such as Cutout [10] and RandomAugment [8]. FixMatch and ReMixMatch are used as the backbone of the proposed algorithm; they are described in Section 3.2. ",
+        "bbox": [
+            173,
+            628,
+            825,
+            767
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Class-imbalanced learning (CIL) As a popular approach for CIL, re-sampling techniques [16, 7, 2, 13] balance the number of training samples for each class in the training set. As another popular approach, re-weighting techniques [23, 14, 33] re-weight the loss for each class by a factor inversely proportional to the number of data points belonging to that class. Although these approaches are simple, they have some drawbacks. For example, oversampling from minority classes can cause overfitting, whereas undersampling from majority classes can cause information loss [6]. In the case of re-weighting, gradients can be calculated to be abnormally large when the class imbalance is severe, resulting in unstable training [6, 1]. Many attempts have been made to alleviate these problems, such as effective re-weighting [9] and meta-learning-based re-weighting [28, 15]. New forms of losses have also been proposed [6, 27]. In [36, 19], knowledge is transferred from the data of majority classes to the data of minority classes. These CIL algorithms were designed for labeled data and require label information; thus, they are not applicable to unlabeled data. In [17], it was found that biased classification is mainly due to the classification layer and that a classification algorithm can learn meaningful representations even from a class-imbalanced training set. Based on this finding, we design the ABC to use high-quality representations learned from class-imbalanced data utilizing FixMatch [29] and ReMixMatch [3]. ",
+        "bbox": [
+            174,
+            772,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            174
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Class-imbalanced semi-supervised learning (CISSL) There have been few studies on CISSL. In [35], it was found that more accurate decision boundaries can be obtained in class-imbalanced settings through self-supervised learning and semi-supervised learning. DARP [18] refines biased pseudolabels by solving a convex optimization problem. CReST [34], a recent self-training technique, mitigates class imbalance by using pseudo-labeled unlabeled data points classified as minority classes with a higher probability than those classified as majority classes. ",
+        "bbox": [
+            174,
+            181,
+            825,
+            263
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Methodology ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            286,
+            313,
+            305
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 Problem setting ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            320,
+            323,
+            335
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Suppose that we have a labeled dataset $\\mathcal { X } = \\{ ( x _ { n } , y _ { n } ) : n \\in ( 1 , . . . , N ) \\}$ , where $x _ { n } \\in \\mathbb { R } ^ { d }$ is the nth labeled data point and $y _ { n } \\in \\{ 1 , \\ldots , L \\}$ is the corresponding label. We also have an unlabeled dataset $\\mathcal { U } = \\{ ( u _ { m } ) : m \\in ( 1 , \\ldots , M ) \\}$ , where $u _ { m } \\in \\mathbb { R } ^ { d }$ is the mth unlabeled data point. We express the ratio of the amount of labeled data as $\\begin{array} { r } { \\beta = \\frac { N } { M + N } } \\end{array}$ NM+N . Generally, β < 0.5, because label acquisition is costly and laborious. We denote the number of labeled data points of class $l$ as $N _ { l }$ , i.e., $\\begin{array} { r } { \\sum _ { l = 1 } ^ { L } N _ { l } = N } \\end{array}$ , and assume that the $L$ classes are sorted according to cardinality in descending order, i.e., $N _ { 1 } \\geq N _ { 2 } \\geq \\cdot \\cdot \\cdot \\geq N _ { L }$ . We denote the ratio of the class imbalance as $\\begin{array} { r } { \\gamma = \\frac { N _ { 1 } } { N _ { L } } } \\end{array}$ N1 . Under class-imbalanced scenarios, $\\gamma \\gg 1$ . Following previous CIL studies, we define the half of the classes containing a large amount of data as the majority classes, and the other half of the classes, containing a small amount of data, as the minority classes. Following [34], we assume that $\\mathcal { X }$ and $\\mathcal { U }$ share the same class distribution, i.e., the labeled and unlabeled datasets are class-imbalanced to the same extent. From $\\mathcal { X }$ and $\\mathcal { U }$ , we generate minibatches $\\mathcal { M B } _ { \\mathcal { X } } = \\{ ( x _ { b } , y _ { b } ) : b \\in ( 1 , . . . , B ) \\} \\subset \\mathcal { X }$ and $\\mathcal { M B } _ { \\mathcal { U } } = \\{ ( u _ { b } ) : b \\in ( 1 , \\ldots , \\bar { B } ) \\} \\subset \\mathcal { U }$ for each iteration of training, where $B$ is the minibatch size. Using these minibatches for training, we aim to learn a model $f : \\mathbb { R } ^ { d }  \\{ 1 , . . . L \\}$ that performs effectively on a class-balanced test set. ",
+        "bbox": [
+            174,
+            347,
+            825,
+            568
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 Backbone SSL algorithm ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            587,
+            387,
+            602
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We attach the ABC to the backbone’s representation layer, so that it can utilize the high-quality representations learned by the backbone. We use FixMatch [29] or ReMixMatch [3] as the backbone, as these two have achieved state-of-the-art SSL performance. FixMatch uses the classification loss calculated from the weakly augmented labeled data point $\\alpha \\left( { { x } _ { b } } \\right)$ generated by flipping and cropping the image, and the consistency regularization loss calculated from the weakly augmented unlabeled data point $\\alpha \\left( u _ { b } \\right)$ and strongly augmented unlabeled data point $\\mathcal { A } \\left( u _ { b } \\right)$ generated by Cutout [10] and RandomAugment [8]. ReMixMatch predicts the class label of the weakly augmented unlabeled data point $\\alpha \\left( u _ { b } \\right)$ using distribution alignment and sharpening, and assigns the predicted label to the strongly augmented unlabeled data point $\\mathcal { A } \\left( u _ { b } \\right)$ . These strongly augmented unlabeled data point $\\mathcal { A } \\left( u _ { b } \\right)$ and strongly augmented labeled data point $\\boldsymbol { \\mathcal { A } } \\left( \\boldsymbol { x } _ { b } \\right)$ are used to conduct mixup regularization. ReMixMatch also conducts consistency regularization in a manner similar to FixMatch and selfsupervised learning using the rotation of the image [11, 39]. FixMatch and ReMixMatch have greatly improved the SSL performance by learning high-quality representations using strong data augmentation. However, these algorithms can be significantly biased toward the majority classes in class-imbalanced settings. ",
+        "bbox": [
+            173,
+            614,
+            825,
+            821
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Using FixMatch and ReMixMatch as the backbone of the proposed algorithm, we ensure that the ABC enjoys high-quality representations learned by the backbone, while replacing the backbone’s biased classifier. To train the ABC, we reuse the weakly augmented data and strongly augmented data used by the backbone to decrease the computational cost. Although we use FixMatch and ReMixMatch as the backbone in this study, the ABC can also be combined with other DNN-based SSL algorithms, as long as they use weakly augmented data and strongly augmented data. ",
+        "bbox": [
+            174,
+            828,
+            823,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.3 ABC for class-imbalanced Semi-supervised learning ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            90,
+            575,
+            106
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To train the ABC to be balanced, we first generate $0 / 1$ mask $M \\left( x _ { b } \\right)$ for each labeled data point $x _ { b }$ using a Bernoulli distribution $B \\left( \\cdot \\right)$ with the parameter set to be inversely proportional to the number of data points of each class. This setting makes $B \\left( \\cdot \\right)$ generate mask 1 with high probability for the data points in the minority classes, but with low probability for those in the majority classes. Then, the classification loss is multiplied by the generated mask, so that the ABC can be trained with a balanced classification loss. Multiplying the classification loss by the $0 / 1$ mask can be interpreted as oversampling of the data points in the minority classes, whereas it can be interpreted as undersampling of those in the majority classes. In representation learning, oversampling and undersampling techniques have shown overfitting and information loss problems, respectively. In contrast, the ABC can overcome these problems because it uses the representations learned by the backbone, which is trained on all data points in the minibatch. The use of the $0 / 1$ mask to construct the balanced loss, instead of directly creating a balanced subset, allows the backbone and the ABC to be trained from the same minibatches. Therefore, the representations of minibatches calculated for training the backbone can be used again for training the ABC. Consequently, the proposed algorithm only requires a slightly increased time cost compared to training the backbone alone. This is confirmed in Section 4.3. The overall procedure of balanced training with $0 / 1$ mask for the ABC attached to a representation layer of the backbone is presented in Figure 2. The classification loss for the ABC, $L _ { c l s }$ , with $0 / 1$ mask $M \\left( \\cdot \\right)$ is expressed as ",
+        "bbox": [
+            173,
+            116,
+            826,
+            366
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/da10984a6c21b193a9d099ed37c5a22559601bd152f6784649eb1936ffcc7a88.jpg",
+        "text": "$$\nL _ { c l s } = \\frac { 1 } { B } \\sum _ { b = 1 } ^ { B } M \\left( x _ { b } \\right) { \\bf H } \\left( p _ { s } \\left( y | \\alpha \\left( x _ { b } \\right) \\right) , p _ { b } \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            333,
+            373,
+            630,
+            416
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ef59381df6208106203a896e062c8e1897a467bef586ef5045ae18dc1bc84f21.jpg",
+        "text": "$$\nM \\left( x _ { b } \\right) = B \\left( \\frac { N _ { L } } { N _ { y _ { b } } } \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            408,
+            433,
+            557,
+            468
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { H }$ is the standard cross-entropy loss, $\\alpha \\left( { { x } _ { b } } \\right)$ is an augmented labeled data point, $p _ { s } \\left( y | \\alpha \\left( x _ { b } \\right) \\right)$ is the predicted class distribution using the ABC for $\\alpha \\left( \\boldsymbol { x } _ { b } \\right)$ , and $p _ { b }$ is the one-hot label for $x _ { b }$ . ",
+        "bbox": [
+            173,
+            474,
+            826,
+            503
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/5a9db9f1d3e2324da36a716913047efaf57865391e43e3a60375b541bff55eaf.jpg",
+        "image_caption": [
+            "Figure 2: Overall procedure for balanced training of the ABC with a $0 / 1$ mask "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            520,
+            799,
+            670
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.4 Consistency regularization for ABC ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            727,
+            460,
+            741
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To increase the margin between the decision boundary and the data points using unlabeled data, we conduct consistency regularization for the ABC, similar to the way in FixMatch. Specifically, we first obtain the predicted class distribution $p _ { s } \\left( y | \\alpha \\left( u _ { b } \\right) \\right)$ for a weakly augmented unlabeled data point $\\alpha \\left( u _ { b } \\right)$ using the ABC and use it as a soft pseudo-label $q _ { b }$ . Then, for two strongly augmented unlabeled data points $\\mathcal { A } _ { 1 } \\left( u _ { b } \\right)$ and $\\mathcal { A } _ { 2 } \\left( u _ { b } \\right)$ , we train the ABC to produce their predicted class distributions, $p _ { s } \\left( y | \\mathcal { A } _ { 1 } \\left( u _ { b } \\right) \\right)$ and $p _ { s } \\left( y | \\mathcal { A } _ { 2 } \\left( u _ { b } \\right) \\right)$ , to be close to $q _ { b }$ . ",
+        "bbox": [
+            173,
+            752,
+            825,
+            837
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In class-imbalanced settings, because most unlabeled data points belong to majority classes, most weakly augmented unlabeled data points can be predicted as the majority classes. Then, consistency regularization would be conducted with a higher frequency for the majority classes, which can cause a classifier to be biased toward the majority classes. To prevent this issue, we conduct consistency regularization in a modified manner that is suitable for class-imbalance problems. Specifically, whereas FixMatch minimizes entropy by converting the predicted class distribution for a weakly augmented data point into a one-hot pseudo-label, we directly use the predicted class distribution as a soft pseudo-label. We do not pursue entropy minimization for the ABC because it can accelerate biased classification toward certain classes. Moreover, we once again generate $0 / 1$ mask $M \\left( \\cdot \\right)$ for each unlabeled data point $u _ { b }$ based on a soft pseudo label $q _ { b }$ , and multiply the consistency regularization loss for $u _ { b }$ by the generated mask, so that the ABC can be trained with a class-balanced consistency regularization loss. Note that existing resampling techniques are not applicable to unlabeled data, because they require a label for each data point. In contrast, we make it possible to resample unlabeled data by using the soft pseudo-label and the $0 / 1$ mask. The consistency regularization loss, $L _ { c o n }$ , with $0 / 1$ mask $M \\left( \\cdot \\right)$ is expressed as ",
+        "bbox": [
+            174,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            825,
+            231
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ccf9dd324b4bddb9704338bea123cdff1f817d958cdb0bd53795cbf74e47c9a5.jpg",
+        "text": "$$\nL _ { c o n } = \\frac { 1 } { B } \\sum _ { b = 1 } ^ { B } \\sum _ { k = 1 } ^ { 2 } M \\left( u _ { b } \\right) { \\bf I } \\left( \\operatorname* { m a x } \\left( q _ { b } \\right) \\geq \\tau \\right) { \\bf H } \\left( p _ { s } \\left( y | \\mathcal { A } _ { k } \\left( u _ { b } \\right) \\right) , q _ { b } \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            254,
+            237,
+            709,
+            281
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7f30abaee01687ab937c3ec6934f1ff2019d40767ffde5ab28374c4b41f886e4.jpg",
+        "text": "$$\n{ \\cal M } \\left( u _ { b } \\right) = { \\cal B } \\left( \\frac { N _ { L } } { N _ { \\widehat { q } _ { b } } } \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            408,
+            296,
+            555,
+            332
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { I }$ is the indicator function, $\\operatorname* { m a x } \\left( q _ { b } \\right)$ is the highest predicted assignment probability for any class, representing the confidence of prediction, and $\\tau$ is the confidence threshold. To avoid the unwanted effects of inaccurate soft pseudo-labels during consistency regularization, we only use the weakly augmented unlabeled data points whose confidence is higher than the threshold $\\tau$ , similar to that in FixMatch. To take full advantage of few unlabeled data points with prediction confidence values that are higher than the confidence threshold $\\tau$ in the early stage of training, we gradually decrease the parameter of the Bernoulli distribution $B \\left( \\cdot \\right)$ for $u _ { b }$ from 1 to $N _ { L } / N _ { \\widehat { q } b }$ , where $\\widehat { q _ { b } }$ is the one-hot pseudo-label obtained from $q _ { b }$ b. Following previous studies [3, 24, 29, 4], we do bnot backpropagate gradients for pseudo-label prediction. The overall procedure for consistency regularization for the ABC is shown in Appendix A. ",
+        "bbox": [
+            173,
+            338,
+            825,
+            478
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.5 End-to-end training ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            493,
+            352,
+            508
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Unlike a recent CIL trend to finetune a classifier in a balanced manner after representation learning is completed (i.e., decoupled learning of representations and a classifier) [17, 27], we obtain a balanced classifier by training the proposed algorithm end-to-end. We train the proposed algorithm with the sum of losses from Sections 3.3 and 3.4, and the loss for the backbone, $L _ { b a c k }$ . The total loss function $L _ { t o t a l }$ is expressed as ",
+        "bbox": [
+            173,
+            518,
+            825,
+            588
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/626aa308a0fba538651defccfcbd41314511493e5098205235f1f4f43b0b4e95.jpg",
+        "text": "$$\nL _ { t o t a l } = L _ { c l s } + L _ { c o n } + L _ { b a c k } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            379,
+            597,
+            586,
+            613
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Whereas we use the sum of the losses for the backbone and ABC for training the proposed algorithm, we predict the class labels of new data points using only the ABC. In our experiments in Sections 4.4 and 4.5, we show that the proposed algorithm trained end-to-end produces better performance than competing algorithms with decoupled learning of representations and a classifier, and we analyze possible reasons. We present the pseudo code of the proposed algorithm in Appendix B. ",
+        "bbox": [
+            173,
+            619,
+            825,
+            690
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            710,
+            312,
+            727
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 Experimental setup ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            741,
+            349,
+            757
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We created class-imbalanced versions of CIFAR-10, CIFAR-100 [21], and SVHN [25] datasets to conduct experiments under various ratios of class imbalance $\\gamma$ and various ratios of the amount of labeled data $\\beta$ . For class-imbalance types, we first consider long-tailed (LT) imbalance in which the number of data points exponentially decreases from the largest to the smallest class, i.e., $N _ { k } = N _ { 1 } \\times \\gamma ^ { - \\frac { k - 1 } { L - 1 } }$ , where $\\begin{array} { r } { \\gamma = \\frac { N _ { 1 } } { N _ { L } } } \\end{array}$ N1 . We also consider step imbalance [5] in which the whole majority classes have the same amount of data and the whole minority classes also have the same amount of data. Two types of class imbalance for the considered datasets are illustrated in Appendix C. For the main setting, we set $\\gamma = 1 0 0$ , $N _ { 1 } = 1 0 0 0$ , and $\\beta = 2 0 \\%$ for CIFAR-10 and SVHN, and $\\gamma = 2 0$ , $N _ { 1 } = 2 0 0$ and $\\beta = 4 0 \\%$ for CIFAR-100. Similar to [18], we set $\\gamma$ of CIFAR-100 to be relatively small because CIFAR-100 has only 500 training data points for each class. To evaluate the performance of the proposed algorithm on large-scale datasets, we also conducted experiments on 7.5M data points of 256 by 256 images from the LSUN dataset [37]. ",
+        "bbox": [
+            173,
+            766,
+            826,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            92,
+            823,
+            119
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We compared the performance of the proposed algorithm with that of various baseline algorithms. Specifically, we considered the following baseline algorithms: ",
+        "bbox": [
+            169,
+            126,
+            825,
+            154
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "• Deep CNN (vanilla algorithm): This is trained on only labeled data with the cross-entropy loss.   \n• BALMS [27] (CIL algorithm): This state-of-the-art CIL algorithm does not use unlabeled data.   \n• VAT [24], ReMixMatch [3], and FixMatch [29] (SSL algorithms): These are state-of-the-art SSL algorithms, but do not consider class imbalance.   \n• FixMatch+CReST+PDA and ReMixMatch+CReST $^ +$ PDA (CISSL algorithms): CReST $^ { + }$ PDA [34] mitigates class imbalance by using unlabeled data points classified as the minority classes with a higher probability than those classified as the majority classes.   \n• ReMixMatch+DARP and FixMatch $+$ DARP (CISSL algorithms): These algorithms use DARP [18] to refine the pseudo labels obtained from ReMixMatch or FixMatch.   \nReMixMatch+DARP $+ ($ cRT and FixMatch+DARP $+ \\mathrm { c }$ RT (CISSL algorithms): Compared to ReMixMatch+DARP and FixMatch $+$ DARP, these algorithms finetune the classifier using cRT [17]. ",
+        "bbox": [
+            171,
+            162,
+            826,
+            345
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For the structure of the deep CNN used in the proposed and baseline algorithms, we used Wide ResNet-28-2 [38]. We trained the proposed algorithm for 250, 000 iterations with a batch size of 64. The confidence threshold $\\tau$ was set to 0.95 based on experiments with various values of $\\tau$ in Appendix D. We used the Adam optimizer [20] with a learning rate of 0.002, and used Cutout [10] and RandomAugment [8] for strong data augmentation, following [18]. Similar to [3, 4], we evaluated the performance of the proposed algorithm using an exponential moving average of the parameters over iterations with a decay rate of 0.999, instead of scheduling the learning rate. In Tables 1-5, we used the overall accuracy and the accuracy only for minority classes as performance measures. We repeated the experiments five times under the main setting, and three times under the step imbalance and other settings of $\\beta$ and $\\gamma$ . We report the average and standard deviation of the performance measures over repeated experiments. For the vanilla algorithm, FixMatch+DARP $+ \\mathrm { c R T }$ , and ReMixMatch $+$ DARP+cRT, which suffered from overfitting, we measured performance every 500 iterations and recorded the best performance. Further details of the experimental setup are described in Appendix E. ",
+        "bbox": [
+            173,
+            358,
+            825,
+            551
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 Experimental results ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            568,
+            357,
+            583
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The performance of the competing algorithms under the main setting are summarized in Table 1. We can observe that the proposed algorithm achieved the highest overall performance, with improved performance for minority classes. Interestingly, VAT, an SSL algorithm, showed similar performance to the vanilla algorithm, and worse performance than BALMS, a CIL algorithm. Similarly, FixMatch and ReMixMatch, which do not consider class imbalance, showed poor performance for minority classes. Although BALMS mitigated class imbalance, it produced poor overall performance, as it did not use unlabeled data for training. This demonstrates the importance of using unlabeled data for training, even in the class-imbalanced setting. FixMatch+CReST $^ { + }$ PDA and ReMixMatch $^ +$ CReST $^ +$ PDA mitigated class imbalance by using unlabeled data points classified as the minority classes with a higher probability, but produced lower performance than the proposed algorithm. This may be because even if all unlabeled data points classified as minority classes are additionally used for training, their amount is still less than that of the data in majority classes, while the proposed algorithm uses class-balanced minibatches by generating the $0 / 1$ mask. Fixmatch+DARP and ReMixMatch+DARP slightly mitigated class imbalance by refining biased pseudo-labels, but resulted in lower performance than the proposed algorithm. This may be because even perfect pseudo labels cannot change the underlying class-imbalanced distribution of the training data. By additionally using a rebalancing technique cRT, FixMatch(ReMixMatch) ${ \\bf \\Lambda } + { \\bf D } { \\bf A } { \\bf R } { \\bf P } { \\bf + c } { \\bf R } { \\bf T }$ performed better than FixMatch(ReMixMatch)+DARP. However, FixMatch(ReMixMatch) $\\scriptstyle \\mathbf { \\Lambda } + \\mathbf { D } \\mathbf { A } \\mathbf { R } \\mathbf { P } + \\mathbf { c } \\mathbf { R } \\mathbf { T }$ still performed worse than FixMatch(ReMixMatch) $+$ ABC, although it also uses high-quality representations learned by FixMatch(ReMixMatch) and techniques for mitigating class imbalance. The superior performance of FixMatch(ReMixMatch) $+$ ABC over FixMatch(ReMixMatch)+DARP+cRT is probably because FixMatch(ReMixMatch) $^ { + }$ ABC was trained end-to-end, and the ABC was also trained using unlabeled data. We discuss this in more detail in Sections 4.4 and 4.5. Overall, the algorithms combined with ",
+        "bbox": [
+            173,
+            593,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "ReMixMatch performed better than the algorithms combined with FixMatch. In addition to the overall accuracy and minority-class-accuracy, we also compared the performance of the competing algorithms in terms of the geometric mean (G-mean) of class-wise accuracy under the main setting in Appendix F. ",
+        "bbox": [
+            174,
+            90,
+            825,
+            147
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/ad2644cab29f932a7e9d5279a66cb055e873098ba35618663cff54bc9cebd4c0.jpg",
+        "table_caption": [
+            "Table 1: Overall accuracy/minority-class-accuracy under the main setting "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>CIFAR-10-LT</td><td>SVHN-LT</td><td>CIFAR-100-LT</td></tr><tr><td>Algorithm</td><td>γ = 100,β= 20%</td><td>γ = 100,β= 20%</td><td>γ = 20,β= 40%</td></tr><tr><td>Vanilla</td><td>55.3±1.30/33.9±1.88</td><td>77.0±0.67/63.3±1.25</td><td>40.1±1.15/ 25.2±0.95</td></tr><tr><td>VAT [24]</td><td>55.3±0.88/28.2±1.55</td><td>81.3±0.47/68.2±0.88</td><td>40.4±0.34/24.8±0.38</td></tr><tr><td>BALMS [27]</td><td>70.7±0.59/69.8±1.03</td><td>87.6±0.53/85.0±0.67</td><td>50.2±0.54/42.9±1.03</td></tr><tr><td>FixMatch [29]</td><td>72.3±0.33/ 53.8±0.63</td><td>88.0±0.30/ 79.4±0.54</td><td>51.0±0.20/32.8±0.41</td></tr><tr><td>w/CReST+PDA[34]</td><td>76.6±0.46/61.4±0.85</td><td>89.1±0.69/81.7±1.18</td><td>51.6±0.29/36.4±0.46</td></tr><tr><td>w/DARP[18]</td><td>73.7±0.98/57.0±2.12</td><td>88.6±0.19/80.5±0.54</td><td>51.4±0.37/33.9±0.77</td></tr><tr><td>w/DARP+cRT[18]</td><td>78.1±0.89/66.6±1.55</td><td>89.9±0.44/ 83.5±0.61</td><td>54.7±0.46/41.2±0.42</td></tr><tr><td>w/ ABC</td><td>81.1±0.82/ 72.0±1.77</td><td>92.0±0.38/ 87.9±0.73</td><td>56.3±0.19/43.4±0.42</td></tr><tr><td>ReMixMatch [3]</td><td>73.7±0.39/ 55.9±0.87</td><td>89.8±0.42/82.8±0.68</td><td>54.0±0.29/37.1±0.37</td></tr><tr><td>w/CReST+PDA[34]</td><td>75.7±0.34/59.6±0.76</td><td>90.9±0.20/85.2±0.39</td><td>54.6±0.48/38.1±0.69</td></tr><tr><td>w/DARP[18]</td><td>74.4±0.41/56.9±0.67</td><td>90.2±0.22/83.5±0.40</td><td>54.5±0.33/37.7±0.58</td></tr><tr><td>w/DARP+cRT[18]</td><td>78.5±0.61/66.4±1.68</td><td>92.1±0.48/87.6±0.75</td><td>55.1±0.45/43.6±0.58</td></tr><tr><td>w/ ABC</td><td>82.4±0.45/ 75.7±1.18</td><td>93.9±0.16/92.5±0.4</td><td>57.6±0.26/ 46.7±0.50</td></tr></table>",
+        "bbox": [
+            232,
+            186,
+            766,
+            397
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To evaluate the performance of the proposed algorithm in various settings, we conducted experiments using ReMixMatch, FixMatch, and the CISSL algorithms considered in Table 1, while changing the ratio of class imbalance $\\gamma$ and the ratio of the amount of labeled data $\\beta$ . The results for CIFAR-10 are presented in Table 2, and the results for SVHN and CIFAR-100 are presented in Appendix G. In Table 2, we can observe that the proposed algorithm achieved the highest overall accuracy with greatly improved performance for minority classes for all settings. Because FixMatch+DARP+cRT and ReMixMatch+DARP+cRT do not use unlabeled data for classifier tuning, the difference in performance between FixMatch(ReMixMatch)+DARP+cRT and the proposed algorithm increased as the ratio of the amount of labeled data $\\beta$ decreased and as the ratio of class imbalance $\\gamma$ increased. In addition, the difference in performance between FixMatch(ReMixMatch)+CReST+PDA and the proposed algorithm tended to increase as the ratio of class imbalance $\\gamma$ increased, because the difference between the number of labeled data points belonging to the majority classes and the number of unlabeled data points classified as the minority classes increases with $\\gamma$ . ",
+        "bbox": [
+            173,
+            424,
+            826,
+            604
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/f8e164c7646b41289de766c7a14e997d9ac0416a4722043c631f7c653bd1cb43.jpg",
+        "table_caption": [
+            "Table 2: Overall accuracy/minority-class accuracy for CIFAR-10 under various settings "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"5\">CIFAR-10-LT</td></tr><tr><td>Algorithm</td><td>γ= 100,β = 10%</td><td>γ=100,β=30%</td><td>γ = 50,β= 20%</td><td>γ = 150,β= 20%</td></tr><tr><td>FixMatch [29]</td><td>70.0±0.59/ 48.9±1.04</td><td>74.9±0.63/ 58.2±1.28</td><td>81.2±0.07/ 70.7±0.36</td><td>68.5±0.60/ 45.8±1.15</td></tr><tr><td>w/CReST+PDA[34]</td><td>73.9±0.40/ 58.9±1.14</td><td>77.6±0.73/64.0±1.39</td><td>83.3±0.10/ 75.7±0.39</td><td>70.0±0.82/49.4±1.52</td></tr><tr><td>w/DARP+cRT[18]</td><td>74.6±0.98/ 59.2±2.12</td><td>79.0±0.25/67.7±0.95</td><td>83.6±0.42/77.1±1.19</td><td>73.2±0.85/ 57.1±1.13</td></tr><tr><td>w/ ABC</td><td>77.2±1.60/ 65.7±2.85</td><td>81.5±0.29/ 72.9±0.96</td><td>85.2±0.51/ 80.2±0.64</td><td>77.1±0.46/ 64.4±0.92</td></tr><tr><td>ReMixMatch [3]</td><td>71.5±0.51/ 52.2±1.08</td><td>75.8±0.10/ 59.4±0.17</td><td>81.5±0.17/70.7±0.32</td><td>69.9±0.23/48.4±0.60</td></tr><tr><td>w/CReST+PDA [34]</td><td>73.8±0.32/ 56.6±0.43</td><td>78.6±0.73/64.8±1.49</td><td>83.9±0.26/ 75.4±0.52</td><td>71.3±0.77/ 50.8±1.59</td></tr><tr><td>w/DARP+cRT[18]</td><td>75.9±1.20/62.1±3.10</td><td>81.0±0.16/70.7±0.72</td><td>84.5±0.80/ 77.8±1.67</td><td>73.9±0.59/ 57.4±1.45</td></tr><tr><td>w/ ABC</td><td>79.8±0.36/ 70.8±0.92</td><td>84.3±1.03/ 80.6±0.97</td><td>87.5±0.31/ 84.6±1.19</td><td>80.6±0.66/ 72.1±1.51</td></tr></table>",
+        "bbox": [
+            173,
+            643,
+            826,
+            787
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We also conducted experiments under a step-imbalance setting, where the class imbalance was more noticeable. This setting assumes a more severely imbalanced class distribution than the LT imbalance settings, because half of the classes have very scarce data. The experimental results for CIFAR-10 are presented in Table 3, and the results for SVHN and CIFAR-100 are presented in Appendix H. In Table 3, we can see that the proposed algorithm achieved the best performance, and the performance margin is greater than that of the LT imbalance settings. ReMixMatch+CReST $^ +$ PDA showed relatively low performance compared to the other algorithms. ",
+        "bbox": [
+            173,
+            814,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/cf12eb155f5ad12965b6f7c651b62f2b37cb694515c8dcc541126008dbf4383c.jpg",
+        "table_caption": [
+            "Table 3: Overall accuracy/minority-class accuracy on CIFAR-10 under a step imbalance setting "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"4\">CIFAR-10-Step， γ= 100, β=20%</td></tr><tr><td>Algorithm</td><td>w/-</td><td>w/ CReST+PDA [34]</td><td>w/DARP+cRT[18]</td><td>w/ ABC</td></tr><tr><td>FixMatch [29]</td><td>54.0±0.84/ 11.8±1.71</td><td>71.1±0.78/48.2±2.26</td><td>69.8±1.51/ 45.1±2.70</td><td>75.9±0.49/ 57.0±1.07</td></tr><tr><td>ReMixMatch [3]</td><td>60.8±0.10/ 25.1±1.28</td><td>64.6±0.97/33.5±2.05</td><td>72.3±1.77/ 50.6±3.53</td><td>76.4±1.70/ 65.7±1.30</td></tr></table>",
+        "bbox": [
+            174,
+            109,
+            823,
+            179
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To evaluate the performance of the proposed algorithm on a large-scale dataset, we also conducted experiments on the LSUN dataset [37], which is naturally a long-tailed dataset. Among the algorithms considered in Tables 2 and 3, those combined with CReST were excluded for comparison, because CReST requires loading of the whole unlabeled data in the repeated process of updating pseudolabels, which is not possible for the large-scale LSUN dataset. Instead, we additionally considered FixMatch $+ \\mathrm { c R T }$ and ReMixMatch $+ \\mathrm { c R T }$ for comparison. The experimental results are presented in Table 4. The proposed algorithm showed better performance than the other baseline algorithms. DARP resulted in degradation of the performance, possibly because the scale of the LSUN dataset is very large. Specifically, DARP solves a convex optimization with all unlabeled data points to refine the pseudo labels. As the scale of the unlabeled dataset increases, this optimization problem becomes more difficult to solve and, consequently, the pseudo-labels could be refined inaccurately. Unlike the results for other datasets, the algorithms combined with FixMatch performed better than the algorithms combined with ReMixMatch. ",
+        "bbox": [
+            173,
+            205,
+            826,
+            385
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/b2376f108ff15ad325840eae9ab56e85c0c95757a31b5b11ce963a976f312940.jpg",
+        "table_caption": [
+            "Table 4: Overall accuracy/minority-class accuracy for the large-scale LSUN dataset "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>LSUN,</td><td colspan=\"4\">γ=100, β=20%</td></tr><tr><td>Algorithm</td><td>w/-</td><td>w/ cRT[17]</td><td>w/ DARP [18]</td><td>w/ DARP+cRT[18]</td><td> w/ ABC</td></tr><tr><td>FixMatch [29]</td><td>73.1/ 55.3</td><td>77.0/71.5</td><td>71.0/ 51.8</td><td>75.8/ 69.5</td><td>78.9 / 75.5</td></tr><tr><td>ReMixMatch [3]</td><td>69.4/49.1</td><td>75.4/ 69.5</td><td>65.6 /44.1</td><td>72.1/67.5</td><td>76.9 / 69.5</td></tr></table>",
+        "bbox": [
+            173,
+            420,
+            825,
+            491
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3 Complexity of the proposed algorithm ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            523,
+            477,
+            539
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The proposed algorithm requires additional parameters for the ABC, but the number of the additional parameters is negligible compared to the number of parameters of the backbone. For example, the ABC additionally required only $0 . 0 9 \\%$ and $0 . 8 7 \\%$ of the number of backbone parameters for CIFAR-10 with 10 classes and CIFAR-100 with 100 classes, respectively. Moreover, because the ABC shares the representation layer of the backbone, it does not significantly increase the memory usage and training time. Furthermore, we could train the proposed algorithm on the large-scale LSUN dataset without a significant increase in computation cost, because the entire training procedure could be carried out using minibatches of data. In contrast, the algorithms combined with DARP required convex optimization for all pseudo-labels, which significantly increased the computation cost as the number of classes or the amount of data increased. Similarly, it required significant time to train the algorithms combined with CReST, because CReST requires iterative re-training with a labeled set expanded by adding unlabeled data points with pseudo-labels. We present the floating point operations per second (FLOPS) for each algorithm using Nvidia Tesla-V100 in Appendix I. ",
+        "bbox": [
+            173,
+            549,
+            825,
+            729
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.4 Qualitative analysis of high-quality representations and balanced classification ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            747,
+            756,
+            762
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The ABC can use high-quality representations learned by the backbone when performing balanced classification. To verify this, in Figure 3, we present t-distributed stochastic neighbor embedding (t-SNE) [31] of the representations of the CIFAR-10 test set learned by the ABC (without SSL backbone), FixMatch+ABC, and ReMixMatch+ABC on CIFAR-10-LT under the main setting. Different colors indicate different classes. As expected, “ABC (without SSL backbone)\" failed to learn class-separable representations because sufficient data were not used for training while using the $0 / 1$ mask. In contrast, by training the backbone (FixMatch or ReMixMatch) together with the ABC, the proposed algorithm could use the entire data and learn high-quality representations. In this example, ReMixMatch produced more separable representations than FixMatch, which shows that the choice of the backbone affects the performance of the proposed algorithm, as expected. ",
+        "bbox": [
+            174,
+            772,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/99227d1cab7c7773431bcec650838ce8292a71f841ed6eb6e75b912c4f996a19.jpg",
+        "image_caption": [
+            "Figure 3: t-SNE of the proposed algorithm and the ABC (without SSL backbone) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            200,
+            88,
+            794,
+            190
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The proposed algorithm can also mitigate class imbalance by using the ABC. To verify this, we compare the confusion matrices of the predictions on the test set of CIFAR-10 using ReMixMatch, ReMixMatch $^ +$ DARP+cRT, and ReMiMatch $^ { 1 + }$ ABC trained on CIFAR-10 under the main setting in Figure 4. In the confusion matrices, the value in the ith row and the $j$ th column represents the ratio of the amount of data belonging to the ith class to the amount of data predicted as the $j$ th class. Each cell has a darker red color when the ratio is larger. We can see that ReMixMatch often misclassified data points in the minority classes (e.g., classes 8 and 9 into classes 0 and 1). This may be because ReMixMatch does not consider class imbalance, and thus biased pseudo-labels were used for training. ReMixMatch+DARP+cRT produced a more balanced class-distribution compared to ReMixMatch by additionally using DARP $+ \\mathrm { c R T }$ . However, a significant number of data points in the minority classes were still misclassified as majority classes. In contrast, ReMixMatch+ABC classified the test data points in the minority classes with higher accuracy, and produced a significantly more balanced class distribution than ReMixMatch+DARP $+ \\mathrm { c }$ RT, as shown in Figure 4 (c). As both ReMixMatch+DARP+cRT and ReMixMatch $+$ ABC use ReMixMatch to learn representations, the performance gap between these two algorithms results from the different characteristics of the ABC versus DARP $+$ cRT as follows. First, DARP $^ +$ cRT does not use unlabeled data for training its classifier after representations learning is completed, whereas the ABC uses unlabeled data with unbiased pseudo-labels for its training. Second, whereas DARP $+ \\mathrm { c }$ RT decouples the learning of representations and training of a classifier, the ABC is trained end-to-end interactively with representations learned by the backbone. We also present the confusion matrices of the predictions on the test set of CIFAR-10 using FixMatch, FixMatch+DARP+cRT, and FixMatch+ABC as well as the confusion matrices of the pseudo-labels on the same dataset using ReMixMatch, ReMixMatch+DARP $+ \\mathrm { c }$ RT, ReMixMatch $+$ ABC, FixMatch, FixMatch $+ \\mathrm { D A R P + c R T } ,$ , and FixMatch $+$ ABC in Appendix J. Moreover, we compare the ABC and the classifier of DARP+cRT in more detail using the validation loss plots in Appendix K. ",
+        "bbox": [
+            173,
+            244,
+            825,
+            588
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/b3b1fb935d28f783a03a39935157713174f789746071a48a7f010399e9aa1a52.jpg",
+        "image_caption": [
+            "Figure 4: Confusion matrices of the predictions on the test set of CIFAR-10 "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            606,
+            795,
+            756
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.5 Ablation study ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            816,
+            315,
+            830
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We conducted an ablation study on CIFAR-10-LT in the main setting to investigate the effect of each element of the proposed algorithm. The results for ReMixMatch+ABC are presented in Table 5, where each row indicates the proposed algorithm with the described conditions in that row. The results are summarized as follows. 1) If we did not gradually decrease the parameter of the Bernoulli distribution $B \\left( \\cdot \\right)$ when conducting consistency regularization, then an overbalance problem occurred because of unlabeled data misclassified as minority classes. 2) Without consistency regularization for the ABC, the decision boundary did not clearly separate each class. 3) Without using the $0 / 1$ mask for $L _ { c l s }$ and $L _ { c o n }$ , the ABC was trained to be biased toward the majority classes. 4) Without confidence threshold $\\tau$ for consistency regularization, training became unstable and, consequently, the ABC was trained to be biased toward certain classes. 5) Similarly, if hard pseudo-labels, instead of soft pseudo-labels, were used for consistency regularization, then the ABC was biased toward certain classes. 6) If the ABC was solely used without the backbone, the performance decreased because the ABC could not use high-quality representations learned by the backbone. 7) When we used a re-weighting technique [13] instead of a mask for the ABC, training became unstable because of abnormally large gradients calculated for training on the data of the minority classes. 8) The decoupled training of the backbone and ABC resulted in decreased classification performance, as was also analyzed in Section 4.4. Similarly, we present the results of the ablation study for FixMatch $+$ ABC in Appendix L. ",
+        "bbox": [
+            174,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            270
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/2786338252f6f8776183903af74fa0f19242d8057a9bb517d6af65e0f0738f7b.jpg",
+        "table_caption": [
+            "Table 5: Ablation study for ReMixMatch $^ +$ ABC on CIFAR-10-LT, $\\gamma = 1 0 0$ , $\\beta = 2 0 \\%$ "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Ablation study</td><td>Overall</td><td>Minority</td></tr><tr><td>ReMixMatch+ABC (proposed algorithm)</td><td>82.4</td><td>75.7</td></tr><tr><td>Without gradually decreasing the parameter of B(-) for consistency regularization</td><td>81.8</td><td>74.6</td></tr><tr><td>Without consistency regularization for the ABC</td><td>79.4</td><td>66.9</td></tr><tr><td>Without using the O/1 mask for the consistency regularization loss Lcon</td><td>79.0</td><td>69.2</td></tr><tr><td>Without using the O/1 mask for the classification loss Lcl s</td><td>74.4</td><td>57.8</td></tr><tr><td>Without using the confidence threshold T for consistency regularization</td><td>74.3</td><td>75.4</td></tr><tr><td>Using hard pseudo labels for consistency regularization</td><td>70.2</td><td>75.1</td></tr><tr><td>Without training backbone (ABC without SSL backbone)</td><td>68.7</td><td>56.2</td></tr><tr><td>Training the ABC with a re-weighting technique</td><td>81.2</td><td>74.1</td></tr><tr><td>Decoupled training of the backbone and ABC</td><td>79.5</td><td>72.3</td></tr></table>",
+        "bbox": [
+            202,
+            306,
+            794,
+            449
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            478,
+            299,
+            494
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We introduced the ABC, which is attached to a state-of-the-art SSL algorithm, for CISSL. The ABC can utilize high-quality representations learned by the backbone, while being trained to make classbalanced predictions. The ABC also utilizes unlabeled data by conducting consistency regularization in a modified way for class-imbalance problems. The experimental results obtained under various settings demonstrate that the proposed algorithm outperforms the baseline algorithms. We also conducted a qualitative analysis and an ablation study to verify the contribution of each element of the proposed algorithm. The proposed algorithm assumes that the labeled and unlabeled data are class-imbalanced to the same extent. In the future, we plan to release this assumption by adopting a module for estimating class distribution. Deep learning algorithms can be applied to many societal problems. However, if the training data are imbalanced, the algorithms could be trained to make socially biased decisions in favor of the majority groups. The proposed algorithm can contribute to solving these issues. However, there is also a potential risk that the proposed algorithm could be used as a tool to identify minorities and discriminate against them. It should be ensured that the proposed method cannot be used for any purpose that may have negative social impacts. ",
+        "bbox": [
+            174,
+            511,
+            825,
+            703
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            724,
+            328,
+            741
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This work was supported by the National Research Foundation of Korea (NRF) grant funded by the Korea government (MSIT) (2018R1C1B6004511, 2020R1A4A10187747). ",
+        "bbox": [
+            176,
+            756,
+            823,
+            784
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            805,
+            266,
+            821
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[1] An, J., Ying, L., and Zhu, Y. (2021). Why resampling outperforms reweighting for correcting sampling bias with stochastic gradients. In International Conference on Learning Representations. [2] Barandela, R., Rangel, E., Sánchez, J. S., and Ferri, F. J. (2003). Restricted decontamination for the imbalanced training sample problem. In Iberoamerican congress on pattern recognition, pages 424–431. Springer. ",
+        "bbox": [
+            171,
+            829,
+            826,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[3] Berthelot, D., Carlini, N., Cubuk, E. D., Kurakin, A., Sohn, K., Zhang, H., and Raffel, C. (2019a). Remixmatch: Semi-supervised learning with distribution matching and augmentation anchoring. In International Conference on Learning Representations. ",
+        "bbox": [
+            173,
+            90,
+            823,
+            133
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[4] Berthelot, D., Carlini, N., Goodfellow, I., Papernot, N., Oliver, A., and Raffel, C. A. (2019b). Mixmatch: A holistic approach to semi-supervised learning. In Wallach, H., Larochelle, H., Beygelzimer, A., d'Alché-Buc, F., Fox, E., and Garnett, R., editors, Advances in Neural Information Processing Systems, volume 32. Curran Associates, Inc. ",
+        "bbox": [
+            174,
+            140,
+            823,
+            196
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[5] Buda, M., Maki, A., and Mazurowski, M. A. (2018). A systematic study of the class imbalance problem in convolutional neural networks. Neural Networks, 106:249–259. ",
+        "bbox": [
+            171,
+            205,
+            825,
+            234
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[6] Cao, K., Wei, C., Gaidon, A., Arechiga, N., and Ma, T. (2019). Learning imbalanced datasets with label-distribution-aware margin loss. In Wallach, H., Larochelle, H., Beygelzimer, A., d'Alché-Buc, F., Fox, E., and Garnett, R., editors, Advances in Neural Information Processing Systems, volume 32. Curran Associates, Inc. ",
+        "bbox": [
+            173,
+            242,
+            825,
+            299
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[7] Chawla, N. V., Bowyer, K. W., Hall, L. O., and Kegelmeyer, W. P. (2002). Smote: synthetic minority over-sampling technique. Journal of artificial intelligence research, 16:321–357. ",
+        "bbox": [
+            171,
+            305,
+            821,
+            335
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[8] Cubuk, E. D., Zoph, B., Shlens, J., and Le, Q. V. (2020). Randaugment: Practical automated data augmentation with a reduced search space. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition Workshops, pages 702–703. ",
+        "bbox": [
+            174,
+            342,
+            823,
+            386
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[9] Cui, Y., Jia, M., Lin, T.-Y., Song, Y., and Belongie, S. (2019). Class-balanced loss based on effective number of samples. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 9268–9277. ",
+        "bbox": [
+            173,
+            392,
+            823,
+            435
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[10] DeVries, T. and Taylor, G. W. (2017). Improved regularization of convolutional neural networks with cutout. arXiv preprint arXiv:1708.04552. ",
+        "bbox": [
+            166,
+            443,
+            825,
+            472
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[11] Gidaris, S., Singh, P., and Komodakis, N. (2018). Unsupervised representation learning by predicting image rotations. In International Conference on Learning Representations. ",
+        "bbox": [
+            171,
+            479,
+            823,
+            510
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[12] Grandvalet, Y. and Bengio, Y. (2005). Semi-supervised learning by entropy minimization. In Saul, L., Weiss, Y., and Bottou, L., editors, Advances in Neural Information Processing Systems, volume 17. MIT Press. ",
+        "bbox": [
+            174,
+            516,
+            825,
+            559
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[13] He, H. and Garcia, E. A. (2009). Learning from imbalanced data. IEEE Transactions on knowledge and data engineering, 21(9):1263–1284. ",
+        "bbox": [
+            171,
+            566,
+            825,
+            595
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[14] Huang, C., Li, Y., Loy, C. C., and Tang, X. (2016). Learning deep representation for imbalanced classification. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 5375–5384. ",
+        "bbox": [
+            173,
+            603,
+            825,
+            646
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[15] Jamal, M. A., Brown, M., Yang, M.-H., Wang, L., and Gong, B. (2020). Rethinking classbalanced methods for long-tailed visual recognition from a domain adaptation perspective. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 7610–7619. ",
+        "bbox": [
+            173,
+            654,
+            826,
+            710
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[16] JAPKOWICZ, N. (2000). The class imbalance problem: Significance and strategies. In Proc. 2000 International Conference on Artificial Intelligence, volume 1, pages 111–117. ",
+        "bbox": [
+            171,
+            717,
+            825,
+            747
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[17] Kang, B., Xie, S., Rohrbach, M., Yan, Z., Gordo, A., Feng, J., and Kalantidis, Y. (2020). Decoupling representation and classifier for long-tailed recognition. In International Conference on Learning Representations. ",
+        "bbox": [
+            176,
+            753,
+            823,
+            797
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[18] Kim, J., Hur, Y., Park, S., Yang, E., Hwang, S. J., and Shin, J. (2020a). Distribution aligning refinery of pseudo-label for imbalanced semi-supervised learning. In Larochelle, H., Ranzato, M., Hadsell, R., Balcan, M. F., and Lin, H., editors, Advances in Neural Information Processing Systems, volume 33, pages 14567–14579. Curran Associates, Inc. ",
+        "bbox": [
+            178,
+            804,
+            823,
+            861
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[19] Kim, J., Jeong, J., and Shin, J. (2020b). M2m: Imbalanced classification via major-to-minor translation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 13896–13905. ",
+        "bbox": [
+            174,
+            868,
+            826,
+            911
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[20] Kingma, D. P. and Ba, J. (2015). Adam: A method for stochastic optimization. In ICLR, 2015. ",
+        "bbox": [
+            171,
+            90,
+            826,
+            107
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[21] Krizhevsky, A. (2009). Learning multiple layers of features from tiny images. Technical report, Department of Computer Science, University of Toronto. ",
+        "bbox": [
+            171,
+            114,
+            825,
+            143
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[22] Lee, D.-H. et al. (2013). Pseudo-label: The simple and efficient semi-supervised learning method for deep neural networks. In Workshop on challenges in representation learning, ICML, volume 3. ",
+        "bbox": [
+            173,
+            151,
+            825,
+            194
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[23] Mikolov, T., Sutskever, I., Chen, K., Corrado, G. S., and Dean, J. (2013). Distributed representations of words and phrases and their compositionality. In Burges, C. J. C., Bottou, L., Welling, M., Ghahramani, Z., and Weinberger, K. Q., editors, Advances in Neural Information Processing Systems, volume 26. Curran Associates, Inc. ",
+        "bbox": [
+            173,
+            203,
+            826,
+            260
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[24] Miyato, T., Maeda, S.-i., Koyama, M., and Ishii, S. (2018). Virtual adversarial training: a regularization method for supervised and semi-supervised learning. IEEE transactions on pattern analysis and machine intelligence, 41(8):1979–1993. ",
+        "bbox": [
+            173,
+            267,
+            823,
+            310
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[25] Netzer, Y., Wang, T., Coates, A., Bissacco, A., Wu, B., and Ng, A. Y. (2011). Reading digits in natural images with unsupervised feature learning. In NIPS Workshop, 2011. ",
+        "bbox": [
+            171,
+            319,
+            823,
+            349
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[26] Park, S., Park, J., Shin, S.-J., and Moon, I.-C. (2018). Adversarial dropout for supervised and semi-supervised learning. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 32. ",
+        "bbox": [
+            176,
+            356,
+            825,
+            398
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[27] Ren, J., Yu, C., sheng, s., Ma, X., Zhao, H., Yi, S., and Li, h. (2020). Balanced meta-softmax for long-tailed visual recognition. In Larochelle, H., Ranzato, M., Hadsell, R., Balcan, M. F., and Lin, H., editors, Advances in Neural Information Processing Systems, volume 33, pages 4175–4186. Curran Associates, Inc. ",
+        "bbox": [
+            173,
+            406,
+            826,
+            464
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[28] Ren, M., Zeng, W., Yang, B., and Urtasun, R. (2018). Learning to reweight examples for robust deep learning. In International Conference on Machine Learning, pages 4334–4343. PMLR. ",
+        "bbox": [
+            171,
+            472,
+            823,
+            502
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[29] Sohn, K., Berthelot, D., Carlini, N., Zhang, Z., Zhang, H., Raffel, C. A., Cubuk, E. D., Kurakin, A., and Li, C.-L. (2020). Fixmatch: Simplifying semi-supervised learning with consistency and confidence. Advances in Neural Information Processing Systems, 33. ",
+        "bbox": [
+            174,
+            510,
+            823,
+            554
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[30] Tarvainen, A. and Valpola, H. (2017). Mean teachers are better role models: Weight-averaged consistency targets improve semi-supervised deep learning results. In Guyon, I., Luxburg, U. V., Bengio, S., Wallach, H., Fergus, R., Vishwanathan, S., and Garnett, R., editors, Advances in Neural Information Processing Systems, volume 30. Curran Associates, Inc. ",
+        "bbox": [
+            174,
+            560,
+            826,
+            618
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[31] Van der Maaten, L. and Hinton, G. (2008). Visualizing data using t-sne. Journal of machine learning research, 9(11). ",
+        "bbox": [
+            166,
+            626,
+            825,
+            656
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[32] Verma, V., Lamb, A., Kannala, J., Bengio, Y., and Lopez-Paz, D. (2019). Interpolation consistency training for semi-supervised learning. In Proceedings of the Twenty-Eighth International Joint Conference on Artificial Intelligence, IJCAI-19, pages 3635–3641. International Joint Conferences on Artificial Intelligence Organization. ",
+        "bbox": [
+            174,
+            664,
+            826,
+            720
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[33] Wang, Y.-X., Ramanan, D., and Hebert, M. (2017). Learning to model the tail. In Guyon, I., Luxburg, U. V., Bengio, S., Wallach, H., Fergus, R., Vishwanathan, S., and Garnett, R., editors, Advances in Neural Information Processing Systems, volume 30. Curran Associates, Inc. ",
+        "bbox": [
+            178,
+            728,
+            825,
+            772
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[34] Wei, C., Sohn, K., Mellina, C., Yuille, A., and Yang, F. (2021). Crest: A class-rebalancing selftraining framework for imbalanced semi-supervised learning. arXiv preprint arXiv:2102.09559. ",
+        "bbox": [
+            169,
+            780,
+            825,
+            810
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[35] Yang, Y. and Xu, Z. (2020). Rethinking the value of labels for improving class-imbalanced learning. In Larochelle, H., Ranzato, M., Hadsell, R., Balcan, M. F., and Lin, H., editors, Advances in Neural Information Processing Systems, volume 33, pages 19290–19301. Curran Associates, Inc. ",
+        "bbox": [
+            173,
+            818,
+            825,
+            873
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[36] Yin, X., Yu, X., Sohn, K., Liu, X., and Chandraker, M. (2018). Feature transfer learning for deep face recognition with under-represented data. arXiv e-prints, pages arXiv–1803. ",
+        "bbox": [
+            173,
+            882,
+            821,
+            911
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[37] Yu, F., Zhang, Y., Song, S., Seff, A., and Xiao, J. (2015). Lsun: Construction of a large-scale image dataset using deep learning with humans in the loop. arXiv preprint arXiv:1506.03365.   \n[38] Zagoruyko, S. and Komodakis, N. (2016). Wide residual networks. arXiv preprint arXiv:1605.07146.   \n[39] Zhai, X., Oliver, A., Kolesnikov, A., and Beyer, L. (2019). S4l: Self-supervised semi-supervised learning. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 1476–1485. ",
+        "bbox": [
+            173,
+            90,
+            826,
+            205
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Checklist ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            228,
+            254,
+            244
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            253,
+            339,
+            267
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   \n(b) Did you describe the limitations of your work? [Yes] See Section 5.   \n(c) Did you discuss any potential negative societal impacts of your work? [Yes] See Section 5.   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            238,
+            272,
+            825,
+            375
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            378,
+            493,
+            392
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [N/A] (b) Did you include complete proofs of all theoretical results? [N/A] ",
+        "bbox": [
+            238,
+            396,
+            738,
+            426
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            214,
+            430,
+            393,
+            444
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes] We included the code and instruction in the supplemental material. We will also upload the code at githup with the copyright after the review process.   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] See Section 4.1 and Appendix E.   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes] See Section 4.2.   \n(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] We summarize the resources and FLOPS in Section 4.2 and Appendix I. ",
+        "bbox": [
+            238,
+            448,
+            825,
+            604
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            209,
+            608,
+            823,
+            622
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes] We cited the creators of CIFAR-10, SVHN, CIFAR-100, LSUN in Section 4.1.   \n(b) Did you mention the license of the assets? [N/A] In their homepage, the creators of the datasets request to cite their work rather than mentioning the license.   \n(c) Did you include any new assets either in the supplemental material or as a URL? [Yes] We included the code for training the proposed algorithm as the supplemental material. We will also upload it at githup with the copyright after review process.   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A] We used the benchmark datasets cited in Section 4.1   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] We used the benchmark datasets cited in Section 4.1 ",
+        "bbox": [
+            238,
+            626,
+            825,
+            797
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            214,
+            803,
+            705,
+            816
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   \n(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   \n(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] ",
+        "bbox": [
+            238,
+            820,
+            825,
+            909
+        ],
+        "page_idx": 12
+    }
+]

parse/train/BJxQxeBYwH/BJxQxeBYwH.md

@@ -0,0 +1,365 @@
+# ARE POWERFUL GRAPH NEURAL NETS NECESSARY? A DISSECTION ON GRAPH CLASSIFICATION
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Graph Neural Nets (GNNs) have received increasing attentions, partially due to their superior performance in many node and graph classification tasks. However, there is a lack of understanding on what they are learning and how sophisticated the learned graph functions are. In this work, we propose a dissection of GNNs on graph classification into two parts: 1) the graph filtering, where graph-based neighbor aggregations are performed, and 2) the set function, where a set of hidden node features are composed for prediction. To study the importance of both parts, we propose to linearize them separately. We first linearize the graph filtering function, resulting Graph Feature Network (GFN), which is a simple lightweight neural net defined on a set of graph augmented features. Further linearization of GFN’s set function results in Graph Linear Network (GLN), which is a linear function. Empirically we perform evaluations on common graph classification benchmarks. To our surprise, we find that, despite the simplification, GFN could match or exceed the best accuracies produced by recently proposed GNNs (with a fraction of computation cost), while GLN underperforms significantly. Our results demonstrate the importance of non-linear set function, and suggest that linear graph filtering with non-linear set function is an efficient and powerful scheme for modeling existing graph classification benchmarks.
+
+# 1 INTRODUCTION
+
+Recent years have seen increasing attention to Graph Neural Nets (GNNs) (Scarselli et al., 2009; Li et al., 2015; Defferrard et al., 2016; Kipf and Welling, 2016), which have achieved superior performance in many graph tasks, such as node classification (Kipf and Welling, 2016; Wu et al., 2019) and graph classification (Simonovsky and Komodakis, 2017; Xinyi and Chen, 2019). Different from traditional neural networks that are defined on regular structures such as sequences or images, graphs provide a more general abstraction for structured data, which subsume regular structures as special cases. The power of GNNs is that they can directly define learnable compositional function on (arbitrary) graphs, thus extending classic networks (e.g. CNNs, RNNs) to more irregular and general domains.
+
+Despite their success, it is unclear what GNNs have learned, and how sophisticated the learned graph functions are. It is shown in (Zeiler and Fergus, 2014) that traditional CNNs used in image recognition have learned complex hierarchical and compositional features, and that deep non-linear computation can be beneficial He et al. (2016). Is this also the case when applying GNNs to common graph problems? Recently, Wu et al. (2019) showed that, for common node classification benchmarks, non-linearity can be removed in GNNs without suffering much loss of performance. The resulting linear GNNs collapse into a logistic regression on graph propagated features. This raises doubts on the necessity of complex GNNs, which require much more expensive computation, for node classification benchmarks. Here we take a step further dissecting GNNs, and examine the necessity of complex GNN parts on more challenging graph classification benchmarks (Yanardag and Vishwanathan, 2015; Zhang et al., 2018a; Xinyi and Chen, 2019).
+
+To better understand GNNs on graph classification, we dissect it into two parts/stages: 1) the graph filtering part, where graph-based neighbor aggregations are performed, and 2) the set function part, where a set of hidden node features are composed for prediction. We aim to test the importance of both parts separately, and seek answers to the following questions. Do we need a sophisticated graph filtering function for a particular task or dataset? And if we have a powerful set function, is it enough to use a simple graph filtering function?
+
+To answer these questions, we propose to linearize both parts separately. We first linearize graph filtering part, resulting Graph Feature Network (GFN): a simple lightweight neural net defined on a set of graph augmented features. Unlike GNNs, which learn a multi-step neighbor aggregation function on graphs (Dai et al., 2016; Gilmer et al., 2017), the GFN only utilizes graphs in constructing its input features. It first augments nodes with graph structural and propagated features, and then learns a neural net directly on the set of nodes (i.e. a bag of graph pre-processed feature vectors), which make it more efficient. We then further linearize set function in GFN, and arrive at Graph Linear Network (GLN), which is a linear function of augmented graph features.
+
+Empirically, we perform evaluations on common graph classification benchmarks (Yanardag and Vishwanathan, 2015; Zhang et al., 2018a; Xinyi and Chen, 2019), and find that GFN can match or exceed the best accuracies produced by recently proposed GNNs, at a fraction of the computation cost. GLN performs much poorly than both GFN and recent GNNs. This result casts doubts on the necessity of non-linear graph filtering, and suggests that the existing GNNs may not have learned more sophisticated graph functions than linear neighbor aggregation on these benchmarks. Furthermore, we find non-linear set function plays an important role, as its linearization can hurt performance significantly.
+
+# 2 PRELIMINARIES
+
+Graph classification problem. We use $G = ( V , E ) \in \mathcal { G }$ to denote a graph, where $V$ is a set of vertices/nodes, and $E$ is a set of edges. We further denote an attributed graph as $G _ { X } = ( G , X ) \in \mathcal G _ { X }$ , where $\ b { X } \in \mathbb { R } ^ { n \times d }$ are node attributes with $n = | V |$ . It is assumed that each attributed graph is associated with some label $y \in \mathcal { V }$ , where $\mathcal { V }$ is a set of pre-defined categories. The goal in graph classification problem is to learn a mapping function $f : { \mathcal { G } } _ { X } \to \mathcal { V }$ , such that we can predict the target class for unseen graphs accurately. Many real world problems can be formulated as graph classification problems, such as social and biological graph classification Yanardag and Vishwanathan (2015); Kipf and Welling (2016).
+
+Graph neural networks. Graph Neural Networks (GNNs) define functions on the space of attributed graph $\mathcal { G } _ { X }$ . Typically, the graph function, $\mathrm { G N N } ( G , X )$ , learns a multiple-step transformation of the original attributes/signals for final node level or graph level prediction. In each of the step $t$ , a new node presentation, $h _ { v } ^ { ( t ) }$ is learned. Initially, $h _ { v } ^ { ( 1 ) }$ is initialized with the node attribute vector, and during each subsequent step, a neighbor aggregation function is applied to generate the new node representation. More specifically, common neighbor aggregation functions for the $v$ -th node take the following form:
+
+$$
+h _ { v } ^ { ( t ) } = f \bigg ( h _ { v } ^ { ( t - 1 ) } , \bigg \{ h _ { u } ^ { ( t - 1 ) } | u \in \mathcal { N } ( v ) \bigg \} \bigg ) ,
+$$
+
+where $\mathcal { N } ( v )$ is a set of neighboring nodes of node $v$ . To instantiate this neighbor aggregation function, (Kipf and Welling, 2016) proposes the Graph Convolutional Network (GCN) aggregation scheme as follows.
+
+$$
+h _ { v } ^ { ( t + 1 ) } = \sigma \bigg ( \sum _ { u \in \mathcal { N } ( v ) } \tilde { A } _ { u v } ( W ^ { ( t ) } ) ^ { T } h _ { u } ^ { ( t ) } \bigg ) ,
+$$
+
+where $W ^ { ( t ) } \in \mathbb { R } ^ { d \times d ^ { \prime } }$ is the learnable transformation weight, $\tilde { A } = \tilde { D } ^ { - 1 / 2 } ( A + \epsilon I ) \tilde { D } ^ { - 1 / 2 }$ is the normalized adjacency matrix with $\epsilon$ as a constant $\mathbf { \epsilon } _ { \epsilon } = 1$ in Kipf and Welling (2016)) and ${ \tilde { D } } _ { i i } =$ $\begin{array} { r } { \sum _ { j } A _ { i j } + \epsilon . ~ \sigma ( \cdot ) } \end{array}$ is a non-linear activation function, such as ReLU. This transformation can also be written as $H ^ { ( t + 1 ) } = \sigma ( \tilde { A } H ^ { ( t ) } W ^ { ( t ) } )$ , where $H ^ { ( t ) } \in \mathbb { R } ^ { n \times d }$ are the hidden states of all nodes at $t { \cdot }$ -th step.
+
+More sophisticated neighbor aggregation schemes are also proposed, such as GraphSAGE (Hamilton et al., 2017) which allows pooling and recurrent aggregation over neighboring nodes. Most recently, in Graph Isomorphism Network (GIN) $\mathrm { { X u } }$ et al., 2019), a more powerful aggregation function is
+
+proposed as follows.
+
+$$
+h _ { v } ^ { ( t ) } = \mathbf { M } \mathbf { L } \mathbf { P } ^ { ( t ) } \bigg ( \bigg ( 1 + \epsilon ^ { ( t ) } \bigg ) h _ { v } ^ { ( t - 1 ) } + \sum _ { u \in \mathcal { N } ( v ) } h _ { u } ^ { ( t - 1 ) } \bigg ) ,
+$$
+
+where MLP abbreviates for multi-layer perceptrons and $\epsilon ^ { ( t ) }$ can either be zero or a learnable parameter.
+
+Finally, in order to generate graph level representation $h _ { G }$ , a readout function is used, which generally takes the following form:
+
+$$
+h _ { G } = g \bigg ( \bigg \{ h _ { v } ^ { ( T ) } | v \in G \bigg \} \bigg ) .
+$$
+
+This can be instantiated by a global sum pooling, i.e. $\begin{array} { r } { h _ { G } = \sum _ { v = 1 } ^ { n } h _ { v } ^ { ( T ) } } \end{array}$ followed by fully connected layers to generate the categorical or numerical output.
+
+# 3 APPROACH
+
+# 3.1 GRAPH FEATURE NETWORK
+
+Motivated by the question that, with a powerful graph readout function, whether wwe can simplify the sophisticated multi-step neighbor aggregation functions (such as Eq. 2 and 3). Therefore we propose Graph Feature Network (GFN): a neural set function defined on a set of graph augmented features.
+
+Graph augmented features. In GFN, we replace the sophisticated neighbor aggregation functions (such as Eq. 2 and 3) with graph augmented features based on $G _ { X }$ . Here we consider two categories as follows: 1) graph structural/topological features, which are related to the intrinsic graph structure, such as node degrees, or node centrality scores1, but do not rely on node attributes; 2) graph propagated features, which leverage the graph as a medium to propagate node attributes. The graph augmented features $X ^ { G }$ can be seen as the output of a feature extraction function defined on the attributed graph, i.e. $X ^ { G } = \gamma ( G , X )$ , and Eq. 5 below gives a specific form, which combine node degree features and multi-scale graph propagated features as follows:
+
+$$
+X ^ { G } = \gamma ( G , X ) = \bigg [ d , X , \tilde { A } ^ { 1 } X , \tilde { A } ^ { 2 } X , \cdot \cdot \cdot , \tilde { A } ^ { K } X \bigg ] ,
+$$
+
+where $\ b { d } \in \mathbb { R } ^ { n \times 1 }$ is the degree vector for all nodes, and $\tilde { A }$ is again the normalized adjacency matrix $( \tilde { A } = \tilde { D } ^ { - 1 / 2 } ( A + \epsilon I ) \tilde { D } ^ { - 1 / 2 } )$ , but other designs of propagation operator are possible (Klicpera et al., 2019). Features separated by comma are concatenated to form $\bar { X ^ { G } }$ .
+
+Neural set function. To build a powerful graph readout function based on graph augmented features $X ^ { G }$ , we use a neural set function. The neural set function discards the graph structures and learns purely based on the set of augmented node features. Motivated by the general form of a permutationinvariant set function shown in Zaheer et al. (2017), we define our neural set function for GFN as follows:
+
+$$
+\mathrm { G F N } ( G , X ) = \rho \bigg ( \sum _ { v \in \mathcal { V } } \phi \bigg ( X _ { v } ^ { G } \bigg ) \bigg ) .
+$$
+
+Both $\phi ( \cdot )$ and $\rho ( \cdot )$ are parameterized by neural networks. Concretely, we parameterize the function $\phi ( \cdot )$ as a multi-layer perceptron (MLP), i.e. $\phi ( x ) = \sigma ( \sigma ( \cdot \cdot \cdot \sigma ( x ^ { T } W ^ { ( 1 ) } ) \cdot \cdot \cdot ) W ^ { ( T ) } )$ . Note that a single layer of $\phi ( \cdot )$ resembles a graph convolution layer $H ^ { ( t + 1 ) } = \sigma ( \tilde { A } H ^ { ( t ) } W ^ { ( t ) } )$ with the normalized adjacency matrix $\tilde { A }$ replaced by identity matrix $I$ (a.k.a. $1 \times 1$ convolution). As for the function $\rho ( \cdot )$ , we parameterize it with another MLP (i.e. fully connected layers in this case).
+
+Computation efficiency. GFN provides a way to approximate GNN with less computation overheads, especially during the training process. Since the graph augmented features can be pre-computed before training starts, the graph structures are not involved in the iterative training process. This brings the following advantages. First, since there is no neighbor aggregation step in GFN, it reduces computational complexity. To see this, one can compare a single layer feature transformation function in GFN, i.e. $\sigma ( H W )$ , against the neighbor aggregation function in GCN, i.e. $\sigma ( \tilde { A } H W )$ . Secondly, since graph augmented features of different scales are readily available from the input layer, GFN can leverage them much earlier, thus may require fewer transformation layers. Lastly, it also eases the implementation related overhead, since the neighbor aggregation operation in graphs are typically implemented by sparse matrix operations.
+
+Graph Linear Network. When we use a linear set function instead of the generic one used in Eq.   
+6, we arrive at graph linear network, which can be expressed as follows.
+
+$$
+\mathrm { G L N } ( G , X ) = \sigma \bigg ( W \sum _ { v \in \mathcal { V } } \bigg ( X _ { v } ^ { G } \bigg ) \bigg ) .
+$$
+
+Where $W$ is a weight matrix, and $\sigma ( \cdot )$ is softmax function produce class probability.
+
+# 3.2 FROM GNN TO GFN AND GLN: A DISSECTION OF GNNS
+
+To better understand GNNs on graph classification, we propose a formal dissection/decomposition of GNNs into two parts/stages: the graph filtering part and the set function part. As we shall see shortly, the simplification of the graph filtering part allows us to derive GFN from GNN, and also be able to assess the importance of the two GNN parts separately.
+
+To make concepts more clear, we first give formal definitions of the two GNN parts in the dissection. Definition 1. (Graph filtering) A graph filtering function, $Y = { \mathcal { F } } _ { G } ( X )$ , performs a transformation of input signals based on the graph $G$ , which takes a set of signals $\dot { X } \in \mathbb { R } ^ { n \times d }$ and outputs another set of filtered signals Y ∈ Rm×d0 .
+
+Graph filtering in most existing GNNs consists of multi-step neighbor aggregation operations, i.e. multiple steps of Eq. 1. For example, in GCN Kipf and Welling (2016), the multi-step neighbor aggregation can be expressed as $\bar { H ^ { ( T ) } } = \sigma ( A \sigma ( . . . \bar { \sigma } ( A X W ^ { ( 1 ) } ) . . . \bar { ) } W ^ { ( T ) } )$ .
+
+Definition 2. (Set function) A set function, $y = \mathcal { T } ( Y )$ , takes a set of vectors $Y \in \mathbb { R } ^ { m \times d ^ { \prime } }$ where their order does not matter, and outputs a task specific prediction $y \in \mathcal { V }$ .
+
+The graph readout function in Eq. 4 is a set function, which enables the graph level prediction that is permutation invariant w.r.t. nodes in the graph. Although a typical readout function is simply a global pooling (Xu et al., 2019), the set function can be as complicated as Eq. 6.
+
+Claim 1. A GNN that is a mapping of $\mathcal { G } _ { X }  \mathcal { V }$ can be decomposed into a graph filtering function followed by a set function, i.e. $G N N ( G , X ) = \mathcal { T } \circ \mathcal { F } _ { G } ( X )$ .
+
+This claim is obvious for the neighbor aggregation framework defined by Eq. 1 and 4, where most existing GNN variants such as GCN, GraphSAGE and GIN follow. This claim is also general, even for unforeseen GNN variants that do not explicitly follow this framework 2.
+
+We aim to assess the importance of two GNN parts separately. However, it is worth pointing out that the above decomposition is not unique in general, and the functionality of the two parts can overlap: if the graph filtering part has fully transformed graph features, then a simple set function may be used for prediction. This makes it challenging to answer the question: do we need a sophisticated graph filtering part for a particular task or dataset, especially when a powerful set function is used? To better disentangle these two parts and study their importance more independently, similar to $\mathrm { W u }$ et al. (2019), we propose to simplify the graph filtering part by linearizing it.
+
+Definition 3. (Linear graph filtering) We say a graph filtering function ${ \mathcal { F } } _ { G } ( X )$ is linear w.r.t. $X$ iff it can be expressed as ${ \mathcal { F } } _ { G } ( X ) = \Gamma ( G , X ) \theta$ , where $\Gamma ( G , X )$ is a linear map of $X$ , and $\pmb \theta$ is the only learnable parameter.
+
+Intuitively, one can construct a linear graph filtering by removing the non-linear operations from graph filtering part in existing GNNs, such as non-linear activation function $\sigma ( \cdot )$ in Eq. 2 or 3. By doing so, the graph filtering becomes linear w.r.t. X, thus multi-layer weights collapse into a single linear transformation, described by $\pmb { \theta }$ . More concretely, let us consider a linearized GCN Kipf and Welling (2016), its $K$ -th layer can be written as $H ^ { ( K ) } = \hat { A } ^ { K } X ( \Pi _ { k = 1 } ^ { K } W ^ { ( k ) } )$ , and we can rewrite the weights with $\pmb \theta = \Pi _ { k = 1 } ^ { K } W ^ { ( k ) }$ .
+
+The linearization of graph filtering part enables us to disentangle graph filtering and the set function more thoroughly: the graph filtering part mainly constructs graph augmented features (by setting $\gamma ( G , X ) = \Gamma ( G , X ) )$ , and the set function learns to compose them for the graph-level prediction. This leads to the proposed GFN. In other words, GNNs with a linear graph filtering part can be expressed as GFN with appropriate graph augmented features. This is shown more formally in the following proposition 1.
+
+Proposition 1. Let $G N N ^ { l i n } ( G , X )$ be a mapping of $\mathcal { G } _ { X }  \mathcal { V }$ that has a linear graph filtering part, i.e. ${ \mathcal { F } } _ { G } ( X ) = \Gamma ( G , X ) \theta$ , then we have $G N N ^ { l i n } ( G , X ) = G F N ( G , X )$ , where $\gamma ( G , X ) = \Gamma ( G , X )$
+
+The proof can be found in the appendix. Noted that a GNN with a linear graph filtering can be seen as a GFN, but the reverse may not be true. General GFN can have non-linear graph filtering, e.g. when the feature extraction function $\gamma ( G , X )$ is not a linear map of $X$ (Eq. 5 is a linear map of $X$ ).
+
+Why GFN? GFN can also help us understand the functions that GNNs learned on current benchmarks. First, by comparing GNN with linear graph filtering (i.e. GFN) against standard GNN with non-linear graph filtering, we can assess the importance of non-linear graph filtering part. Secondly, by comparing GFN with linear set function (i.e. GLN) against GFN with non-linear set function, we can assess the importance of non-linear set function.
+
+Beyond as a tool to study GNN parts, GFN is also more efficient than GNN counterpart, which makes it a fast approximation. Furthermore, GFNs can be a very powerful framework without restriction on the feature extraction function $\gamma ( G , X )$ and the exact forms of the set function. The potential expressiveness of a GFN is demonstrated by the following proposition.
+
+Proposition 2. For any GNN $\mathcal { F }$ defined in $\mathcal { G } _ { X }$ , there exists a graph to set mapping $\mathcal { M } : \mathcal { G }  \mathcal { S }$ where $s$ is a set space, and a set function $\tau$ that approximates $\mathcal { F }$ to arbitrary precision, i.e. $\forall G \in$ $\mathcal { G } _ { X } , F ( G ) \approx \mathcal { T } ( \mathcal { M } ( G ) )$ .
+
+The proof is provided in the appendix. We want to provide an intuitive interpretation here. There exists some way(s) that we can encode any graph into a set, and learn a generic set function on it. As long as the set contains the graph information, a powerful set function can learn to integrate it in a flexible way. So a well constructed GFN can be as powerful as, if not more powerful than, the most powerful GNNs. This shows the potential of the GFN framework in modeling arbitrary graph data.
+
+# 4 EXPERIMENTS
+
+# 4.1 DATASETS AND SETTINGS
+
+Datasets. The main datasets we consider are commonly used graph classification benchmarks (Yanardag and Vishwanathan, 2015; Xinyi and Chen, 2019; Xu et al., 2019). The graphs in the collection can be categorized into two categories: (1) biological graphs, including MUTAG, NCI1, PROTEINS, D&D, ENZYMES; and (2) social graphs, including COLLAB, IMDB-Binary (IMDB-B), IMDBMulti (IMDB-M), Reddit-Multi-5K (RE-M5K), Reddit-Multi-12K (RE-M12K). It is worth noting that the social graphs have no node attributes, while the biological graphs come with categorical node attributes. The detailed statistics can be found in the appendix.
+
+Baselines. We compare with two families of baselines. The first family of baselines are kernel-based, namely the Weisfeiler-Lehman subtree kernel (WL) (Shervashidze et al., 2011), Deep Graph Kernel (DGK) (Yanardag and Vishwanathan, 2015) and AWE (Ivanov and Burnaev, 2018) that incorporate kernel-based methods with learning-based approach to learn embeddings. The second family of baselines are GNN-based models, which include recently proposed PATCHY-SAN (PSCN) (Niepert et al., 2016), Deep Graph CNN (DGCNN) (Zhang et al., 2018a), CapsGNN (Xinyi and Chen, 2019) and GIN (Xu et al., 2019).
+
+Table 1: Test accuracies $( \% )$ for biological graphs. The best results per dataset and in average are highlighted. - means the results are not available for a particular dataset.   
+
+<table><tr><td>Algorithm</td><td>MUTAG</td><td>NCI1</td><td>PROTEINS</td><td>D&amp;D</td><td>ENZYMES</td><td>Average</td></tr><tr><td>WL</td><td>82.05±0.36</td><td>82.19±0.18</td><td>74.68±0.49</td><td>79.78±0.36</td><td>52.22±1.26</td><td>74.18</td></tr><tr><td>AWE</td><td>87.87±9.76</td><td>-</td><td>-</td><td>71.51±4.02</td><td>35.77±5.93</td><td>-</td></tr><tr><td>DGK</td><td>87.44±2.72</td><td>80.31±0.46</td><td>75.68±0.54</td><td>73.50±1.01</td><td>53.43±0.91</td><td>74.07</td></tr><tr><td>PSCN</td><td>88.95±4.37</td><td>76.34±1.68</td><td>75.00±2.51</td><td>76.27±2.64</td><td>-</td><td>-</td></tr><tr><td>DGCNN</td><td>85.83±1.66</td><td>74.44±0.47</td><td>75.54±0.94</td><td>79.37±0.94</td><td>51.00±7.29</td><td>73.24</td></tr><tr><td>CapsGNN</td><td>86.67±6.88</td><td>78.35±1.55</td><td>76.28±3.63</td><td>75.38±4.17</td><td>54.67±5.67</td><td>74.27</td></tr><tr><td>GIN</td><td>89.40±5.60</td><td>82.70±1.70</td><td>76.20±2.80</td><td>1</td><td>1</td><td>1</td></tr><tr><td>GCN</td><td>87.20±5.11</td><td>83.65±1.69</td><td>75.65±3.24</td><td>79.12±3.07</td><td>66.50±6.91</td><td>78.42</td></tr><tr><td>GLN</td><td>82.85±12.15</td><td>68.61±2.31</td><td>75.65±4.43</td><td>76.75±5.00</td><td>43.83±5.16</td><td>69.54</td></tr><tr><td>GFN</td><td>90.84±7.22</td><td>82.77±1.49</td><td>76.46±4.06</td><td>78.78±3.49</td><td>70.17±5.58</td><td>79.80</td></tr><tr><td>GFN-light</td><td>89.89±7.14</td><td>81.43±1.65</td><td>77.44±3.77</td><td>78.62±5.43</td><td>69.50±7.37</td><td>79.38</td></tr></table>
+
+Table 2: Test accuracies $( \% )$ for social graphs. The best results per dataset and in average are highlighted. - means the results are not available for a particular dataset.   
+
+<table><tr><td>Algorithm</td><td>COLLAB</td><td>IMDB-B</td><td>IMDB-M</td><td>RE-M5K</td><td>RE-M12K</td><td>Average</td></tr><tr><td>WL</td><td>79.02±1.77</td><td>73.40±4.63</td><td>49.33±4.75</td><td>49.44±2.36</td><td>38.18±1.30</td><td>57.87</td></tr><tr><td>AWE</td><td>73.93±1.94</td><td>74.45±5.83</td><td>51.54±3.61</td><td>50.46±1.91</td><td>39.20±2.09</td><td>57.92</td></tr><tr><td>DGK</td><td>73.09±0.25</td><td>66.96±0.56</td><td>44.55±0.52</td><td>41.27±0.18</td><td>32.22±0.10</td><td>51.62</td></tr><tr><td>PSCN</td><td>72.60±2.15</td><td>71.00±2.29</td><td>45.23±2.84</td><td>49.10±0.70</td><td>41.32±0.42</td><td>55.85</td></tr><tr><td>DGCNN</td><td>73.76±0.49</td><td>70.03±0.86</td><td>47.83±0.85</td><td>48.70±4.54</td><td></td><td>=</td></tr><tr><td>CapsGNN</td><td>79.62±0.91</td><td>73.10±4.83</td><td>50.27±2.65</td><td>52.88±1.48</td><td>46.62±1.90</td><td>60.50</td></tr><tr><td>GIN</td><td>80.20±1.90</td><td>75.10±5.10</td><td>52.30±2.80</td><td>57.50±1.50</td><td>1</td><td>1</td></tr><tr><td>GCN</td><td>81.72±1.64</td><td>73.30±5.29</td><td>51.20±5.13</td><td>56.81±2.37</td><td>49.31±1.44</td><td>62.47</td></tr><tr><td>GLN</td><td>75.72±2.51</td><td>73.10±3.18</td><td>50.40±5.61</td><td>52.97±2.58</td><td>39.84±0.95</td><td>58.41</td></tr><tr><td>GFN</td><td>81.50±2.42</td><td>73.00±4.35</td><td>51.80±5.16</td><td>57.59±2.40</td><td>49.43±1.36</td><td>62.66</td></tr><tr><td>GFN-light</td><td>81.34±1.73</td><td>73.00±4.29</td><td>51.20±5.71</td><td>57.11±1.46</td><td>49.75±1.19</td><td>62.48</td></tr></table>
+
+For the above baselines, we use their accuracies reported in the original papers, following the same evaluation setting as in (Xu et al., 2019). Architecture and hyper-parameters can make a difference, so to enable a better controlled comparison between GFN and GNN, we also implement Graph Convolutional Networks (GCN) from (Kipf and Welling, 2016). More specifically, our GCN model contains a dense feature transformation layer, i.e. $H ^ { ( 2 ) } = \sigma ( X W ^ { ( 1 ) } )$ , followed by three GCN layers, i.e. $H ^ { ( t + 1 ) } = \sigma ( \tilde { A } H ^ { ( t ) } W ^ { ( t ) } )$ . We also vary the number of GCN layers in our ablation study. To enable graph level prediction, we add a global sum pooling, followed by two fully-connected layers that produce categorical probability over pre-defined categories.
+
+Model configurations. For the proposed GFN, we mirror our GCN model configuration to allow direct comparison. Therefore, we use the same architecture, parameterization and training setup, but replace the GCN layer with feature transformation layers (totaling four such layers). Converting GCN layer to feature transformation layer is equivalent to setting $A = I$ in in GCN layers. We also construct a faster GFN, namely “GFN-light”, that contains only a single feature transformation layer, which can further reduce the training time while maintaining similar performance.
+
+For both our GCN and GFN, we utilize ReLU activation and batch normalization (Ioffe and Szegedy, 2015), and fix the hidden dimensionality to 128. No regularization is applied. Furthermore we use batch size of 128, a fixed learning rate of 0.001, and the Adam optimizer (Kingma and Ba, 2014). GLN follows the same setting as GFN, but contains no feature transform layer. It only has the global sum pooling of graph features followed by a single fully connected layer. To compare with existing work, we follow (Xinyi and Chen, 2019; $\mathrm { X u }$ et al., 2019) and perform 10-fold cross validation. We run the model for 100 epochs, and select the epoch in the same way as $\mathrm { X u }$ et al. (2019), i.e., a single epoch with the best cross-validation accuracy averaged over the 10 folds is selected. We report the average and standard deviation of test accuracies at the selected epoch over 10 folds.
+
+In terms of input node features for GFN and GLN, by default, we use both degree and multi-scale propagated features (up to $K = 3$ ), that is $[ d , X , \tilde { A } ^ { 1 } X , \tilde { A } ^ { 2 } X , \tilde { A } ^ { 3 } X ]$ . We turn discrete features into one-hot vectors, and also discretize degree features into one-hot vectors, as suggested in Fey and Lenssen (2019). We set $X = { \vec { 1 } }$ for the social graphs we consider as there are no node attributes. By default, we also augment node features in our GCN with an extra node degree feature (to counter that the normalized adjacency matrix may lose the degree information). Other graph augmented features are also studied for GCN (which has minor effects). All experiments are run on Nvidia GTX 1080 Ti GPU.
+
+# 4.2 PERFORMANCE COMPARISON BETWEEN GLN, GFN AND EXISTING GNN VARIANTS
+
+Table 1 and 2 show the results of different methods in both biological and social datasets. It is worth noting that in both datasets, GFN achieves similar performances with our GCN, and match or exceed existing state-of-the-art results on multiple datasets, while GLN performs worse in most of the datasets. This result suggests the importance of non-linear set function, while casting doubt on the necessity of non-linear graph filtering for these benchmarks.
+
+![](images/4635eb89e08a70cb0b220272a0d8982bc79862d9934431a70e4c00364be4cfcb.jpg)  
+Figure 1: Training and test performance versus training epoch.
+
+Figure 1 shows training/test curves for both GCN and GFN. We observe that GCN usually perform better than GFN during the training, but their test performances are mostly similar (sometimes GFN is better as training continues). This concludes that GFN works well not because it is easier to optimize.
+
+# 4.3 TRAINING TIME COMPARISONS BETWEEN GFNS AND GCNS
+
+Since GFN’s performance is on par with GCN’s, we further compare the training time of our GCN and the proposed GFNs. Figure 2 shows that a significant speedup (from $1 . 4 \times$ to $6 . 7 \times$ as fast) by utilizing GFN compared to GCN, especially for datasets with denser edges such as the COLLAB dataset. Also since our GFN can work with fewer transformation layers, GFN-light can achieve better speedup by reducing the number of transformation layers. Note that our GCN is already very efficient as it is built on a highly optimized framework Fey and Lenssen (2019).
+
+# 4.4 ABLATIONS
+
+Node features. To better understand the impact of features, we test both models with different input node features. Table 3 shows that 1) graph features are very important for both GFN and GCN, 2) the node degree feature is surprisingly important, and multi-scale features can further improve on that, and 3) even with multi-scale features, GCN still performs similarly to GFN, which further suggests that linear graph filtering is enough. More detailed results (per dataset) can be found in the appendix.
+
+Architecture depth. We vary the number of convolutional layers (with two FC-layers after sum pooling kept the same). Table 4 shows that 1) GCN benefits from multiple grpah convolutional layers with a significant diminishing return, 2) GFN with single feature transformation layer works pretty well already, likely due to the availability of multi-scale input node features, which otherwise require multiple GCN layers to obtain.
+
+![](images/44cb3f53b08b7a6bb8ec43af6945c2e0fd3e917b403c4d3e18e94beab8e51095.jpg)  
+Figure 2: Training time comparisons. The annotation, e.g. $1 . 0 \times$ , denotes speedup compared to GCN.
+
+Table 3: Accuracies $( \% )$ under various augmented features. Averaged results over multiple datasets are shown here. $A ^ { 1 , 2 , 3 } X$ is abbreviated for $A ^ { 1 } X , A ^ { 2 } X , A ^ { 3 } X$ , and default node feature $X$ is always used (if available) but not displayed to reduce clutter. Best results per row/block are highlighted.   
+
+<table><tr><td>Graphs</td><td>Model</td><td>None</td><td>d</td><td>A1x</td><td>A12X</td><td>A1,23 x</td><td>d,A¹x</td><td>d,A12 x</td><td>d,A1.2.3 X</td></tr><tr><td rowspan="2">Bio.</td><td>GCN</td><td>78.52</td><td>78.51</td><td>78.23</td><td>78.24</td><td>78.68</td><td>79.10</td><td>79.26</td><td>79.69</td></tr><tr><td>GFN</td><td>76.27</td><td>77.84</td><td>78.78</td><td>79.09</td><td>79.17</td><td>78.71</td><td>79.21</td><td>79.13</td></tr><tr><td rowspan="2">Soical</td><td>GCN</td><td>34.02</td><td>62.35</td><td>59.20</td><td>60.39</td><td>60.28</td><td>62.45</td><td>62.71</td><td>62.77</td></tr><tr><td>GFN</td><td>30.45</td><td>60.79</td><td>58.04</td><td>59.83</td><td>60.09</td><td>62.47</td><td>62.63</td><td>62.60</td></tr></table>
+
+Table 4: Accuracies $( \% )$ under different number of Conv. layers.   
+
+<table><tr><td></td><td></td><td>1</td><td>2</td><td>3</td><td>4</td><td>5</td></tr><tr><td>Bio.</td><td>GCN</td><td>77.17</td><td>79.38</td><td>78.86</td><td>78.75</td><td>78.21</td></tr><tr><td></td><td>GFN</td><td>79.59</td><td>79.77</td><td>79.78</td><td>78.99</td><td>78.14</td></tr><tr><td>Soical</td><td>GCN</td><td>60.69</td><td>62.12</td><td>62.37</td><td>62.70</td><td>62.46</td></tr><tr><td></td><td>GFN</td><td>62.70</td><td>62.88</td><td>62.81</td><td>62.80</td><td>62.60</td></tr></table>
+
+Visualization. We also provide visualization of random and misclassified samples from the tested graph datasets in the appendix J. We could not clearly distinguish graphs from different classes easily based on their appearance, suggesting that both GFN and GCN are capturing underlying non-trivial features.
+
+# 5 DISCUSSION
+
+In this work, we conduct a dissection of GNNs on common graph classification benchmarks. We first decompose GNNs into two parts, and linearize the graph filtering part resulting GFN. We then further linearize the set function of GFN resulting GLN. In our extensive experiments, we find GFN can match or exceed the best results by recently proposed GNNs, with a fraction of computation cost. The linearization of graph filtering (i.e. GFN) has little impact on performance, while linearization of both graph filtering and set function (i.e. GLN) leads to worse performance.
+
+Since GCN usually achieve better training accuracies while not better test accuracies, we conjecture that the linear graph filtering may be a good inductive bias for tested datasets, though this is speculative and requires more future investigations. Another possibility is that complexity of current graph classification benchmarks is limited, so that linear graph filtering is enough, thus moving to datasets or problems with information that is more structurally complicated could require sophisticated non-linear graph filtering.
+
+We also observe the potential of GFN, which leverages a generic set function to model graphs. In the future, we would like to build upon the powerful general GFN framework for structured data.
+
+# REFERENCES
+
+Hanjun Dai, Bo Dai, and Le Song. Discriminative embeddings of latent variable models for structured data. In International conference on machine learning, 2016.
+
+Michaël Defferrard, Xavier Bresson, and Pierre Vandergheynst. Convolutional neural networks on graphs with fast localized spectral filtering. In Advances in neural information processing systems, 2016.
+
+Simon S. Du, Kangcheng Hou, Barnabás Póczos, Ruslan Salakhutdinov, Ruosong Wang, and Keyulu Xu. Graph neural tangent kernel: Fusing graph neural networks with graph kernels. ArXiv, abs/1905.13192, 2019.
+
+Matthias Fey and Jan E. Lenssen. Fast graph representation learning with PyTorch Geometric. In ICLR Workshop on Representation Learning on Graphs and Manifolds, 2019.
+
+Justin Gilmer, Samuel S Schoenholz, Patrick F Riley, Oriol Vinyals, and George E Dahl. Neural message passing for quantum chemistry. In Proceedings of the 34th International Conference on Machine Learning, 2017.
+
+Will Hamilton, Zhitao Ying, and Jure Leskovec. Inductive representation learning on large graphs. In Advances in Neural Information Processing Systems, 2017.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Identity mappings in deep residual networks. In European conference on computer vision, 2016.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. arXiv preprint arXiv:1502.03167, 2015.
+
+Sergey Ivanov and Evgeny Burnaev. Anonymous walk embeddings. arXiv preprint arXiv:1805.11921, 2018.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. arXiv preprint arXiv:1609.02907, 2016.
+
+Johannes Klicpera, Aleksandar Bojchevski, and Stephan Günnemann. Combining neural networks with personalized pagerank for classification on graphs. In International Conference on Learning Representations, 2019. URL https://openreview.net/forum?id $=$ H1gL-2A9Ym.
+
+Yujia Li, Daniel Tarlow, Marc Brockschmidt, and Richard Zemel. Gated graph sequence neural networks. arXiv preprint arXiv:1511.05493, 2015.
+
+Mathias Niepert, Mohamed Ahmed, and Konstantin Kutzkov. Learning convolutional neural networks for graphs. In International conference on machine learning, 2016.
+
+Franco Scarselli, Marco Gori, Ah Chung Tsoi, Markus Hagenbuchner, and Gabriele Monfardini. The graph neural network model. IEEE Transactions on Neural Networks, 2009.
+
+Nino Shervashidze, Pascal Schweitzer, Erik Jan van Leeuwen, Kurt Mehlhorn, and Karsten M Borgwardt. Weisfeiler-lehman graph kernels. Journal of Machine Learning Research, 2011.
+
+Martin Simonovsky and Nikos Komodakis. Dynamic edge-conditioned filters in convolutional neural networks on graphs. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, 2017.
+
+Felix Wu, Tianyi Zhang, Amauri Holanda de Souza Jr, Christopher Fifty, Tao Yu, and Kilian Q Weinberger. Simplifying graph convolutional networks. arXiv preprint arXiv:1902.07153, 2019.
+
+Zhang Xinyi and Lihui Chen. Capsule graph neural network. In International Conference on Learning Representations, 2019. URL https://openreview.net/forum?id $\equiv$ Byl8BnRcYm.
+
+Keyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. How powerful are graph neural networks? In International Conference on Learning Representations, 2019. URL https://openreview.net/ forum?id $\equiv$ ryGs6iA5Km.
+
+Pinar Yanardag and SVN Vishwanathan. Deep graph kernels. In Proceedings of the 21th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, 2015.
+
+Manzil Zaheer, Satwik Kottur, Siamak Ravanbakhsh, Barnabas Poczos, Ruslan R Salakhutdinov, and Alexander J Smola. Deep sets. In Advances in neural information processing systems, 2017.
+
+Matthew D Zeiler and Rob Fergus. Visualizing and understanding convolutional networks. In European conference on computer vision, 2014.
+
+Muhan Zhang, Zhicheng Cui, Marion Neumann, and Yixin Chen. An end-to-end deep learning architecture for graph classification. In Thirty-Second AAAI Conference on Artificial Intelligence, 2018a.
+
+Zhen Zhang, Mianzhi Wang, Yijian Xiang, Yan Huang, and Arye Nehorai. Retgk: Graph kernels based on return probabilities of random walks. In Advances in Neural Information Processing Systems, pages 3964–3974, 2018b.
+
+# A COMPARISONS OF DIFFERENT LINEARIZATIONS
+
+Table 5: Comparisons of different linearizations.   
+
+<table><tr><td>Method</td><td>Graph filtering</td><td>Set function</td><td>Efficiency</td><td>Performance</td></tr><tr><td>GLN</td><td>Linear</td><td>Linear</td><td>High</td><td>Low</td></tr><tr><td>GFNlin</td><td>Linear</td><td>Non-linear</td><td>High</td><td>High</td></tr><tr><td>GCN</td><td>Non-linear</td><td>Linear/Non-linear</td><td>Low</td><td>High</td></tr></table>
+
+Table 5 summarizes the comparisons between GCN and its linearized variants. The efficiency and performance are concluded from our experiments on graph classification benchmarks. Noted that a GNN with a linear graph filtering can be seen as a GFN, but the reverse may not be true. General GFN can have non-linear graph filtering, e.g. when the feature extraction function $\gamma ( G , X )$ is not a linear map of $X$ . Thus we use $\mathrm { G F N } ^ { l i n }$ in Table 5 to denote such subtle difference.
+
+# B PROOFS
+
+Here we provide the proof for Proposition 1.
+
+Proof. According to claim 1 and definition 3, a $\mathrm { G N N } ( G , X )$ with a linear graph filtering part, denoted by $\mathrm { G N N } ^ { l i n } ( G , X )$ , can be written as follows.
+
+$$
+\mathbf { G } \mathbf { N } \mathbf { N } ^ { l i n } ( G , X ) = T \circ { \mathcal { F } } _ { G } ( X ) = { \mathcal { T } } ( \Gamma ( G , X ) \theta ) = { \mathcal { T } } ^ { \prime } ( \Gamma ( G , X ) ) ,
+$$
+
+where $\pmb \theta$ is absorbed into the set function $\tau ^ { \prime } ( \cdot )$ . According to GFN’s definition in Eq. 6 and general set function result from Zaheer et al. (2017), we have
+
+$$
+\operatorname { G F N } ( G , X ) = { \mathcal { T } } ^ { \prime \prime } ( X ^ { G } ) = { \mathcal { T } } ^ { \prime \prime } ( \gamma ( G , X ) ) .
+$$
+
+By setting $\gamma ( G , X ) = \Gamma ( G , X )$ , we arrive at $\mathrm { { G N N } } ^ { l i n } ( G , X ) = \mathrm { { G F N } } ( G , X )$
+
+Here we provide the proof for Proposition 2.
+
+Proof. We show the existence of the mapping $\tau$ by constructing it as follows. First, we assign a unique ID to each of the node, then we add its ID and its neighbors’ IDs in the end of node features. If there are edges with features, we also treat them as nodes and apply the same above procedure. This procedure results in a set of nodes with features that preserve the same original information (since we can reconstruct the original graph).
+
+We now show the existence of a set function that can mimic any graph functions operated on $\mathcal { G }$ , again, by constructing a specific one. Since the set of nodes preserve the whole graph information, the set function can first reconstruct the graph by decoding the node’s feature vectors. At every computation step, the set function find neighbors of each node in the set, and compute the aggregation function in exactly the same way as the graph function would do with the neighbors of a node. This procedure is repeated until the graph function produces its output.
+
+Hence, the above constructed example proves the existence of $\mathcal { M }$ and a set function $\tau$ such that $\forall G \in { \mathcal { G } } _ { X } , { \mathcal { F } } ( G ) \approx { \mathcal { T } } ( { \mathcal { M } } ( G ) )$ . We also note that the specially constructed examples above are feasible but likely not optimal. A better solution is to have a set function that learns to adaptively leverage the graph structure as well as node attributes. □
+
+# C DETAILED STATISTICS OF DATASETS
+
+Detailed statistics of the biological and social graph datasets are listed in Table 6 and 7, respectively.
+
+Table 6: Data statistics of Biological dataset   
+
+<table><tr><td>Dataset</td><td>MUTAG</td><td>NCI1</td><td>PROTEINS</td><td>D&amp;D</td><td>ENZYMES</td></tr><tr><td># graphs</td><td>188</td><td>4110</td><td>1113</td><td>1178</td><td>600</td></tr><tr><td>#classes</td><td>2</td><td>2</td><td>2</td><td>2</td><td>6</td></tr><tr><td># features</td><td>7</td><td>37</td><td>3</td><td>82</td><td>3</td></tr><tr><td>Avg # nodes</td><td>17.93</td><td>29.87</td><td>39.06</td><td>284.32</td><td>32.63</td></tr><tr><td>Avg # edges</td><td>19.79</td><td>32.30</td><td>72.82</td><td>715.66</td><td>62.14</td></tr></table>
+
+Table 7: Data statistics of Social dataset   
+
+<table><tr><td>Dataset</td><td>COLLAB</td><td>IMDB-B</td><td>IMDB-M</td><td>RE-M5K</td><td>RE-12K</td></tr><tr><td># graphs</td><td>5000</td><td>1000</td><td>1500</td><td>4999</td><td>11929</td></tr><tr><td>#classes</td><td>3</td><td>2</td><td>3</td><td>5</td><td>11</td></tr><tr><td># features</td><td>1</td><td>1</td><td>1</td><td>1</td><td>1</td></tr><tr><td>Avg # nodes</td><td>74.49</td><td>19.77</td><td>13.00</td><td>508.52</td><td>391.41</td></tr><tr><td>Avg # edges</td><td>2457.78</td><td>96.53</td><td>65.94</td><td>594.87</td><td>456.89</td></tr></table>
+
+# D EXPERIMENTS ON GRAPH CONSTRUCTED FROM IMAGES (MNIST)
+
+In addition to the common graph benchmarks, we also consider image classification on MNIST where pixels are treated as nodes and eight nearest neighbors in the grid, with an extra self-loop, are used to construct the graph.
+
+For MNIST, we train and evaluate on the given train/test split. Additionally, since MNIST benefits more from deeper GCN layers, we parameterize our GCN model using a residual network (He et al., 2016) with multiple GCN blocks, the number of blocks are kept the same for GCN and GFN, and varied according to the size of total receptive field. GFN utilizes the same multi-scale features as in Eq. 5.
+
+We report the accuracies under different total receptive field sizes (i.e. the number of hops a pixel could condition its computation on). Results in Table 8 show that, in all three different receptive field sizes, GCN with non-linear neighbor aggregation outperforms GFN with linear graph propagated features. This indicates that non-linear graph filtering is essential for performing well in this dataset. Note that our results are not directly comparable to traditional CNN’s, as our GNN does not distinguish the neighbor pixel direction in its parameterization, and a global sum pooling of pixels does not leverage spatial information. For context, when using coordinates as features both GCN and GFN achieve nearly $9 9 \%$ accuracy.
+
+Table 8: Test accuracies $( \% )$ on MNIST graphs.   
+
+<table><tr><td>Receptive size</td><td>GCN</td><td>GFN</td></tr><tr><td>3</td><td>91.47</td><td>87.73</td></tr><tr><td>5</td><td>95.16</td><td>91.83</td></tr><tr><td>7</td><td>96.14</td><td>92.68</td></tr></table>
+
+This test on graphs constructed from image dataset (MNIST), the obser  
+vation that similarly configured GCN outperforms GFN by a large margin, indicates the importance of non-linear graph filtering for this type of graph dataset.
+
+# E DETAILED PERFORMANCES WITH DIFFERENT FEATURES
+
+Table 9 show the performances under different graph features for GNNs and GFNs. It is evident that both model benefit significantly from graph features, especially GFNs.
+
+# F DETAILED PERFORMANCES WITH DIFFERENT ARCHITECTURE DEPTHS
+
+Table 10 shows performance per datasets under different number of layers.
+
+Table 9: Accuracies $( \% )$ under various augmented features. $A ^ { 1 \dots 3 } X$ is abbreviated for $A ^ { 1 } X , A ^ { 2 } X , A ^ { 3 } X$ , and default node feature $X$ is always used (if available) but not displayed to reduce clutter.   
+
+<table><tr><td>Dataset</td><td>Model</td><td>None</td><td>d</td><td>A1x</td><td>A12 X</td><td>A1.x</td><td>d,A¹x</td><td>d,A1,2x</td><td>d,A1..3 x</td></tr><tr><td>MUTAG</td><td>GCN GFN</td><td>83.48 82.21</td><td>87.09 89.31</td><td>83.35 87.59</td><td>83.43 87.17</td><td>85.56 86.62</td><td>87.18 89.42</td><td>87.62 89.28</td><td>88.73 88.26</td></tr><tr><td>NCI1</td><td>GCN GFN</td><td>80.15 70.83</td><td>83.24 75.50</td><td>82.62 80.95</td><td>83.11 82.80</td><td>82.60 83.50</td><td>83.38 81.92</td><td>83.63 82.41</td><td>83.50 82.84</td></tr><tr><td>PROTEINS</td><td>GCN GFN</td><td>74.49 74.93</td><td>76.28 76.63</td><td>74.48 76.01</td><td>75.47 75.74</td><td>76.54 76.64</td><td>77.09 76.37</td><td>76.91 76.46</td><td>77.45 77.09</td></tr><tr><td>DD</td><td>GCN GFN GCN</td><td>79.29 78.70 75.17</td><td>78.78 77.77 67.17</td><td>78.70 77.85 72.00</td><td>77.67 77.43 71.50</td><td>78.18 78.28</td><td>78.35 77.34</td><td>78.79 76.92</td><td>79.12 78.11</td></tr><tr><td>ENZYMES</td><td>GFN GCN</td><td>74.67 39.69</td><td>70.00 82.14</td><td>71.50 76.62</td><td>72.33 76.98</td><td>70.50 70.83 77.22</td><td>69.50 68.50 82.14</td><td>69.33 71.00 82.24</td><td>69.67 69.33 82.20</td></tr><tr><td>COLLAB</td><td>GFN GCN</td><td>31.57 51.00</td><td>80.36 73.00</td><td>76.40 70.30</td><td>77.08 71.10</td><td>77.04 72.20</td><td>81.28 73.50</td><td>81.62 73.80</td><td>81.26 73.70</td></tr><tr><td>IMDB-B IMDB-M</td><td>GFN GCN</td><td>50.00 35.00</td><td>73.30 50.33</td><td>72.30 45.53</td><td>71.30 46.33</td><td>71.70 45.73</td><td>74.40 50.20</td><td>73.20 50.73</td><td>73.90 51.00</td></tr><tr><td>RE-M5K</td><td>GFN GCN GFN</td><td>33.33 28.48</td><td>51.20 56.99</td><td>46.80 54.97</td><td>46.67 57.43</td><td>46.47 56.55</td><td>51.93 56.67</td><td>51.93 56.75</td><td>51.73 57.01</td></tr><tr><td>RE-M12K</td><td>GCN</td><td>20.00 15.93</td><td>54.23 49.28</td><td>51.11 48.58</td><td>55.85 50.11</td><td>56.35 49.71</td><td>56.45 49.73</td><td>57.01 50.03</td><td>56.71 49.92</td></tr><tr><td></td><td>GFN</td><td>17.33</td><td>44.86</td><td>43.61</td><td>48.25</td><td>48.87</td><td>48.31</td><td>49.37</td><td>49.39</td></tr></table>
+
+Table 10: Accuracies $( \% )$ under different number of Conv. layers. Flat denotes the collapsed GFN into a linear model (i.e. linearizing the set function).   
+
+<table><tr><td>Dataset</td><td>Method</td><td>Flat</td><td>1</td><td>2</td><td>3</td><td>4</td><td>5</td></tr><tr><td>MUTAG</td><td>GCN GFN</td><td>= 82.85</td><td>88.32 90.34</td><td>90.89 89.39</td><td>87.65 88.18</td><td>88.31 87.59</td><td>87.68 87.18</td></tr><tr><td>NCI1</td><td>GCN GFN</td><td>- 68.61</td><td>75.62 81.77</td><td>81.41 83.09</td><td>83.04 82.85</td><td>82.94 82.80</td><td>83.31 83.09</td></tr><tr><td>PROTEINS</td><td>GCN GFN</td><td>- 75.65</td><td>76.91 77.71</td><td>76.99 77.09</td><td>77.00 77.17</td><td>76.19 76.28</td><td>75.29 75.92</td></tr><tr><td>DD</td><td>GCN GFN</td><td>- 76.75</td><td>77.34 78.44</td><td>77.93 78.78</td><td>78.95 79.04</td><td>79.46 78.45</td><td>78.77 76.32</td></tr><tr><td>ENZYMES</td><td>GCN GFN</td><td>- 43.83</td><td>67.67 69.67</td><td>69.67 70.50</td><td>67.67 71.67</td><td>66.83 69.83</td><td>66.00 68.17</td></tr><tr><td>COLLAB</td><td>GCN GFN</td><td>- 75.72</td><td>80.36 81.24</td><td>81.86 82.04</td><td>81.40 81.36</td><td>81.90 82.18</td><td>81.78 81.72</td></tr><tr><td>IMDB-B</td><td>GCN GFN</td><td>1 73.10</td><td>72.60 73.50</td><td>72.30 73.30</td><td>73.30 74.00</td><td>73.80 73.90</td><td>73.40 73.60</td></tr><tr><td>IMDB-M</td><td>GCN GFN</td><td>- 50.40</td><td>51.53 51.73</td><td>51.07 52.13</td><td>50.87 51.93</td><td>51.53 51.87</td><td>50.60 51.40</td></tr><tr><td>RE-M5K RE-M12K</td><td>GCN GFN GCN</td><td>- 52.97 -</td><td>54.05 57.45 44.91</td><td>56.49 57.13 48.87</td><td>56.83 57.21 49.45</td><td>56.73 56.61</td><td>56.89 57.03</td></tr></table>
+
+![](images/1ca5eb66dd959a22f90e6811850cf76b4d99132d8192e4c02ec0a324248c94f9.jpg)  
+Figure 3: Training and test performance versus training epoch.
+
+G MORE CURVES ON TRAINING / TEST PERFORMANCE VS EPOCH
+
+Figure 3 shows more training/test curves for both GCN and GFN. The conclusion is consistent with main text that GFN works well not because it is easier to optimize.
+
+# H COMPARISONS TO RETGK AND GNTK
+
+Here we further compare our results to two recent work, namely RetGK (Zhang et al., 2018b) and GNTK (Du et al., 2019). RetGK proposes a family of graph kernels based on return probabilities of random walks, with different instantiations: $\mathrm { R e t G K } _ { I }$ , $\mathrm { R e t G K } _ { I I }$ , and $\mathrm { R e t G K } _ { I I } ( \mathrm { M C } )$ . In their experiments, node attribute are divided into three types: non-attribute, discrete attributes, and continues attributes, and we compare to their reported results. GNTK leverages the connection between infinitely wide networks and kernels to construct an infinitely wide GNN using graph kernels. We also compare to their reported results.
+
+It is worth mentioning that these graph kernel based methods are typically quadratic in the number of graphs and nodes, which makes them hard to scale to large datasets. The proposed GFN has linear complexity and even faster than typical GNNs, which makes our method really scalable to larger datasets.
+
+The results on biological and social graphs are shown in Table 11 and 12 respectively. We found that overall, despite the methodology differences, GFN still performs on par with these methods averaged over compared datasets (with performance differences on some datasets but they are mostly within one standard deviation).
+
+Table 11: Test accuracies $( \% )$ for biological graphs. The best results per dataset and in average are highlighted. - means the results are not available for a particular dataset.   
+
+<table><tr><td>Algorithm</td><td>MUTAG</td><td>NCI1</td><td>PROTEINS</td><td>D&amp;D</td><td>ENZYMES</td><td>Average</td></tr><tr><td>RetGK1(Dis)</td><td>90.3±1.1</td><td>84.5±0.2</td><td>75.8±0.6</td><td>81.6±0.3</td><td>60.4±0.8</td><td>78.52</td></tr><tr><td>RetGK1 (Dis)</td><td>90.1±1.0</td><td>83.5±0.2</td><td>75.2±0.3</td><td>81.0±0.5</td><td>59.1±1.1</td><td>77.78</td></tr><tr><td>RetGK1(Con)</td><td></td><td></td><td>76.2±0.5</td><td></td><td>70.0±0.9</td><td>-</td></tr><tr><td>RetGK1r(Con)</td><td></td><td></td><td>75.9±0.4</td><td></td><td>70.7±0.9</td><td></td></tr><tr><td>RetGK1(Con&amp;Dis)</td><td></td><td></td><td>78.0±0.3</td><td></td><td>72.2±0.8</td><td>=</td></tr><tr><td>RetGK1(Con&amp;Dis)</td><td></td><td></td><td>77.3±0.5</td><td></td><td>70.6±0.7</td><td></td></tr><tr><td>GNTK</td><td>90.00±8.5</td><td>84.2±1.5</td><td>75.6±4.2</td><td></td><td>-</td><td>-</td></tr><tr><td>GCN</td><td>87.20±5.11</td><td>83.65±1.69</td><td>75.65±3.24</td><td>79.12±3.07</td><td>66.50±6.91</td><td>78.42</td></tr><tr><td>GLN</td><td>82.85±12.15</td><td>68.61±2.31</td><td>75.65±4.43</td><td>76.75±5.00</td><td>43.83±5.16</td><td>69.54</td></tr><tr><td>GFN</td><td>90.84±7.22</td><td>82.77±1.49</td><td>76.46±4.06</td><td>78.78±3.49</td><td>70.17±5.58</td><td>79.80</td></tr><tr><td>GFN-light</td><td>89.89±7.14</td><td>81.43±1.65</td><td>77.44±3.77</td><td>78.62±5.43</td><td>69.50±7.37</td><td>79.38</td></tr></table>
+
+Table 12: Test accuracies $( \% )$ for social graphs. The best results per dataset and in average are highlighted. - means the results are not available for a particular dataset.   
+
+<table><tr><td>Algorithm</td><td>COLLAB</td><td>IMDB-B</td><td>IMDB-M</td><td>RE-M5K</td><td>RE-M12K</td><td>Average</td></tr><tr><td>RetGK1(Non)</td><td>81.0±0.3</td><td>71.9±1.0</td><td>47.7±0.3</td><td>56.1±0.5</td><td>48.7±0.2</td><td>61.08</td></tr><tr><td>RetGK1 (Non)</td><td>80.6±0.3</td><td>72.3±0.6</td><td>48.7±0.6</td><td>55.3±0.3</td><td>47.1±0.3</td><td>60.8</td></tr><tr><td>RetGK1 (MC)(Non)</td><td>73.6±0.3</td><td>71.0±0.6</td><td>46.7±0.6</td><td>54.2±0.3</td><td>45.9±0.2</td><td>58.28</td></tr><tr><td>GNTK</td><td>83.6±1.0</td><td>76.9±3.6</td><td>52.8±4.6</td><td>1</td><td>1</td><td>1</td></tr><tr><td>GCN</td><td>81.72±1.64</td><td>73.30±5.29</td><td>51.20±5.13</td><td>56.81±2.37</td><td>49.31±1.44</td><td>62.47</td></tr><tr><td>GLN</td><td>75.72±2.51</td><td>73.10±3.18</td><td>50.40±5.61</td><td>52.97±2.58</td><td>39.84±0.95</td><td>58.41</td></tr><tr><td>GFN</td><td>81.50±2.42</td><td>73.00±4.35</td><td>51.80±5.16</td><td>57.59±2.40</td><td>49.43±1.36</td><td>62.66</td></tr><tr><td>GFN-light</td><td>81.34±1.73</td><td>73.00±4.29</td><td>51.20±5.71</td><td>57.11±1.46</td><td>49.75±1.19</td><td>62.48</td></tr></table>
+
+# I VARYING DATASET SIZE
+
+To test the impact of dataset size, we take the largest graph dataset, RE-M12K, which has 11929 graphs. And we then construct nine new datasets by randomly sampling the original dataset with different ratios, ranging from $10 \%$ to $100 \%$ of all graphs. We compute both training and test accuracies over 10 fold cross-validation for both our GFN and GCN. For each dataset size (10 fold cross validation), we consider two ways to extract performance: (1) selecting best epoch averaged over 10 fold cross validation, or (2) selecting the last epoch (i.e. the 100-th epoch).
+
+Figure 4 shows the results. We can see that as data size increases, 1) it is harder for both models to overfit (training acccuracy decreases), but it seems GCN still overfits more if trained longer (to the last epoch); 2) at the best epoch, both models performance almost identical, without significant gaps between them.
+
+# J GRAPH VISUALIZATIONS
+
+Figure 5, 6, 8, and 7 show the random and mis-classified samples for MUTAG, PROTEINS, IMDB-B, and IMDB-M, respectively. In general, it is difficult to find the patterns of each class by visually examining the graphs. And the mis-classified patterns are not visually distinguishable, except for IMDB-B/IMDB-M datasets where there are some graphs seem ambiguous.
+
+![](images/004f92e13773c29d662684c7adb3124beff9553d403874426300f87b5c132e77.jpg)  
+Figure 4: Performances under varied dataset size. As dataset sizes increases, it becomes harder to overfit (especially for GFN), but GFN still performs as well as, if not better, than GCN.
+
+![](images/7925f7791a8c6ed7ddc6576e03e08de977e13ec0851d8da70ad9475e5fb9a471.jpg)  
+Figure 5: Random and mis-classified samples from MUTAG. Each row represents a (true) class.
+
+![](images/5614e63bb5301532abe8646feb986d94f6679cb904032af5331bb867f48afc86.jpg)  
+Figure 6: Random and mis-classified samples from PROTEINS. Each row represents a (true) class.
+
+![](images/6b92a833cff3ad64a7c7c9da5abab4cfa7bc4f7a82022f9a1978a99ceb6b8c4b.jpg)  
+Figure 7: Random and mis-classified samples from IMDB-B. Each row represents a (true) class.
+
+![](images/5d0f2e2376268631bd24474c868cd9bff3bdb9b39a7875aca0710ad48c25cf64.jpg)  
+Figure 8: Random and mis-classified samples from IMDB-M. Each row represents a (true) class.

parse/train/BJxQxeBYwH/BJxQxeBYwH_content_list.json

@@ -0,0 +1,1906 @@
+[
+    {
+        "type": "text",
+        "text": "ARE POWERFUL GRAPH NEURAL NETS NECESSARY? A DISSECTION ON GRAPH CLASSIFICATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            815,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            170,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Graph Neural Nets (GNNs) have received increasing attentions, partially due to their superior performance in many node and graph classification tasks. However, there is a lack of understanding on what they are learning and how sophisticated the learned graph functions are. In this work, we propose a dissection of GNNs on graph classification into two parts: 1) the graph filtering, where graph-based neighbor aggregations are performed, and 2) the set function, where a set of hidden node features are composed for prediction. To study the importance of both parts, we propose to linearize them separately. We first linearize the graph filtering function, resulting Graph Feature Network (GFN), which is a simple lightweight neural net defined on a set of graph augmented features. Further linearization of GFN’s set function results in Graph Linear Network (GLN), which is a linear function. Empirically we perform evaluations on common graph classification benchmarks. To our surprise, we find that, despite the simplification, GFN could match or exceed the best accuracies produced by recently proposed GNNs (with a fraction of computation cost), while GLN underperforms significantly. Our results demonstrate the importance of non-linear set function, and suggest that linear graph filtering with non-linear set function is an efficient and powerful scheme for modeling existing graph classification benchmarks. ",
+        "bbox": [
+            233,
+            265,
+            766,
+            517
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            544,
+            336,
+            560
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recent years have seen increasing attention to Graph Neural Nets (GNNs) (Scarselli et al., 2009; Li et al., 2015; Defferrard et al., 2016; Kipf and Welling, 2016), which have achieved superior performance in many graph tasks, such as node classification (Kipf and Welling, 2016; Wu et al., 2019) and graph classification (Simonovsky and Komodakis, 2017; Xinyi and Chen, 2019). Different from traditional neural networks that are defined on regular structures such as sequences or images, graphs provide a more general abstraction for structured data, which subsume regular structures as special cases. The power of GNNs is that they can directly define learnable compositional function on (arbitrary) graphs, thus extending classic networks (e.g. CNNs, RNNs) to more irregular and general domains. ",
+        "bbox": [
+            174,
+            575,
+            825,
+            700
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Despite their success, it is unclear what GNNs have learned, and how sophisticated the learned graph functions are. It is shown in (Zeiler and Fergus, 2014) that traditional CNNs used in image recognition have learned complex hierarchical and compositional features, and that deep non-linear computation can be beneficial He et al. (2016). Is this also the case when applying GNNs to common graph problems? Recently, Wu et al. (2019) showed that, for common node classification benchmarks, non-linearity can be removed in GNNs without suffering much loss of performance. The resulting linear GNNs collapse into a logistic regression on graph propagated features. This raises doubts on the necessity of complex GNNs, which require much more expensive computation, for node classification benchmarks. Here we take a step further dissecting GNNs, and examine the necessity of complex GNN parts on more challenging graph classification benchmarks (Yanardag and Vishwanathan, 2015; Zhang et al., 2018a; Xinyi and Chen, 2019). ",
+        "bbox": [
+            174,
+            708,
+            825,
+            861
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To better understand GNNs on graph classification, we dissect it into two parts/stages: 1) the graph filtering part, where graph-based neighbor aggregations are performed, and 2) the set function part, where a set of hidden node features are composed for prediction. We aim to test the importance of both parts separately, and seek answers to the following questions. Do we need a sophisticated graph filtering function for a particular task or dataset? And if we have a powerful set function, is it enough to use a simple graph filtering function? ",
+        "bbox": [
+            176,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To answer these questions, we propose to linearize both parts separately. We first linearize graph filtering part, resulting Graph Feature Network (GFN): a simple lightweight neural net defined on a set of graph augmented features. Unlike GNNs, which learn a multi-step neighbor aggregation function on graphs (Dai et al., 2016; Gilmer et al., 2017), the GFN only utilizes graphs in constructing its input features. It first augments nodes with graph structural and propagated features, and then learns a neural net directly on the set of nodes (i.e. a bag of graph pre-processed feature vectors), which make it more efficient. We then further linearize set function in GFN, and arrive at Graph Linear Network (GLN), which is a linear function of augmented graph features. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            251
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Empirically, we perform evaluations on common graph classification benchmarks (Yanardag and Vishwanathan, 2015; Zhang et al., 2018a; Xinyi and Chen, 2019), and find that GFN can match or exceed the best accuracies produced by recently proposed GNNs, at a fraction of the computation cost. GLN performs much poorly than both GFN and recent GNNs. This result casts doubts on the necessity of non-linear graph filtering, and suggests that the existing GNNs may not have learned more sophisticated graph functions than linear neighbor aggregation on these benchmarks. Furthermore, we find non-linear set function plays an important role, as its linearization can hurt performance significantly. ",
+        "bbox": [
+            174,
+            257,
+            825,
+            369
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 PRELIMINARIES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            392,
+            339,
+            409
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Graph classification problem. We use $G = ( V , E ) \\in \\mathcal { G }$ to denote a graph, where $V$ is a set of vertices/nodes, and $E$ is a set of edges. We further denote an attributed graph as $G _ { X } = ( G , X ) \\in \\mathcal G _ { X }$ , where $\\ b { X } \\in \\mathbb { R } ^ { n \\times d }$ are node attributes with $n = | V |$ . It is assumed that each attributed graph is associated with some label $y \\in \\mathcal { V }$ , where $\\mathcal { V }$ is a set of pre-defined categories. The goal in graph classification problem is to learn a mapping function $f : { \\mathcal { G } } _ { X } \\to \\mathcal { V }$ , such that we can predict the target class for unseen graphs accurately. Many real world problems can be formulated as graph classification problems, such as social and biological graph classification Yanardag and Vishwanathan (2015); Kipf and Welling (2016). ",
+        "bbox": [
+            173,
+            425,
+            826,
+            537
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Graph neural networks. Graph Neural Networks (GNNs) define functions on the space of attributed graph $\\mathcal { G } _ { X }$ . Typically, the graph function, $\\mathrm { G N N } ( G , X )$ , learns a multiple-step transformation of the original attributes/signals for final node level or graph level prediction. In each of the step $t$ , a new node presentation, $h _ { v } ^ { ( t ) }$ is learned. Initially, $h _ { v } ^ { ( 1 ) }$ is initialized with the node attribute vector, and during each subsequent step, a neighbor aggregation function is applied to generate the new node representation. More specifically, common neighbor aggregation functions for the $v$ -th node take the following form: ",
+        "bbox": [
+            173,
+            556,
+            825,
+            659
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2cc70e712ab920e73067bffdea406e84345b4e90b1d7ac8728269133ba0b207e.jpg",
+        "text": "$$\nh _ { v } ^ { ( t ) } = f \\bigg ( h _ { v } ^ { ( t - 1 ) } , \\bigg \\{ h _ { u } ^ { ( t - 1 ) } | u \\in \\mathcal { N } ( v ) \\bigg \\} \\bigg ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            361,
+            661,
+            635,
+            695
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathcal { N } ( v )$ is a set of neighboring nodes of node $v$ . To instantiate this neighbor aggregation function, (Kipf and Welling, 2016) proposes the Graph Convolutional Network (GCN) aggregation scheme as follows. ",
+        "bbox": [
+            176,
+            703,
+            825,
+            746
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b2509d17e64dc78bc290490a9aa1a30f2371e8369a52ed6421029722c5a80836.jpg",
+        "text": "$$\nh _ { v } ^ { ( t + 1 ) } = \\sigma \\bigg ( \\sum _ { u \\in \\mathcal { N } ( v ) } \\tilde { A } _ { u v } ( W ^ { ( t ) } ) ^ { T } h _ { u } ^ { ( t ) } \\bigg ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            364,
+            746,
+            632,
+            787
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $W ^ { ( t ) } \\in \\mathbb { R } ^ { d \\times d ^ { \\prime } }$ is the learnable transformation weight, $\\tilde { A } = \\tilde { D } ^ { - 1 / 2 } ( A + \\epsilon I ) \\tilde { D } ^ { - 1 / 2 }$ is the normalized adjacency matrix with $\\epsilon$ as a constant $\\mathbf { \\epsilon } _ { \\epsilon } = 1$ in Kipf and Welling (2016)) and ${ \\tilde { D } } _ { i i } =$ $\\begin{array} { r } { \\sum _ { j } A _ { i j } + \\epsilon . ~ \\sigma ( \\cdot ) } \\end{array}$ is a non-linear activation function, such as ReLU. This transformation can also be written as $H ^ { ( t + 1 ) } = \\sigma ( \\tilde { A } H ^ { ( t ) } W ^ { ( t ) } )$ , where $H ^ { ( t ) } \\in \\mathbb { R } ^ { n \\times d }$ are the hidden states of all nodes at $t { \\cdot }$ -th step. ",
+        "bbox": [
+            173,
+            795,
+            825,
+            876
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "More sophisticated neighbor aggregation schemes are also proposed, such as GraphSAGE (Hamilton et al., 2017) which allows pooling and recurrent aggregation over neighboring nodes. Most recently, in Graph Isomorphism Network (GIN) $\\mathrm { { X u } }$ et al., 2019), a more powerful aggregation function is ",
+        "bbox": [
+            176,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "proposed as follows. ",
+        "bbox": [
+            173,
+            103,
+            310,
+            118
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7a75e131c92dc052ade8f9848c00ef0927ee2f54bab7cca453be88bf5c5b84aa.jpg",
+        "text": "$$\nh _ { v } ^ { ( t ) } = \\mathbf { M } \\mathbf { L } \\mathbf { P } ^ { ( t ) } \\bigg ( \\bigg ( 1 + \\epsilon ^ { ( t ) } \\bigg ) h _ { v } ^ { ( t - 1 ) } + \\sum _ { u \\in \\mathcal { N } ( v ) } h _ { u } ^ { ( t - 1 ) } \\bigg ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            320,
+            127,
+            676,
+            170
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where MLP abbreviates for multi-layer perceptrons and $\\epsilon ^ { ( t ) }$ can either be zero or a learnable parameter. ",
+        "bbox": [
+            173,
+            180,
+            825,
+            196
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Finally, in order to generate graph level representation $h _ { G }$ , a readout function is used, which generally takes the following form: ",
+        "bbox": [
+            173,
+            202,
+            825,
+            231
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/898391c249bc52276be97f68116a9da7551af847725ee6fa018c6fc87db1111f.jpg",
+        "text": "$$\nh _ { G } = g \\bigg ( \\bigg \\{ h _ { v } ^ { ( T ) } | v \\in G \\bigg \\} \\bigg ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            406,
+            233,
+            589,
+            268
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "This can be instantiated by a global sum pooling, i.e. $\\begin{array} { r } { h _ { G } = \\sum _ { v = 1 } ^ { n } h _ { v } ^ { ( T ) } } \\end{array}$ followed by fully connected layers to generate the categorical or numerical output. ",
+        "bbox": [
+            171,
+            277,
+            825,
+            309
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 APPROACH",
+        "text_level": 1,
+        "bbox": [
+            174,
+            332,
+            299,
+            348
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 GRAPH FEATURE NETWORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            366,
+            406,
+            381
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Motivated by the question that, with a powerful graph readout function, whether wwe can simplify the sophisticated multi-step neighbor aggregation functions (such as Eq. 2 and 3). Therefore we propose Graph Feature Network (GFN): a neural set function defined on a set of graph augmented features. ",
+        "bbox": [
+            173,
+            393,
+            825,
+            449
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Graph augmented features. In GFN, we replace the sophisticated neighbor aggregation functions (such as Eq. 2 and 3) with graph augmented features based on $G _ { X }$ . Here we consider two categories as follows: 1) graph structural/topological features, which are related to the intrinsic graph structure, such as node degrees, or node centrality scores1, but do not rely on node attributes; 2) graph propagated features, which leverage the graph as a medium to propagate node attributes. The graph augmented features $X ^ { G }$ can be seen as the output of a feature extraction function defined on the attributed graph, i.e. $X ^ { G } = \\gamma ( G , X )$ , and Eq. 5 below gives a specific form, which combine node degree features and multi-scale graph propagated features as follows: ",
+        "bbox": [
+            173,
+            467,
+            826,
+            580
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0250f08e5a4ce388ffdbdb1815b9672fc16e7c6d13c69e4e74c2966d4c3649a0.jpg",
+        "text": "$$\nX ^ { G } = \\gamma ( G , X ) = \\bigg [ d , X , \\tilde { A } ^ { 1 } X , \\tilde { A } ^ { 2 } X , \\cdot \\cdot \\cdot , \\tilde { A } ^ { K } X \\bigg ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            326,
+            589,
+            669,
+            625
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\ b { d } \\in \\mathbb { R } ^ { n \\times 1 }$ is the degree vector for all nodes, and $\\tilde { A }$ is again the normalized adjacency matrix $( \\tilde { A } = \\tilde { D } ^ { - 1 / 2 } ( A + \\epsilon I ) \\tilde { D } ^ { - 1 / 2 } )$ , but other designs of propagation operator are possible (Klicpera et al., 2019). Features separated by comma are concatenated to form $\\bar { X ^ { G } }$ . ",
+        "bbox": [
+            173,
+            636,
+            825,
+            681
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Neural set function. To build a powerful graph readout function based on graph augmented features $X ^ { G }$ , we use a neural set function. The neural set function discards the graph structures and learns purely based on the set of augmented node features. Motivated by the general form of a permutationinvariant set function shown in Zaheer et al. (2017), we define our neural set function for GFN as follows: ",
+        "bbox": [
+            173,
+            699,
+            826,
+            768
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8d9d55a95434cb0f899345cb977045688a34cf7025d19f8c0e16023fd630d50a.jpg",
+        "text": "$$\n\\mathrm { G F N } ( G , X ) = \\rho \\bigg ( \\sum _ { v \\in \\mathcal { V } } \\phi \\bigg ( X _ { v } ^ { G } \\bigg ) \\bigg ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            382,
+            768,
+            616,
+            809
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Both $\\phi ( \\cdot )$ and $\\rho ( \\cdot )$ are parameterized by neural networks. Concretely, we parameterize the function $\\phi ( \\cdot )$ as a multi-layer perceptron (MLP), i.e. $\\phi ( x ) = \\sigma ( \\sigma ( \\cdot \\cdot \\cdot \\sigma ( x ^ { T } W ^ { ( 1 ) } ) \\cdot \\cdot \\cdot ) W ^ { ( T ) } )$ . Note that a single layer of $\\phi ( \\cdot )$ resembles a graph convolution layer $H ^ { ( t + 1 ) } = \\sigma ( \\tilde { A } H ^ { ( t ) } W ^ { ( t ) } )$ with the normalized adjacency matrix $\\tilde { A }$ replaced by identity matrix $I$ (a.k.a. $1 \\times 1$ convolution). As for the function $\\rho ( \\cdot )$ , we parameterize it with another MLP (i.e. fully connected layers in this case). ",
+        "bbox": [
+            173,
+            815,
+            825,
+            893
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Computation efficiency. GFN provides a way to approximate GNN with less computation overheads, especially during the training process. Since the graph augmented features can be pre-computed before training starts, the graph structures are not involved in the iterative training process. This brings the following advantages. First, since there is no neighbor aggregation step in GFN, it reduces computational complexity. To see this, one can compare a single layer feature transformation function in GFN, i.e. $\\sigma ( H W )$ , against the neighbor aggregation function in GCN, i.e. $\\sigma ( \\tilde { A } H W )$ . Secondly, since graph augmented features of different scales are readily available from the input layer, GFN can leverage them much earlier, thus may require fewer transformation layers. Lastly, it also eases the implementation related overhead, since the neighbor aggregation operation in graphs are typically implemented by sparse matrix operations. ",
+        "bbox": [
+            173,
+            103,
+            826,
+            244
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Graph Linear Network. When we use a linear set function instead of the generic one used in Eq.   \n6, we arrive at graph linear network, which can be expressed as follows. ",
+        "bbox": [
+            173,
+            258,
+            823,
+            287
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/408e74414a992f4207c5988d80fe23975ab32637b28aede96c5bb483a0ac4bbf.jpg",
+        "text": "$$\n\\mathrm { G L N } ( G , X ) = \\sigma \\bigg ( W \\sum _ { v \\in \\mathcal { V } } \\bigg ( X _ { v } ^ { G } \\bigg ) \\bigg ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            377,
+            290,
+            620,
+            330
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Where $W$ is a weight matrix, and $\\sigma ( \\cdot )$ is softmax function produce class probability. ",
+        "bbox": [
+            174,
+            333,
+            722,
+            348
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 FROM GNN TO GFN AND GLN: A DISSECTION OF GNNS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            363,
+            616,
+            378
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To better understand GNNs on graph classification, we propose a formal dissection/decomposition of GNNs into two parts/stages: the graph filtering part and the set function part. As we shall see shortly, the simplification of the graph filtering part allows us to derive GFN from GNN, and also be able to assess the importance of the two GNN parts separately. ",
+        "bbox": [
+            176,
+            390,
+            825,
+            446
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To make concepts more clear, we first give formal definitions of the two GNN parts in the dissection. Definition 1. (Graph filtering) A graph filtering function, $Y = { \\mathcal { F } } _ { G } ( X )$ , performs a transformation of input signals based on the graph $G$ , which takes a set of signals $\\dot { X } \\in \\mathbb { R } ^ { n \\times d }$ and outputs another set of filtered signals Y ∈ Rm×d0 . ",
+        "bbox": [
+            174,
+            453,
+            825,
+            515
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Graph filtering in most existing GNNs consists of multi-step neighbor aggregation operations, i.e. multiple steps of Eq. 1. For example, in GCN Kipf and Welling (2016), the multi-step neighbor aggregation can be expressed as $\\bar { H ^ { ( T ) } } = \\sigma ( A \\sigma ( . . . \\bar { \\sigma } ( A X W ^ { ( 1 ) } ) . . . \\bar { ) } W ^ { ( T ) } )$ . ",
+        "bbox": [
+            174,
+            525,
+            826,
+            569
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Definition 2. (Set function) A set function, $y = \\mathcal { T } ( Y )$ , takes a set of vectors $Y \\in \\mathbb { R } ^ { m \\times d ^ { \\prime } }$ where their order does not matter, and outputs a task specific prediction $y \\in \\mathcal { V }$ . ",
+        "bbox": [
+            173,
+            573,
+            821,
+            603
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The graph readout function in Eq. 4 is a set function, which enables the graph level prediction that is permutation invariant w.r.t. nodes in the graph. Although a typical readout function is simply a global pooling (Xu et al., 2019), the set function can be as complicated as Eq. 6. ",
+        "bbox": [
+            174,
+            613,
+            825,
+            655
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Claim 1. A GNN that is a mapping of $\\mathcal { G } _ { X }  \\mathcal { V }$ can be decomposed into a graph filtering function followed by a set function, i.e. $G N N ( G , X ) = \\mathcal { T } \\circ \\mathcal { F } _ { G } ( X )$ . ",
+        "bbox": [
+            173,
+            657,
+            821,
+            688
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "This claim is obvious for the neighbor aggregation framework defined by Eq. 1 and 4, where most existing GNN variants such as GCN, GraphSAGE and GIN follow. This claim is also general, even for unforeseen GNN variants that do not explicitly follow this framework 2. ",
+        "bbox": [
+            174,
+            696,
+            825,
+            738
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We aim to assess the importance of two GNN parts separately. However, it is worth pointing out that the above decomposition is not unique in general, and the functionality of the two parts can overlap: if the graph filtering part has fully transformed graph features, then a simple set function may be used for prediction. This makes it challenging to answer the question: do we need a sophisticated graph filtering part for a particular task or dataset, especially when a powerful set function is used? To better disentangle these two parts and study their importance more independently, similar to $\\mathrm { W u }$ et al. (2019), we propose to simplify the graph filtering part by linearizing it. ",
+        "bbox": [
+            173,
+            746,
+            825,
+            844
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Definition 3. (Linear graph filtering) We say a graph filtering function ${ \\mathcal { F } } _ { G } ( X )$ is linear w.r.t. $X$ iff it can be expressed as ${ \\mathcal { F } } _ { G } ( X ) = \\Gamma ( G , X ) \\theta$ , where $\\Gamma ( G , X )$ is a linear map of $X$ , and $\\pmb \\theta$ is the only learnable parameter. ",
+        "bbox": [
+            174,
+            847,
+            825,
+            888
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Intuitively, one can construct a linear graph filtering by removing the non-linear operations from graph filtering part in existing GNNs, such as non-linear activation function $\\sigma ( \\cdot )$ in Eq. 2 or 3. By doing so, the graph filtering becomes linear w.r.t. X, thus multi-layer weights collapse into a single linear transformation, described by $\\pmb { \\theta }$ . More concretely, let us consider a linearized GCN Kipf and Welling (2016), its $K$ -th layer can be written as $H ^ { ( K ) } = \\hat { A } ^ { K } X ( \\Pi _ { k = 1 } ^ { K } W ^ { ( k ) } )$ , and we can rewrite the weights with $\\pmb \\theta = \\Pi _ { k = 1 } ^ { K } W ^ { ( k ) }$ . ",
+        "bbox": [
+            174,
+            103,
+            825,
+            193
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The linearization of graph filtering part enables us to disentangle graph filtering and the set function more thoroughly: the graph filtering part mainly constructs graph augmented features (by setting $\\gamma ( G , X ) = \\Gamma ( G , X ) )$ , and the set function learns to compose them for the graph-level prediction. This leads to the proposed GFN. In other words, GNNs with a linear graph filtering part can be expressed as GFN with appropriate graph augmented features. This is shown more formally in the following proposition 1. ",
+        "bbox": [
+            173,
+            198,
+            825,
+            282
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Proposition 1. Let $G N N ^ { l i n } ( G , X )$ be a mapping of $\\mathcal { G } _ { X }  \\mathcal { V }$ that has a linear graph filtering part, i.e. ${ \\mathcal { F } } _ { G } ( X ) = \\Gamma ( G , X ) \\theta$ , then we have $G N N ^ { l i n } ( G , X ) = G F N ( G , X )$ , where $\\gamma ( G , X ) = \\Gamma ( G , X )$ ",
+        "bbox": [
+            173,
+            287,
+            825,
+            320
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The proof can be found in the appendix. Noted that a GNN with a linear graph filtering can be seen as a GFN, but the reverse may not be true. General GFN can have non-linear graph filtering, e.g. when the feature extraction function $\\gamma ( G , X )$ is not a linear map of $X$ (Eq. 5 is a linear map of $X$ ). ",
+        "bbox": [
+            174,
+            332,
+            825,
+            375
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Why GFN? GFN can also help us understand the functions that GNNs learned on current benchmarks. First, by comparing GNN with linear graph filtering (i.e. GFN) against standard GNN with non-linear graph filtering, we can assess the importance of non-linear graph filtering part. Secondly, by comparing GFN with linear set function (i.e. GLN) against GFN with non-linear set function, we can assess the importance of non-linear set function. ",
+        "bbox": [
+            174,
+            392,
+            825,
+            462
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Beyond as a tool to study GNN parts, GFN is also more efficient than GNN counterpart, which makes it a fast approximation. Furthermore, GFNs can be a very powerful framework without restriction on the feature extraction function $\\gamma ( G , X )$ and the exact forms of the set function. The potential expressiveness of a GFN is demonstrated by the following proposition. ",
+        "bbox": [
+            174,
+            468,
+            825,
+            526
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Proposition 2. For any GNN $\\mathcal { F }$ defined in $\\mathcal { G } _ { X }$ , there exists a graph to set mapping $\\mathcal { M } : \\mathcal { G }  \\mathcal { S }$ where $s$ is a set space, and a set function $\\tau$ that approximates $\\mathcal { F }$ to arbitrary precision, i.e. $\\forall G \\in$ $\\mathcal { G } _ { X } , F ( G ) \\approx \\mathcal { T } ( \\mathcal { M } ( G ) )$ . ",
+        "bbox": [
+            174,
+            530,
+            825,
+            574
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The proof is provided in the appendix. We want to provide an intuitive interpretation here. There exists some way(s) that we can encode any graph into a set, and learn a generic set function on it. As long as the set contains the graph information, a powerful set function can learn to integrate it in a flexible way. So a well constructed GFN can be as powerful as, if not more powerful than, the most powerful GNNs. This shows the potential of the GFN framework in modeling arbitrary graph data. ",
+        "bbox": [
+            174,
+            585,
+            825,
+            656
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            679,
+            326,
+            695
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 DATASETS AND SETTINGS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            712,
+            393,
+            726
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Datasets. The main datasets we consider are commonly used graph classification benchmarks (Yanardag and Vishwanathan, 2015; Xinyi and Chen, 2019; Xu et al., 2019). The graphs in the collection can be categorized into two categories: (1) biological graphs, including MUTAG, NCI1, PROTEINS, D&D, ENZYMES; and (2) social graphs, including COLLAB, IMDB-Binary (IMDB-B), IMDBMulti (IMDB-M), Reddit-Multi-5K (RE-M5K), Reddit-Multi-12K (RE-M12K). It is worth noting that the social graphs have no node attributes, while the biological graphs come with categorical node attributes. The detailed statistics can be found in the appendix. ",
+        "bbox": [
+            174,
+            738,
+            826,
+            835
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Baselines. We compare with two families of baselines. The first family of baselines are kernel-based, namely the Weisfeiler-Lehman subtree kernel (WL) (Shervashidze et al., 2011), Deep Graph Kernel (DGK) (Yanardag and Vishwanathan, 2015) and AWE (Ivanov and Burnaev, 2018) that incorporate kernel-based methods with learning-based approach to learn embeddings. The second family of baselines are GNN-based models, which include recently proposed PATCHY-SAN (PSCN) (Niepert et al., 2016), Deep Graph CNN (DGCNN) (Zhang et al., 2018a), CapsGNN (Xinyi and Chen, 2019) and GIN (Xu et al., 2019). ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/5873aa1ae56e4c41fbccbd6f180b917718fe620ec43a7c5440799fcbb1591806.jpg",
+        "table_caption": [
+            "Table 1: Test accuracies $( \\% )$ for biological graphs. The best results per dataset and in average are highlighted. - means the results are not available for a particular dataset. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Algorithm</td><td>MUTAG</td><td>NCI1</td><td>PROTEINS</td><td>D&amp;D</td><td>ENZYMES</td><td>Average</td></tr><tr><td>WL</td><td>82.05±0.36</td><td>82.19±0.18</td><td>74.68±0.49</td><td>79.78±0.36</td><td>52.22±1.26</td><td>74.18</td></tr><tr><td>AWE</td><td>87.87±9.76</td><td>-</td><td>-</td><td>71.51±4.02</td><td>35.77±5.93</td><td>-</td></tr><tr><td>DGK</td><td>87.44±2.72</td><td>80.31±0.46</td><td>75.68±0.54</td><td>73.50±1.01</td><td>53.43±0.91</td><td>74.07</td></tr><tr><td>PSCN</td><td>88.95±4.37</td><td>76.34±1.68</td><td>75.00±2.51</td><td>76.27±2.64</td><td>-</td><td>-</td></tr><tr><td>DGCNN</td><td>85.83±1.66</td><td>74.44±0.47</td><td>75.54±0.94</td><td>79.37±0.94</td><td>51.00±7.29</td><td>73.24</td></tr><tr><td>CapsGNN</td><td>86.67±6.88</td><td>78.35±1.55</td><td>76.28±3.63</td><td>75.38±4.17</td><td>54.67±5.67</td><td>74.27</td></tr><tr><td>GIN</td><td>89.40±5.60</td><td>82.70±1.70</td><td>76.20±2.80</td><td>1</td><td>1</td><td>1</td></tr><tr><td>GCN</td><td>87.20±5.11</td><td>83.65±1.69</td><td>75.65±3.24</td><td>79.12±3.07</td><td>66.50±6.91</td><td>78.42</td></tr><tr><td>GLN</td><td>82.85±12.15</td><td>68.61±2.31</td><td>75.65±4.43</td><td>76.75±5.00</td><td>43.83±5.16</td><td>69.54</td></tr><tr><td>GFN</td><td>90.84±7.22</td><td>82.77±1.49</td><td>76.46±4.06</td><td>78.78±3.49</td><td>70.17±5.58</td><td>79.80</td></tr><tr><td>GFN-light</td><td>89.89±7.14</td><td>81.43±1.65</td><td>77.44±3.77</td><td>78.62±5.43</td><td>69.50±7.37</td><td>79.38</td></tr></table>",
+        "bbox": [
+            191,
+            140,
+            803,
+            325
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/7a489885846000878d83f020a0d6efe16dc0650c3e7231c9fa71abd80bae3ce6.jpg",
+        "table_caption": [
+            "Table 2: Test accuracies $( \\% )$ for social graphs. The best results per dataset and in average are highlighted. - means the results are not available for a particular dataset. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Algorithm</td><td>COLLAB</td><td>IMDB-B</td><td>IMDB-M</td><td>RE-M5K</td><td>RE-M12K</td><td>Average</td></tr><tr><td>WL</td><td>79.02±1.77</td><td>73.40±4.63</td><td>49.33±4.75</td><td>49.44±2.36</td><td>38.18±1.30</td><td>57.87</td></tr><tr><td>AWE</td><td>73.93±1.94</td><td>74.45±5.83</td><td>51.54±3.61</td><td>50.46±1.91</td><td>39.20±2.09</td><td>57.92</td></tr><tr><td>DGK</td><td>73.09±0.25</td><td>66.96±0.56</td><td>44.55±0.52</td><td>41.27±0.18</td><td>32.22±0.10</td><td>51.62</td></tr><tr><td>PSCN</td><td>72.60±2.15</td><td>71.00±2.29</td><td>45.23±2.84</td><td>49.10±0.70</td><td>41.32±0.42</td><td>55.85</td></tr><tr><td>DGCNN</td><td>73.76±0.49</td><td>70.03±0.86</td><td>47.83±0.85</td><td>48.70±4.54</td><td></td><td>=</td></tr><tr><td>CapsGNN</td><td>79.62±0.91</td><td>73.10±4.83</td><td>50.27±2.65</td><td>52.88±1.48</td><td>46.62±1.90</td><td>60.50</td></tr><tr><td>GIN</td><td>80.20±1.90</td><td>75.10±5.10</td><td>52.30±2.80</td><td>57.50±1.50</td><td>1</td><td>1</td></tr><tr><td>GCN</td><td>81.72±1.64</td><td>73.30±5.29</td><td>51.20±5.13</td><td>56.81±2.37</td><td>49.31±1.44</td><td>62.47</td></tr><tr><td>GLN</td><td>75.72±2.51</td><td>73.10±3.18</td><td>50.40±5.61</td><td>52.97±2.58</td><td>39.84±0.95</td><td>58.41</td></tr><tr><td>GFN</td><td>81.50±2.42</td><td>73.00±4.35</td><td>51.80±5.16</td><td>57.59±2.40</td><td>49.43±1.36</td><td>62.66</td></tr><tr><td>GFN-light</td><td>81.34±1.73</td><td>73.00±4.29</td><td>51.20±5.71</td><td>57.11±1.46</td><td>49.75±1.19</td><td>62.48</td></tr></table>",
+        "bbox": [
+            194,
+            382,
+            799,
+            566
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            594,
+            825,
+            623
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For the above baselines, we use their accuracies reported in the original papers, following the same evaluation setting as in (Xu et al., 2019). Architecture and hyper-parameters can make a difference, so to enable a better controlled comparison between GFN and GNN, we also implement Graph Convolutional Networks (GCN) from (Kipf and Welling, 2016). More specifically, our GCN model contains a dense feature transformation layer, i.e. $H ^ { ( 2 ) } = \\sigma ( X W ^ { ( 1 ) } )$ , followed by three GCN layers, i.e. $H ^ { ( t + 1 ) } = \\sigma ( \\tilde { A } H ^ { ( t ) } W ^ { ( t ) } )$ . We also vary the number of GCN layers in our ablation study. To enable graph level prediction, we add a global sum pooling, followed by two fully-connected layers that produce categorical probability over pre-defined categories. ",
+        "bbox": [
+            173,
+            630,
+            825,
+            746
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Model configurations. For the proposed GFN, we mirror our GCN model configuration to allow direct comparison. Therefore, we use the same architecture, parameterization and training setup, but replace the GCN layer with feature transformation layers (totaling four such layers). Converting GCN layer to feature transformation layer is equivalent to setting $A = I$ in in GCN layers. We also construct a faster GFN, namely “GFN-light”, that contains only a single feature transformation layer, which can further reduce the training time while maintaining similar performance. ",
+        "bbox": [
+            173,
+            762,
+            825,
+            847
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For both our GCN and GFN, we utilize ReLU activation and batch normalization (Ioffe and Szegedy, 2015), and fix the hidden dimensionality to 128. No regularization is applied. Furthermore we use batch size of 128, a fixed learning rate of 0.001, and the Adam optimizer (Kingma and Ba, 2014). GLN follows the same setting as GFN, but contains no feature transform layer. It only has the global sum pooling of graph features followed by a single fully connected layer. To compare with existing work, we follow (Xinyi and Chen, 2019; $\\mathrm { X u }$ et al., 2019) and perform 10-fold cross validation. We run the model for 100 epochs, and select the epoch in the same way as $\\mathrm { X u }$ et al. (2019), i.e., a single epoch with the best cross-validation accuracy averaged over the 10 folds is selected. We report the average and standard deviation of test accuracies at the selected epoch over 10 folds. ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            159
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In terms of input node features for GFN and GLN, by default, we use both degree and multi-scale propagated features (up to $K = 3$ ), that is $[ d , X , \\tilde { A } ^ { 1 } X , \\tilde { A } ^ { 2 } X , \\tilde { A } ^ { 3 } X ]$ . We turn discrete features into one-hot vectors, and also discretize degree features into one-hot vectors, as suggested in Fey and Lenssen (2019). We set $X = { \\vec { 1 } }$ for the social graphs we consider as there are no node attributes. By default, we also augment node features in our GCN with an extra node degree feature (to counter that the normalized adjacency matrix may lose the degree information). Other graph augmented features are also studied for GCN (which has minor effects). All experiments are run on Nvidia GTX 1080 Ti GPU. ",
+        "bbox": [
+            174,
+            166,
+            825,
+            281
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 PERFORMANCE COMPARISON BETWEEN GLN, GFN AND EXISTING GNN VARIANTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            297,
+            795,
+            313
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 1 and 2 show the results of different methods in both biological and social datasets. It is worth noting that in both datasets, GFN achieves similar performances with our GCN, and match or exceed existing state-of-the-art results on multiple datasets, while GLN performs worse in most of the datasets. This result suggests the importance of non-linear set function, while casting doubt on the necessity of non-linear graph filtering for these benchmarks. ",
+        "bbox": [
+            174,
+            324,
+            825,
+            393
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/4635eb89e08a70cb0b220272a0d8982bc79862d9934431a70e4c00364be4cfcb.jpg",
+        "image_caption": [
+            "Figure 1: Training and test performance versus training epoch. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            406,
+            813,
+            553
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Figure 1 shows training/test curves for both GCN and GFN. We observe that GCN usually perform better than GFN during the training, but their test performances are mostly similar (sometimes GFN is better as training continues). This concludes that GFN works well not because it is easier to optimize. ",
+        "bbox": [
+            173,
+            593,
+            826,
+            636
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 TRAINING TIME COMPARISONS BETWEEN GFNS AND GCNS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            652,
+            632,
+            666
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Since GFN’s performance is on par with GCN’s, we further compare the training time of our GCN and the proposed GFNs. Figure 2 shows that a significant speedup (from $1 . 4 \\times$ to $6 . 7 \\times$ as fast) by utilizing GFN compared to GCN, especially for datasets with denser edges such as the COLLAB dataset. Also since our GFN can work with fewer transformation layers, GFN-light can achieve better speedup by reducing the number of transformation layers. Note that our GCN is already very efficient as it is built on a highly optimized framework Fey and Lenssen (2019). ",
+        "bbox": [
+            174,
+            678,
+            825,
+            762
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.4 ABLATIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            780,
+            297,
+            792
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Node features. To better understand the impact of features, we test both models with different input node features. Table 3 shows that 1) graph features are very important for both GFN and GCN, 2) the node degree feature is surprisingly important, and multi-scale features can further improve on that, and 3) even with multi-scale features, GCN still performs similarly to GFN, which further suggests that linear graph filtering is enough. More detailed results (per dataset) can be found in the appendix. ",
+        "bbox": [
+            174,
+            804,
+            825,
+            875
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Architecture depth. We vary the number of convolutional layers (with two FC-layers after sum pooling kept the same). Table 4 shows that 1) GCN benefits from multiple grpah convolutional layers with a significant diminishing return, 2) GFN with single feature transformation layer works pretty well already, likely due to the availability of multi-scale input node features, which otherwise require multiple GCN layers to obtain. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/44cb3f53b08b7a6bb8ec43af6945c2e0fd3e917b403c4d3e18e94beab8e51095.jpg",
+        "image_caption": [
+            "Figure 2: Training time comparisons. The annotation, e.g. $1 . 0 \\times$ , denotes speedup compared to GCN. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            102,
+            818,
+            223
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/e9209252e08f3a0a2d7f120f9c79f5d0049518d881f206e57fb42f8b7f4cf803.jpg",
+        "table_caption": [
+            "Table 3: Accuracies $( \\% )$ under various augmented features. Averaged results over multiple datasets are shown here. $A ^ { 1 , 2 , 3 } X$ is abbreviated for $A ^ { 1 } X , A ^ { 2 } X , A ^ { 3 } X$ , and default node feature $X$ is always used (if available) but not displayed to reduce clutter. Best results per row/block are highlighted. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Graphs</td><td>Model</td><td>None</td><td>d</td><td>A1x</td><td>A12X</td><td>A1,23 x</td><td>d,A¹x</td><td>d,A12 x</td><td>d,A1.2.3 X</td></tr><tr><td rowspan=\"2\">Bio.</td><td>GCN</td><td>78.52</td><td>78.51</td><td>78.23</td><td>78.24</td><td>78.68</td><td>79.10</td><td>79.26</td><td>79.69</td></tr><tr><td>GFN</td><td>76.27</td><td>77.84</td><td>78.78</td><td>79.09</td><td>79.17</td><td>78.71</td><td>79.21</td><td>79.13</td></tr><tr><td rowspan=\"2\">Soical</td><td>GCN</td><td>34.02</td><td>62.35</td><td>59.20</td><td>60.39</td><td>60.28</td><td>62.45</td><td>62.71</td><td>62.77</td></tr><tr><td>GFN</td><td>30.45</td><td>60.79</td><td>58.04</td><td>59.83</td><td>60.09</td><td>62.47</td><td>62.63</td><td>62.60</td></tr></table>",
+        "bbox": [
+            174,
+            319,
+            823,
+            410
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/303eefb01a064a24057415b1983b88ff6519c6f284a1fad41f8b1d32286b6bb4.jpg",
+        "table_caption": [
+            "Table 4: Accuracies $( \\% )$ under different number of Conv. layers. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td></td><td>1</td><td>2</td><td>3</td><td>4</td><td>5</td></tr><tr><td>Bio.</td><td>GCN</td><td>77.17</td><td>79.38</td><td>78.86</td><td>78.75</td><td>78.21</td></tr><tr><td></td><td>GFN</td><td>79.59</td><td>79.77</td><td>79.78</td><td>78.99</td><td>78.14</td></tr><tr><td>Soical</td><td>GCN</td><td>60.69</td><td>62.12</td><td>62.37</td><td>62.70</td><td>62.46</td></tr><tr><td></td><td>GFN</td><td>62.70</td><td>62.88</td><td>62.81</td><td>62.80</td><td>62.60</td></tr></table>",
+        "bbox": [
+            312,
+            452,
+            686,
+            542
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            569,
+            823,
+            597
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Visualization. We also provide visualization of random and misclassified samples from the tested graph datasets in the appendix J. We could not clearly distinguish graphs from different classes easily based on their appearance, suggesting that both GFN and GCN are capturing underlying non-trivial features. ",
+        "bbox": [
+            174,
+            603,
+            825,
+            660
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            681,
+            310,
+            698
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this work, we conduct a dissection of GNNs on common graph classification benchmarks. We first decompose GNNs into two parts, and linearize the graph filtering part resulting GFN. We then further linearize the set function of GFN resulting GLN. In our extensive experiments, we find GFN can match or exceed the best results by recently proposed GNNs, with a fraction of computation cost. The linearization of graph filtering (i.e. GFN) has little impact on performance, while linearization of both graph filtering and set function (i.e. GLN) leads to worse performance. ",
+        "bbox": [
+            174,
+            713,
+            825,
+            797
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Since GCN usually achieve better training accuracies while not better test accuracies, we conjecture that the linear graph filtering may be a good inductive bias for tested datasets, though this is speculative and requires more future investigations. Another possibility is that complexity of current graph classification benchmarks is limited, so that linear graph filtering is enough, thus moving to datasets or problems with information that is more structurally complicated could require sophisticated non-linear graph filtering. ",
+        "bbox": [
+            174,
+            804,
+            825,
+            888
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We also observe the potential of GFN, which leverages a generic set function to model graphs. In the future, we would like to build upon the powerful general GFN framework for structured data. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            287,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Hanjun Dai, Bo Dai, and Le Song. Discriminative embeddings of latent variable models for structured data. In International conference on machine learning, 2016. ",
+        "bbox": [
+            174,
+            125,
+            823,
+            151
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Michaël Defferrard, Xavier Bresson, and Pierre Vandergheynst. Convolutional neural networks on graphs with fast localized spectral filtering. In Advances in neural information processing systems, 2016. ",
+        "bbox": [
+            174,
+            160,
+            823,
+            188
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Simon S. Du, Kangcheng Hou, Barnabás Póczos, Ruslan Salakhutdinov, Ruosong Wang, and Keyulu Xu. Graph neural tangent kernel: Fusing graph neural networks with graph kernels. ArXiv, abs/1905.13192, 2019. ",
+        "bbox": [
+            173,
+            196,
+            821,
+            224
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Matthias Fey and Jan E. Lenssen. Fast graph representation learning with PyTorch Geometric. In ICLR Workshop on Representation Learning on Graphs and Manifolds, 2019. ",
+        "bbox": [
+            173,
+            233,
+            821,
+            261
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Justin Gilmer, Samuel S Schoenholz, Patrick F Riley, Oriol Vinyals, and George E Dahl. Neural message passing for quantum chemistry. In Proceedings of the 34th International Conference on Machine Learning, 2017. ",
+        "bbox": [
+            173,
+            268,
+            823,
+            296
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Will Hamilton, Zhitao Ying, and Jure Leskovec. Inductive representation learning on large graphs. In Advances in Neural Information Processing Systems, 2017. ",
+        "bbox": [
+            173,
+            305,
+            823,
+            333
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Identity mappings in deep residual networks. In European conference on computer vision, 2016. ",
+        "bbox": [
+            174,
+            342,
+            825,
+            369
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. arXiv preprint arXiv:1502.03167, 2015. ",
+        "bbox": [
+            173,
+            377,
+            823,
+            405
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sergey Ivanov and Evgeny Burnaev. Anonymous walk embeddings. arXiv preprint arXiv:1805.11921, 2018. ",
+        "bbox": [
+            173,
+            414,
+            816,
+            429
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            176,
+            438,
+            823,
+            464
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. arXiv preprint arXiv:1609.02907, 2016. ",
+        "bbox": [
+            174,
+            473,
+            823,
+            501
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Johannes Klicpera, Aleksandar Bojchevski, and Stephan Günnemann. Combining neural networks with personalized pagerank for classification on graphs. In International Conference on Learning Representations, 2019. URL https://openreview.net/forum?id $=$ H1gL-2A9Ym. ",
+        "bbox": [
+            174,
+            510,
+            823,
+            550
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yujia Li, Daniel Tarlow, Marc Brockschmidt, and Richard Zemel. Gated graph sequence neural networks. arXiv preprint arXiv:1511.05493, 2015. ",
+        "bbox": [
+            174,
+            559,
+            821,
+            585
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mathias Niepert, Mohamed Ahmed, and Konstantin Kutzkov. Learning convolutional neural networks for graphs. In International conference on machine learning, 2016. ",
+        "bbox": [
+            171,
+            594,
+            823,
+            622
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Franco Scarselli, Marco Gori, Ah Chung Tsoi, Markus Hagenbuchner, and Gabriele Monfardini. The graph neural network model. IEEE Transactions on Neural Networks, 2009. ",
+        "bbox": [
+            173,
+            631,
+            823,
+            659
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Nino Shervashidze, Pascal Schweitzer, Erik Jan van Leeuwen, Kurt Mehlhorn, and Karsten M Borgwardt. Weisfeiler-lehman graph kernels. Journal of Machine Learning Research, 2011. ",
+        "bbox": [
+            173,
+            666,
+            825,
+            695
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Martin Simonovsky and Nikos Komodakis. Dynamic edge-conditioned filters in convolutional neural networks on graphs. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, 2017. ",
+        "bbox": [
+            173,
+            703,
+            825,
+            731
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Felix Wu, Tianyi Zhang, Amauri Holanda de Souza Jr, Christopher Fifty, Tao Yu, and Kilian Q Weinberger. Simplifying graph convolutional networks. arXiv preprint arXiv:1902.07153, 2019. ",
+        "bbox": [
+            171,
+            739,
+            823,
+            767
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Zhang Xinyi and Lihui Chen. Capsule graph neural network. In International Conference on Learning Representations, 2019. URL https://openreview.net/forum?id $\\equiv$ Byl8BnRcYm. ",
+        "bbox": [
+            173,
+            776,
+            825,
+            803
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Keyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. How powerful are graph neural networks? In International Conference on Learning Representations, 2019. URL https://openreview.net/ forum?id $\\equiv$ ryGs6iA5Km. ",
+        "bbox": [
+            174,
+            813,
+            825,
+            852
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Pinar Yanardag and SVN Vishwanathan. Deep graph kernels. In Proceedings of the 21th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, 2015. ",
+        "bbox": [
+            173,
+            861,
+            823,
+            888
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Manzil Zaheer, Satwik Kottur, Siamak Ravanbakhsh, Barnabas Poczos, Ruslan R Salakhutdinov, and Alexander J Smola. Deep sets. In Advances in neural information processing systems, 2017. ",
+        "bbox": [
+            174,
+            897,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Matthew D Zeiler and Rob Fergus. Visualizing and understanding convolutional networks. In European conference on computer vision, 2014. ",
+        "bbox": [
+            173,
+            104,
+            823,
+            131
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Muhan Zhang, Zhicheng Cui, Marion Neumann, and Yixin Chen. An end-to-end deep learning architecture for graph classification. In Thirty-Second AAAI Conference on Artificial Intelligence, 2018a. ",
+        "bbox": [
+            173,
+            140,
+            823,
+            166
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zhen Zhang, Mianzhi Wang, Yijian Xiang, Yan Huang, and Arye Nehorai. Retgk: Graph kernels based on return probabilities of random walks. In Advances in Neural Information Processing Systems, pages 3964–3974, 2018b. ",
+        "bbox": [
+            173,
+            174,
+            826,
+            213
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A COMPARISONS OF DIFFERENT LINEARIZATIONS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            103,
+            604,
+            118
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/147f927b51a592c79a5f62251496fc9b549153e930ffa4907b6aa1db68e7d698.jpg",
+        "table_caption": [
+            "Table 5: Comparisons of different linearizations. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Graph filtering</td><td>Set function</td><td>Efficiency</td><td>Performance</td></tr><tr><td>GLN</td><td>Linear</td><td>Linear</td><td>High</td><td>Low</td></tr><tr><td>GFNlin</td><td>Linear</td><td>Non-linear</td><td>High</td><td>High</td></tr><tr><td>GCN</td><td>Non-linear</td><td>Linear/Non-linear</td><td>Low</td><td>High</td></tr></table>",
+        "bbox": [
+            251,
+            172,
+            746,
+            241
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Table 5 summarizes the comparisons between GCN and its linearized variants. The efficiency and performance are concluded from our experiments on graph classification benchmarks. Noted that a GNN with a linear graph filtering can be seen as a GFN, but the reverse may not be true. General GFN can have non-linear graph filtering, e.g. when the feature extraction function $\\gamma ( G , X )$ is not a linear map of $X$ . Thus we use $\\mathrm { G F N } ^ { l i n }$ in Table 5 to denote such subtle difference. ",
+        "bbox": [
+            173,
+            265,
+            825,
+            335
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "B PROOFS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            357,
+            276,
+            373
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Here we provide the proof for Proposition 1. ",
+        "bbox": [
+            176,
+            390,
+            465,
+            405
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Proof. According to claim 1 and definition 3, a $\\mathrm { G N N } ( G , X )$ with a linear graph filtering part, denoted by $\\mathrm { G N N } ^ { l i n } ( G , X )$ , can be written as follows. ",
+        "bbox": [
+            173,
+            426,
+            825,
+            457
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4b6f730824b1db928960bcae93bcead30e524c8a4b7d2cc52597748e75724e81.jpg",
+        "text": "$$\n\\mathbf { G } \\mathbf { N } \\mathbf { N } ^ { l i n } ( G , X ) = T \\circ { \\mathcal { F } } _ { G } ( X ) = { \\mathcal { T } } ( \\Gamma ( G , X ) \\theta ) = { \\mathcal { T } } ^ { \\prime } ( \\Gamma ( G , X ) ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            281,
+            465,
+            715,
+            486
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "where $\\pmb \\theta$ is absorbed into the set function $\\tau ^ { \\prime } ( \\cdot )$ . According to GFN’s definition in Eq. 6 and general set function result from Zaheer et al. (2017), we have ",
+        "bbox": [
+            173,
+            492,
+            823,
+            522
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d180c19552b2d45f3d02bb93dfd7b10548be8081a9d19a0cc7d98ea835a3f5d3.jpg",
+        "text": "$$\n\\operatorname { G F N } ( G , X ) = { \\mathcal { T } } ^ { \\prime \\prime } ( X ^ { G } ) = { \\mathcal { T } } ^ { \\prime \\prime } ( \\gamma ( G , X ) ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            356,
+            529,
+            640,
+            547
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "By setting $\\gamma ( G , X ) = \\Gamma ( G , X )$ , we arrive at $\\mathrm { { G N N } } ^ { l i n } ( G , X ) = \\mathrm { { G F N } } ( G , X )$ ",
+        "bbox": [
+            174,
+            556,
+            678,
+            574
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Here we provide the proof for Proposition 2. ",
+        "bbox": [
+            176,
+            594,
+            465,
+            609
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Proof. We show the existence of the mapping $\\tau$ by constructing it as follows. First, we assign a unique ID to each of the node, then we add its ID and its neighbors’ IDs in the end of node features. If there are edges with features, we also treat them as nodes and apply the same above procedure. This procedure results in a set of nodes with features that preserve the same original information (since we can reconstruct the original graph). ",
+        "bbox": [
+            173,
+            630,
+            826,
+            702
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We now show the existence of a set function that can mimic any graph functions operated on $\\mathcal { G }$ , again, by constructing a specific one. Since the set of nodes preserve the whole graph information, the set function can first reconstruct the graph by decoding the node’s feature vectors. At every computation step, the set function find neighbors of each node in the set, and compute the aggregation function in exactly the same way as the graph function would do with the neighbors of a node. This procedure is repeated until the graph function produces its output. ",
+        "bbox": [
+            174,
+            707,
+            825,
+            791
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Hence, the above constructed example proves the existence of $\\mathcal { M }$ and a set function $\\tau$ such that $\\forall G \\in { \\mathcal { G } } _ { X } , { \\mathcal { F } } ( G ) \\approx { \\mathcal { T } } ( { \\mathcal { M } } ( G ) )$ . We also note that the specially constructed examples above are feasible but likely not optimal. A better solution is to have a set function that learns to adaptively leverage the graph structure as well as node attributes. □ ",
+        "bbox": [
+            173,
+            797,
+            825,
+            854
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "C DETAILED STATISTICS OF DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            877,
+            509,
+            892
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Detailed statistics of the biological and social graph datasets are listed in Table 6 and 7, respectively. ",
+        "bbox": [
+            174,
+            909,
+            823,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/2a14f770747523caafd9fc48f4c1218c4961dbccca803a9a580c8b9cee27edb7.jpg",
+        "table_caption": [
+            "Table 6: Data statistics of Biological dataset "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>MUTAG</td><td>NCI1</td><td>PROTEINS</td><td>D&amp;D</td><td>ENZYMES</td></tr><tr><td># graphs</td><td>188</td><td>4110</td><td>1113</td><td>1178</td><td>600</td></tr><tr><td>#classes</td><td>2</td><td>2</td><td>2</td><td>2</td><td>6</td></tr><tr><td># features</td><td>7</td><td>37</td><td>3</td><td>82</td><td>3</td></tr><tr><td>Avg # nodes</td><td>17.93</td><td>29.87</td><td>39.06</td><td>284.32</td><td>32.63</td></tr><tr><td>Avg # edges</td><td>19.79</td><td>32.30</td><td>72.82</td><td>715.66</td><td>62.14</td></tr></table>",
+        "bbox": [
+            267,
+            127,
+            725,
+            223
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/68b031ffae7f80290fed4e3d1e4d9730ccef910e05fb2d7e37b3ecdcee81fea2.jpg",
+        "table_caption": [
+            "Table 7: Data statistics of Social dataset "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>COLLAB</td><td>IMDB-B</td><td>IMDB-M</td><td>RE-M5K</td><td>RE-12K</td></tr><tr><td># graphs</td><td>5000</td><td>1000</td><td>1500</td><td>4999</td><td>11929</td></tr><tr><td>#classes</td><td>3</td><td>2</td><td>3</td><td>5</td><td>11</td></tr><tr><td># features</td><td>1</td><td>1</td><td>1</td><td>1</td><td>1</td></tr><tr><td>Avg # nodes</td><td>74.49</td><td>19.77</td><td>13.00</td><td>508.52</td><td>391.41</td></tr><tr><td>Avg # edges</td><td>2457.78</td><td>96.53</td><td>65.94</td><td>594.87</td><td>456.89</td></tr></table>",
+        "bbox": [
+            264,
+            268,
+            730,
+            364
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "D EXPERIMENTS ON GRAPH CONSTRUCTED FROM IMAGES (MNIST) ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            395,
+            758,
+            411
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "In addition to the common graph benchmarks, we also consider image classification on MNIST where pixels are treated as nodes and eight nearest neighbors in the grid, with an extra self-loop, are used to construct the graph. ",
+        "bbox": [
+            176,
+            429,
+            823,
+            472
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "For MNIST, we train and evaluate on the given train/test split. Additionally, since MNIST benefits more from deeper GCN layers, we parameterize our GCN model using a residual network (He et al., 2016) with multiple GCN blocks, the number of blocks are kept the same for GCN and GFN, and varied according to the size of total receptive field. GFN utilizes the same multi-scale features as in Eq. 5. ",
+        "bbox": [
+            173,
+            478,
+            823,
+            549
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We report the accuracies under different total receptive field sizes (i.e. the number of hops a pixel could condition its computation on). Results in Table 8 show that, in all three different receptive field sizes, GCN with non-linear neighbor aggregation outperforms GFN with linear graph propagated features. This indicates that non-linear graph filtering is essential for performing well in this dataset. Note that our results are not directly comparable to traditional CNN’s, as our GNN does not distinguish the neighbor pixel direction in its parameterization, and a global sum pooling of pixels does not leverage spatial information. For context, when using coordinates as features both GCN and GFN achieve nearly $9 9 \\%$ accuracy. ",
+        "bbox": [
+            174,
+            556,
+            647,
+            708
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/e4292f19bdf30cde88a1fb2760d2a483d2b894c112ba7bf5cc82b01b397f9df1.jpg",
+        "table_caption": [
+            "Table 8: Test accuracies $( \\% )$ on MNIST graphs. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Receptive size</td><td>GCN</td><td>GFN</td></tr><tr><td>3</td><td>91.47</td><td>87.73</td></tr><tr><td>5</td><td>95.16</td><td>91.83</td></tr><tr><td>7</td><td>96.14</td><td>92.68</td></tr></table>",
+        "bbox": [
+            658,
+            612,
+            830,
+            696
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "This test on graphs constructed from image dataset (MNIST), the obser  \nvation that similarly configured GCN outperforms GFN by a large margin, indicates the importance of non-linear graph filtering for this type of graph dataset. ",
+        "bbox": [
+            176,
+            715,
+            825,
+            758
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "E DETAILED PERFORMANCES WITH DIFFERENT FEATURES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            785,
+            671,
+            799
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Table 9 show the performances under different graph features for GNNs and GFNs. It is evident that both model benefit significantly from graph features, especially GFNs. ",
+        "bbox": [
+            174,
+            819,
+            823,
+            848
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "F DETAILED PERFORMANCES WITH DIFFERENT ARCHITECTURE DEPTHS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            876,
+            787,
+            890
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Table 10 shows performance per datasets under different number of layers. ",
+        "bbox": [
+            174,
+            909,
+            663,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/6d23701ae60d7ecf2656cc21575bda0fbf54b900346c485e24d5966d4933bb03.jpg",
+        "table_caption": [
+            "Table 9: Accuracies $( \\% )$ under various augmented features. $A ^ { 1 \\dots 3 } X$ is abbreviated for $A ^ { 1 } X , A ^ { 2 } X , A ^ { 3 } X$ , and default node feature $X$ is always used (if available) but not displayed to reduce clutter. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>Model</td><td>None</td><td>d</td><td>A1x</td><td>A12 X</td><td>A1.x</td><td>d,A¹x</td><td>d,A1,2x</td><td>d,A1..3 x</td></tr><tr><td>MUTAG</td><td>GCN GFN</td><td>83.48 82.21</td><td>87.09 89.31</td><td>83.35 87.59</td><td>83.43 87.17</td><td>85.56 86.62</td><td>87.18 89.42</td><td>87.62 89.28</td><td>88.73 88.26</td></tr><tr><td>NCI1</td><td>GCN GFN</td><td>80.15 70.83</td><td>83.24 75.50</td><td>82.62 80.95</td><td>83.11 82.80</td><td>82.60 83.50</td><td>83.38 81.92</td><td>83.63 82.41</td><td>83.50 82.84</td></tr><tr><td>PROTEINS</td><td>GCN GFN</td><td>74.49 74.93</td><td>76.28 76.63</td><td>74.48 76.01</td><td>75.47 75.74</td><td>76.54 76.64</td><td>77.09 76.37</td><td>76.91 76.46</td><td>77.45 77.09</td></tr><tr><td>DD</td><td>GCN GFN GCN</td><td>79.29 78.70 75.17</td><td>78.78 77.77 67.17</td><td>78.70 77.85 72.00</td><td>77.67 77.43 71.50</td><td>78.18 78.28</td><td>78.35 77.34</td><td>78.79 76.92</td><td>79.12 78.11</td></tr><tr><td>ENZYMES</td><td>GFN GCN</td><td>74.67 39.69</td><td>70.00 82.14</td><td>71.50 76.62</td><td>72.33 76.98</td><td>70.50 70.83 77.22</td><td>69.50 68.50 82.14</td><td>69.33 71.00 82.24</td><td>69.67 69.33 82.20</td></tr><tr><td>COLLAB</td><td>GFN GCN</td><td>31.57 51.00</td><td>80.36 73.00</td><td>76.40 70.30</td><td>77.08 71.10</td><td>77.04 72.20</td><td>81.28 73.50</td><td>81.62 73.80</td><td>81.26 73.70</td></tr><tr><td>IMDB-B IMDB-M</td><td>GFN GCN</td><td>50.00 35.00</td><td>73.30 50.33</td><td>72.30 45.53</td><td>71.30 46.33</td><td>71.70 45.73</td><td>74.40 50.20</td><td>73.20 50.73</td><td>73.90 51.00</td></tr><tr><td>RE-M5K</td><td>GFN GCN GFN</td><td>33.33 28.48</td><td>51.20 56.99</td><td>46.80 54.97</td><td>46.67 57.43</td><td>46.47 56.55</td><td>51.93 56.67</td><td>51.93 56.75</td><td>51.73 57.01</td></tr><tr><td>RE-M12K</td><td>GCN</td><td>20.00 15.93</td><td>54.23 49.28</td><td>51.11 48.58</td><td>55.85 50.11</td><td>56.35 49.71</td><td>56.45 49.73</td><td>57.01 50.03</td><td>56.71 49.92</td></tr><tr><td></td><td>GFN</td><td>17.33</td><td>44.86</td><td>43.61</td><td>48.25</td><td>48.87</td><td>48.31</td><td>49.37</td><td>49.39</td></tr></table>",
+        "bbox": [
+            173,
+            165,
+            833,
+            506
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/4be4bd90461a7e3cce3681b1d81cd97c422a2a208d66c807069ee0359edcac32.jpg",
+        "table_caption": [
+            "Table 10: Accuracies $( \\% )$ under different number of Conv. layers. Flat denotes the collapsed GFN into a linear model (i.e. linearizing the set function). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>Method</td><td>Flat</td><td>1</td><td>2</td><td>3</td><td>4</td><td>5</td></tr><tr><td>MUTAG</td><td>GCN GFN</td><td>= 82.85</td><td>88.32 90.34</td><td>90.89 89.39</td><td>87.65 88.18</td><td>88.31 87.59</td><td>87.68 87.18</td></tr><tr><td>NCI1</td><td>GCN GFN</td><td>- 68.61</td><td>75.62 81.77</td><td>81.41 83.09</td><td>83.04 82.85</td><td>82.94 82.80</td><td>83.31 83.09</td></tr><tr><td>PROTEINS</td><td>GCN GFN</td><td>- 75.65</td><td>76.91 77.71</td><td>76.99 77.09</td><td>77.00 77.17</td><td>76.19 76.28</td><td>75.29 75.92</td></tr><tr><td>DD</td><td>GCN GFN</td><td>- 76.75</td><td>77.34 78.44</td><td>77.93 78.78</td><td>78.95 79.04</td><td>79.46 78.45</td><td>78.77 76.32</td></tr><tr><td>ENZYMES</td><td>GCN GFN</td><td>- 43.83</td><td>67.67 69.67</td><td>69.67 70.50</td><td>67.67 71.67</td><td>66.83 69.83</td><td>66.00 68.17</td></tr><tr><td>COLLAB</td><td>GCN GFN</td><td>- 75.72</td><td>80.36 81.24</td><td>81.86 82.04</td><td>81.40 81.36</td><td>81.90 82.18</td><td>81.78 81.72</td></tr><tr><td>IMDB-B</td><td>GCN GFN</td><td>1 73.10</td><td>72.60 73.50</td><td>72.30 73.30</td><td>73.30 74.00</td><td>73.80 73.90</td><td>73.40 73.60</td></tr><tr><td>IMDB-M</td><td>GCN GFN</td><td>- 50.40</td><td>51.53 51.73</td><td>51.07 52.13</td><td>50.87 51.93</td><td>51.53 51.87</td><td>50.60 51.40</td></tr><tr><td>RE-M5K RE-M12K</td><td>GCN GFN GCN</td><td>- 52.97 -</td><td>54.05 57.45 44.91</td><td>56.49 57.13 48.87</td><td>56.83 57.21 49.45</td><td>56.73 56.61</td><td>56.89 57.03</td></tr></table>",
+        "bbox": [
+            261,
+            571,
+            736,
+            912
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/1ca5eb66dd959a22f90e6811850cf76b4d99132d8192e4c02ec0a324248c94f9.jpg",
+        "image_caption": [
+            "Figure 3: Training and test performance versus training epoch. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            98,
+            813,
+            541
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "G MORE CURVES ON TRAINING / TEST PERFORMANCE VS EPOCH ",
+        "bbox": [
+            174,
+            590,
+            728,
+            606
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Figure 3 shows more training/test curves for both GCN and GFN. The conclusion is consistent with main text that GFN works well not because it is easier to optimize. ",
+        "bbox": [
+            173,
+            619,
+            820,
+            650
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "H COMPARISONS TO RETGK AND GNTK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            669,
+            535,
+            685
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Here we further compare our results to two recent work, namely RetGK (Zhang et al., 2018b) and GNTK (Du et al., 2019). RetGK proposes a family of graph kernels based on return probabilities of random walks, with different instantiations: $\\mathrm { R e t G K } _ { I }$ , $\\mathrm { R e t G K } _ { I I }$ , and $\\mathrm { R e t G K } _ { I I } ( \\mathrm { M C } )$ . In their experiments, node attribute are divided into three types: non-attribute, discrete attributes, and continues attributes, and we compare to their reported results. GNTK leverages the connection between infinitely wide networks and kernels to construct an infinitely wide GNN using graph kernels. We also compare to their reported results. ",
+        "bbox": [
+            173,
+            700,
+            825,
+            797
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "It is worth mentioning that these graph kernel based methods are typically quadratic in the number of graphs and nodes, which makes them hard to scale to large datasets. The proposed GFN has linear complexity and even faster than typical GNNs, which makes our method really scalable to larger datasets. ",
+        "bbox": [
+            174,
+            805,
+            825,
+            861
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "The results on biological and social graphs are shown in Table 11 and 12 respectively. We found that overall, despite the methodology differences, GFN still performs on par with these methods averaged over compared datasets (with performance differences on some datasets but they are mostly within one standard deviation). ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/64c408f6c3a55d31fbdb5f29c775d2601d701587fd754dc0cd91847d31f62c97.jpg",
+        "table_caption": [
+            "Table 11: Test accuracies $( \\% )$ for biological graphs. The best results per dataset and in average are highlighted. - means the results are not available for a particular dataset. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Algorithm</td><td>MUTAG</td><td>NCI1</td><td>PROTEINS</td><td>D&amp;D</td><td>ENZYMES</td><td>Average</td></tr><tr><td>RetGK1(Dis)</td><td>90.3±1.1</td><td>84.5±0.2</td><td>75.8±0.6</td><td>81.6±0.3</td><td>60.4±0.8</td><td>78.52</td></tr><tr><td>RetGK1 (Dis)</td><td>90.1±1.0</td><td>83.5±0.2</td><td>75.2±0.3</td><td>81.0±0.5</td><td>59.1±1.1</td><td>77.78</td></tr><tr><td>RetGK1(Con)</td><td></td><td></td><td>76.2±0.5</td><td></td><td>70.0±0.9</td><td>-</td></tr><tr><td>RetGK1r(Con)</td><td></td><td></td><td>75.9±0.4</td><td></td><td>70.7±0.9</td><td></td></tr><tr><td>RetGK1(Con&amp;Dis)</td><td></td><td></td><td>78.0±0.3</td><td></td><td>72.2±0.8</td><td>=</td></tr><tr><td>RetGK1(Con&amp;Dis)</td><td></td><td></td><td>77.3±0.5</td><td></td><td>70.6±0.7</td><td></td></tr><tr><td>GNTK</td><td>90.00±8.5</td><td>84.2±1.5</td><td>75.6±4.2</td><td></td><td>-</td><td>-</td></tr><tr><td>GCN</td><td>87.20±5.11</td><td>83.65±1.69</td><td>75.65±3.24</td><td>79.12±3.07</td><td>66.50±6.91</td><td>78.42</td></tr><tr><td>GLN</td><td>82.85±12.15</td><td>68.61±2.31</td><td>75.65±4.43</td><td>76.75±5.00</td><td>43.83±5.16</td><td>69.54</td></tr><tr><td>GFN</td><td>90.84±7.22</td><td>82.77±1.49</td><td>76.46±4.06</td><td>78.78±3.49</td><td>70.17±5.58</td><td>79.80</td></tr><tr><td>GFN-light</td><td>89.89±7.14</td><td>81.43±1.65</td><td>77.44±3.77</td><td>78.62±5.43</td><td>69.50±7.37</td><td>79.38</td></tr></table>",
+        "bbox": [
+            173,
+            140,
+            843,
+            319
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/219d04f2e83e64e58ac83ea94a4c75a7473833442673d13fa0ec7f7bde3e3d4c.jpg",
+        "table_caption": [
+            "Table 12: Test accuracies $( \\% )$ for social graphs. The best results per dataset and in average are highlighted. - means the results are not available for a particular dataset. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Algorithm</td><td>COLLAB</td><td>IMDB-B</td><td>IMDB-M</td><td>RE-M5K</td><td>RE-M12K</td><td>Average</td></tr><tr><td>RetGK1(Non)</td><td>81.0±0.3</td><td>71.9±1.0</td><td>47.7±0.3</td><td>56.1±0.5</td><td>48.7±0.2</td><td>61.08</td></tr><tr><td>RetGK1 (Non)</td><td>80.6±0.3</td><td>72.3±0.6</td><td>48.7±0.6</td><td>55.3±0.3</td><td>47.1±0.3</td><td>60.8</td></tr><tr><td>RetGK1 (MC)(Non)</td><td>73.6±0.3</td><td>71.0±0.6</td><td>46.7±0.6</td><td>54.2±0.3</td><td>45.9±0.2</td><td>58.28</td></tr><tr><td>GNTK</td><td>83.6±1.0</td><td>76.9±3.6</td><td>52.8±4.6</td><td>1</td><td>1</td><td>1</td></tr><tr><td>GCN</td><td>81.72±1.64</td><td>73.30±5.29</td><td>51.20±5.13</td><td>56.81±2.37</td><td>49.31±1.44</td><td>62.47</td></tr><tr><td>GLN</td><td>75.72±2.51</td><td>73.10±3.18</td><td>50.40±5.61</td><td>52.97±2.58</td><td>39.84±0.95</td><td>58.41</td></tr><tr><td>GFN</td><td>81.50±2.42</td><td>73.00±4.35</td><td>51.80±5.16</td><td>57.59±2.40</td><td>49.43±1.36</td><td>62.66</td></tr><tr><td>GFN-light</td><td>81.34±1.73</td><td>73.00±4.29</td><td>51.20±5.71</td><td>57.11±1.46</td><td>49.75±1.19</td><td>62.48</td></tr></table>",
+        "bbox": [
+            173,
+            373,
+            838,
+            515
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "I VARYING DATASET SIZE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            540,
+            401,
+            556
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "To test the impact of dataset size, we take the largest graph dataset, RE-M12K, which has 11929 graphs. And we then construct nine new datasets by randomly sampling the original dataset with different ratios, ranging from $10 \\%$ to $100 \\%$ of all graphs. We compute both training and test accuracies over 10 fold cross-validation for both our GFN and GCN. For each dataset size (10 fold cross validation), we consider two ways to extract performance: (1) selecting best epoch averaged over 10 fold cross validation, or (2) selecting the last epoch (i.e. the 100-th epoch). ",
+        "bbox": [
+            173,
+            570,
+            825,
+            655
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Figure 4 shows the results. We can see that as data size increases, 1) it is harder for both models to overfit (training acccuracy decreases), but it seems GCN still overfits more if trained longer (to the last epoch); 2) at the best epoch, both models performance almost identical, without significant gaps between them. ",
+        "bbox": [
+            174,
+            661,
+            825,
+            718
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "J GRAPH VISUALIZATIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            738,
+            410,
+            753
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Figure 5, 6, 8, and 7 show the random and mis-classified samples for MUTAG, PROTEINS, IMDB-B, and IMDB-M, respectively. In general, it is difficult to find the patterns of each class by visually examining the graphs. And the mis-classified patterns are not visually distinguishable, except for IMDB-B/IMDB-M datasets where there are some graphs seem ambiguous. ",
+        "bbox": [
+            173,
+            768,
+            826,
+            825
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/004f92e13773c29d662684c7adb3124beff9553d403874426300f87b5c132e77.jpg",
+        "image_caption": [
+            "Figure 4: Performances under varied dataset size. As dataset sizes increases, it becomes harder to overfit (especially for GFN), but GFN still performs as well as, if not better, than GCN. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            230,
+            99,
+            767,
+            279
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/7925f7791a8c6ed7ddc6576e03e08de977e13ec0851d8da70ad9475e5fb9a471.jpg",
+        "image_caption": [
+            "Figure 5: Random and mis-classified samples from MUTAG. Each row represents a (true) class. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            332,
+            816,
+            577
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/5614e63bb5301532abe8646feb986d94f6679cb904032af5331bb867f48afc86.jpg",
+        "image_caption": [
+            "Figure 6: Random and mis-classified samples from PROTEINS. Each row represents a (true) class. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            616,
+            816,
+            861
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/6b92a833cff3ad64a7c7c9da5abab4cfa7bc4f7a82022f9a1978a99ceb6b8c4b.jpg",
+        "image_caption": [
+            "Figure 7: Random and mis-classified samples from IMDB-B. Each row represents a (true) class. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            145,
+            815,
+            390
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/5d0f2e2376268631bd24474c868cd9bff3bdb9b39a7875aca0710ad48c25cf64.jpg",
+        "image_caption": [
+            "Figure 8: Random and mis-classified samples from IMDB-M. Each row represents a (true) class. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            510,
+            816,
+            853
+        ],
+        "page_idx": 16
+    }
+]

parse/train/Bkab5dqxe/Bkab5dqxe.md

@@ -0,0 +1,220 @@
+# A COMPOSITIONAL OBJECT-BASED APPROACH TO LEARNING PHYSICAL DYNAMICS
+
+Michael B. Chang\*, Tomer Ullman\*\*, Antonio Torralba\*, and Joshua B. Tenenbaum\*\* \*Department of Electrical Engineering and Computer Science, MIT \*Department of Brain and Cognitive Sciences, MIT {mbchang,tomeru,torralba,jbt}@mit.edu
+
+# ABSTRACT
+
+We present the Neural Physics Engine (NPE), a framework for learning simulators of intuitive physics that naturally generalize across variable object count and different scene configurations. We propose a factorization of a physical scene into composable object-based representations and a neural network architecture whose compositional structure factorizes object dynamics into pairwise interactions. Like a symbolic physics engine, the NPE is endowed with generic notions of objects and their interactions; realized as a neural network, it can be trained via stochastic gradient descent to adapt to specific object properties and dynamics of different worlds. We evaluate the efficacy of our approach on simple rigid body dynamics in two-dimensional worlds. By comparing to less structured architectures, we show that the NPE’s compositional representation of the structure in physical interactions improves its ability to predict movement, generalize across variable object count and different scene configurations, and infer latent properties of objects such as mass.
+
+# 1 INTRODUCTION
+
+Endowing an agent with a program for physical reasoning constrains the agent’s representation of the environment by establishing a prior on the environment’s physics. The agent can leverage these constraints to rapidly learn new tasks, to flexibly adapt to changes in inputs and goals, and to naturally generalize reasoning to novel scenes (Lake et al., 2016).
+
+For example, a foundational sense of intuitive physics is a prior that guides humans to decompose a scene into objects and carry expectations of object boundaries and motion across different scenarios (Spelke, 1990). Humans perceive balls on a billiard table not as meaningless patches of color but rather as impermeable objects. They expect balls moving toward each other to bounce a certain way after a collision rather than pass through each other, crumble into pieces, or disperse into smoke. Replace one billiard ball with a bowling ball and expectations for ball-to-ball interactions will differ, but the underlying sense of inertia and collisions remain. Arrange immovable wooden obstacles on the table and expectations for how a ball’s surface interacts with wood remain constant regardless of how the obstacles are arranged. The ability to plan trajectories in this space without having to relearn physics from scratch each time, regardless of whether there are three balls or eight balls, whether there are obstacles or not, whether obstacles are arranged in one way or another, whether or not the configuration of objects has been seen before, suggests that humans leverage a prior on physics to reason at a level of abstraction where objects, relations, and events are primitive.
+
+This paper explores the question of building this prior into an agent as a program. We view this program as a simulator that takes input provided by a physical scene and the past states of objects, and outputs the future states and physical properties of relevant objects (Anderson, 1990; Battaglia et al., 2013; Goodman and Tenenbaum, 2016). Our goal is to design a program that naturally generalizes across variable object count and different scene configurations without additional retraining. Our proposed framework, the Neural Physics Engine (NPE), outlines several ingredients useful for realizing these two generalization capabilities. We describe these ingredients in the context of a specific instantiation of the NPE applied to two-dimensional worlds of balls and obstacles.
+
+# 1.1 A HYBRID DESIGN
+
+Two general approaches have emerged in the search for a program that captures common-sense physical reasoning. The top-down approach (Bates et al., 2015; Battaglia et al., 2013; Hamrick et al., 2011; Ullman et al., 2014; Wu et al., 2015) formulates the problem as inference over the parameters of a symbolic physics engine, while the bottom-up approach (Agrawal et al., 2016; Fragkiadaki et al., 2015b; Lerer et al., 2016; Li et al., 2016; Mottaghi et al., 2015; 2016; Sutskever et al., 2009) learns to directly map observations to motion prediction or physical judgments. A program under the top-down approach can generalize across any scenario supported by the entities and operators in its description language. However, it may be brittle under scenarios not supported by its description language, and adapting to these new scenarios requires modifying the code or generating new code for the physics engine itself. In contrast, gradient-based bottom-up approaches can apply the same model architecture and learning algorithm to specific scenarios without requiring the physical dynamics of the scenario to be pre-specified. This often comes at the cost of reduced generality: transferring knowledge to new scenes may require extensive retraining, even in cases that seem trivial to human reasoning.
+
+The NPE takes a step toward bridging the gap between expressivity and adaptability by combining the strengths of both approaches. The NPE framework is realized as a differentiable physics simulator that combines rough symbolic structure with gradient-based learning. It exhibits several strong inductive biases that are explicitly present in symbolic physics engines, such as a notion of objects-specific properties and object interactions. Implemented as a neural network, the NPE can also flexibly tailor itself to specific object properties and dynamics of a given world through training. By design, it can extrapolate to a variable number of objects and different scene configurations with only spatially and temporally local computation.
+
+# 1.2 INGREDIENTS USEFUL FOR GENERALIZATION
+
+Our framework proposes four key ingredients useful for generalization across variable object count and different scene configurations without additional retraining. The first ingredient is the view of objects as primitives of physical reasoning. The second is a mechanism for selecting context objects given a particular object. Together, these ingredients reflect two natural assumptions about a physical environment: There exist objects and these objects interact in a factorized manner.
+
+The third and fourth ingredients are factorization and compositionality, which are both applied on two levels: the scene and the network architecture. On the level of the physical scene, the NPE factorizes the scene into object-based representations, and composes smaller building blocks to form larger objects. This method of representation adapts to scene configurations of variable complexity and shape. On the level of the network architecture, the NPE explicitly reflects a causal structure in object interactions by factorizing object dynamics into pairwise interactions. The NPE models the future state of a single object as a function composition of the pairwise interactions between itself and other context objects in the scene. This structure serves to guide learning towards objectbased reasoning and is designed for physical knowledge to transfer across variable number objects anywhere in the scene.
+
+# 1.3 A STEP TOWARDS EMULATING A GENERAL-PURPOSE PHYSICS ENGINE
+
+While previous bottom-up approaches (Sec. 4) have coupled learning vision and learning physical dynamics, we take a different approach for two reasons. First, we see that disentangling the visual properties of an object from its physical dynamics is a step toward achieving the generality of a physics engine. Both vision and dynamics are necessary, but we believe that keeping these functionalities separate is important for common-sense generalization that is robust to cases where the visual appearance changes but the dynamics remain the same. Second, we are optimistic that those two components indeed can be decoupled, that a vision model can map visual input to an intermediate state space, and a dynamics model can evolve objects in that state space through time. For example, there is work in object detection and localization (e.g. Eslami et al. 2016) for extracting position and velocity, as well as work for extracting latent object properties (Wu et al., 2015; 2016). Therefore this paper focuses on learning dynamics in that state space, taking a small step toward emulating a general-purpose physics engine, with the eventual goal of building a system that exhibits the compositionality, modularity, and generality of a physics engine whose internal components can be learned through observation.
+
+![](images/dd6dea5ce4b76d95b0f2f6572777eb2f6e98dab30ac9224461e1400cf71a5ad9.jpg)  
+Figure 1: Physics Programs: We consider the space of physics programs over object-based representations under physical laws that are Markovian and translation-invariant. We consider each object in turn and predict its future state conditioned on the past states of itself and its context objects.
+
+In Sec. 2 we present a specific instantiation of the NPE that uses a neighborhood mask to select context objects. In Sec. 3 we apply that instantiation to investigate variations on two-dimensional worlds of balls and obstacles from the matter-js physics engine (Brummitt, 2014) as a testbed for exploring the NPE’s capabilities to model simple rigid-body dynamics. While these worlds are generated from a simplified physics engine, we believe that learning to model such simple physics under the NPE’s framework is a first and necessary step towards emulating the full capacity of a general physics engine, while maintaining a differentiability that can allow it to eventually learn complex real-world physical phenomena that would be challenging to engineer into conventional physics engines. This paper establishes that important step.
+
+# 2 APPROACH
+
+# 2.1 NEURAL PHYSICS ENGINE
+
+We consider in detail a specific instantiation of the NPE that uses a neighborhood mask to select context objects. This section discusses each of the four ingredients of the NPE framework, that, when combined, comprise a neural network-based physics simulator that learns from observation.
+
+Object-Based Representations We make two observations (Fig. 1) in our factorization of the scene. The first regards spatially local computation. Because physics does not change across inertial frames, it suffices to separately predict the future state of each object conditioned on the past states of itself and the other objects in its neighborhood, similar to Fragkiadaki et al. (2015b). Sec. 3.5 shows that when large structures are represented as a composition of smaller objects, a spatially local attention window helps achieve invariance to scene configuration. The second observation regards temporally local computation. Because physics is Markovian, this prediction need only be for the immediate next timestep, which we show in Sec. 3 is enough to predict physics effectively over long timescales. Given these two observations, it is natural to choose an object-based state representation. A state vector comprises extrinsic properties (position, velocity, orientation, angular velocity), intrinsic properties (mass, object type, object size), and global properties (gravitational, frictional, and pairwise forces) at a given time instance.
+
+Pairwise Factorization Letting a particular object be the focus object $f$ and all other objects in the scene be context objects $c$ , the NPE models the focus object’s velocity $v _ { f } ^ { [ t + 1 ] }$ as a composition of the pairwise interactions between itself and other neighboring context objects in the scene during time $t \mathrm { ~ - ~ } 1$ and $t$ . This input is represented as pairs of object state vectors $\left\{ \left( o _ { f } , o _ { c _ { 1 } } \right) ^ { \left[ t - 1 , t \right] } , \left( o _ { f } , o _ { c _ { 2 } } \right) ^ { \left[ t - 1 , t \right] } , \ldots \right\}$ . As shown in Fig. 2b, the NPE composes an encoder function and a decoder function. The encoder function $f _ { e n c }$ summarizes the interaction of a single object pair. The sum of encodings of all pairs is then concatenated with the focus object’s past state as input to the decoder function. The focus object is a necessary input to the decoder because if there are no neighboring context objects, the summed encoder output would be zero. The decoder function then predicts the focus object’s velocity $v _ { f } ^ { [ t + 1 ] }$ . In practice, the NPE predicts the change $\Delta v$ between $t$ and $t + 1$ to compute $v ^ { [ t + 1 ] } = v ^ { [ t ] } + \Delta v$ , and updates position using the velocity as a first-order approximation1. We predict velocity rather than position to help avoid memorizing the environment; training the network to predict position conditions the network on the worlds in the training domain, making it more difficult to transfer knowledge across environments. We do not include acceleration in the state representation because position and velocity fully parametrize an object’s state. Thus acceleration (e.g. collisions) can be learned by observing velocity for two consecutive timesteps, hence our choice for two input timesteps. We explored longer input durations as well and found no additional benefit.
+
+Context Selection Each $\left( o _ { f } , o _ { c } \right)$ pair is selected to be in the set of neighbors of $f$ by the neighborhood masking function $\lfloor \bar { \lceil } \rceil | p _ { c } - p _ { f } ) | | < N ( o _ { f } ) \rfloor$ , which takes value 1 if the Euclidean distance between the positions $p _ { f }$ and $p _ { c }$ of the focus and context object respectively at time $t$ is less the neighborhood threshold $\dot { \boldsymbol { N } } ( \boldsymbol { o } _ { f } )$ . Many physics engines use a collision detection scheme with two phases. Broad phase is used for computational efficiency and uses a neighborhood threshold to select objects that might, but not necessarily will, collide an object. Narrow phase performs the actual collision detection on that smaller subset of objects and also resolves the collisions for the objects that do collide. Analogously, our neighborhood mask implements broad phase, and the NPE implements narrow phase. The mask only constrains the search space of context objects, and the network figures out how to detect and resolve collisions. This mask is a specific case of a more general attention mechanism to select contextual elements of a scene.
+
+Function Composition Symbolic physics engines evolve objects through time based on dynamics that dictate their independent behavior (e.g. inertia) and their behavior with other objects (e.g. collisions). Notably, in a particular object’s reference frame, the forces it feels from other objects are additive. The NPE architecture incorporates several inductive biases that reflect this recipe. The composition of $f _ { e n c }$ and $f _ { d e c }$ induce a causal structure on the pairs of objects. We provide a loose interpretation of the encoder output $e _ { c , f }$ as the effect of object $c$ on object $f$ , and require that these effects are additive as forces are. This design allows the NPE to scale naturally to different numbers of neighboring context objects. These inductive biases have the effect of strongly constraining the space of possible simulators that the NPE can learn, focusing on compositional programs that reflect pairwise causal structure in object interactions.
+
+# 2.2 BASELINES
+
+The purpose of contrasting the NPE with the following two baselines is to illustrate the benefit of pairwise factorization and function composition, which are the key architectural features of the NPE. As the architectures for both baselines have been shown to work well in similar tasks, it is not immediately clear whether the NPE’s assumptions are useful or necessary, so these are good baselines for comparison. Viewed in another way, comparing with these baselines is a lesion study on the NPE because each baseline lacks an aspect of the NPE structure.
+
+No-Pairwise The No-Pairwise (NP) baseline is summarized by Fig. 2c. It is very similar to the NPE but does not compute pairwise interactions; otherwise its encoder and decoder are the same as the NPE’s. Therefore the NP most directly highlights the value of the NPE’s pairwise factorization. The NP is also a Markovian variant of the Social LSTM (Alahi et al., 2016); it sums the encodings of context objects after encoding each object independently, similar to the Social LSTM’s “social pooling.” Information for modeling how objects interact would only be present after the encoding step. A possible mechanism for predicting dynamics with the NP is if the encoder’s object encoding consists of an abstract object representation and a force field created by that object. Therefore the decoder could apply the sum of the force fields of all context objects to the focus object’s abstract object representation to predict the focus object’s velocity. As Alahi et al. (2016) has demonstrated the Social LSTM’s performance in modeling human trajectories, it would be interesting to see how the same architectural assumptions perform for the physics of moving objects.
+
+![](images/51572477e5f832e557281e245813f144ff74dcfd13d1891321980c98c31884b5.jpg)  
+Figure 2: Scenario and Models: This figure compares the NPE, the NP and the LSTM architectures in predicting the velocity of object 3 for an example scenario [a] of two heavy balls (cyan) and two light balls (yellow-green). Objects 2 and 4 are in object 3’s neighborhood, so object 1 is ignored. [b]: The NPE encoder consists of a pairwise layer (yellow) and a feedforward network (red) and its decoder (blue) is also a feedforward network. The input to the decoder is the concatenation of the summed pairwise encodings and the input state of object 3. [c]: The NP encoder is the same as the NPE encoder, but without the pairwise layer. The NP decoder is the same as the NPE decoder. The input to the decoder is the concatenation of the summed context encodings and the encoding of object 3. [d]: We shuffle the context objects inputted into the LSTM and use a binary flag to indicate whether an object is a context or focus object.
+
+LSTM Long Short-Term Memory (LSTM) networks (Hochreiter and Schmidhuber, 1997) have been shown to sequentially attend to objects (Eslami et al., 2016), so it is interesting to test whether a LSTM is well-suited for modeling object interactions, when the object states are explicitly given as input. From a cognitive science viewpoint, an LSTM can be interpreted as a serial mechanism in object tracking (Pylyshyn and Annan, 2006). Our LSTM architecture (Fig. 2d) accepts the state of each context object until the last step, at which it takes in the focus object’s state and predicts its velocity. Because the LSTM moves through the object space sequentially, its lack of factorized compositional structure highlights the value of the NPE’s function composition of the independent interactions between an object and its neighbors. Our notion of compositionality treats each object and pairwise interaction as independently encapsulated in a separate computational entity that can be reused and rearranged; the NPE encoder is a function that is applied to each $\left( o _ { f } , o _ { c } \right)$ pair. This function encapsulates this computation and can be repeatedly applied to all neighboring context objects equally, such that the NPE composes this repeated encoding function with the decoder function to predict velocity. The LSTM does not exhibit this notion of compositionality because it is not designed to take advantage of the factorized structure of the scene. Unlike the NPE and NP, the LSTM’s structure does not differentiate between focus and context object, so we add a flag to the state representation to indicate to whether an object is a context or focus object. We shuffle the order of the context objects to account for an ordering bias.
+
+# 3 EXPERIMENTS
+
+Object-based representations (ingredient 1) are necessary for the other three ingredients, and having explained the motivation for object-based representations in Sec. 1.3 and Sec. 2.1, we now analyze the other three ingredients in the context of several experiments. In the prediction task (Sec. 3.1), we first test if the NPE is even capable of predicting physics when the number of objects is held constant. In the generalization task (Sec. 3.2), we test the NPE’s capability to generalize across variable object count. In the inference task (Sec. 3.3), we test if the NPE can be inverted to infer mass in both the prediction and generalization settings. In these experiments, we compare against the NPE-NN, a modified NPE without the neighborhood mask, to analyze the context selection mechanism (ingredient 2), the NP to analyze factorization (ingredient 3), the LSTM to analyze compositionality (ingredient 4). Sec. 3.4 analyzes the neighborhood mask in depth. We test the NPE’s capability to generalize across different scene configurations in Sec. 3.5.
+
+Using the matter-js physics engine, we evaluate the NPE on worlds of balls and obstacles. These worlds exhibit nonlinear dynamics and support a wide variety of scenarios. Bouncing balls have been of interest in cognitive science to study causality and counterfactual reasoning, as in Gerstenberg et al. (2012). We trained on 3-timestep windows in trajectories of 60 timesteps (10 timesteps $\approx 1$ second). For a world of $k$ objects, we generate 50,000 such trajectories. For experiments where we train on multiple worlds together, we shuffle the examples across all training worlds and train without a curriculum schedule. All worlds have a vertical dimension of 600 pixels and a horizontal dimension of 800 pixels, and we constrain the maximum velocity of an object to be 60 pixels/second. We normalize positions to $[ 0 , 1 ]$ by dividing by the horizontal dimension, and we normalize velocities to $[ - 1 , 1 ]$ by dividing by the maximum velocity.
+
+Like those of Battaglia et al. (2016) the NPE predictions can be effective over long timescales even when the NPE is only trained to predict the immediate next time step. Randomly selected simulation videos can be found at $\mathtt { h t t p s : / / q o o . q l / B W Y u O F }$ . Plots show results over three independent runs averaged over held-out test data with different random seeds. As shown in the graphs in Fig. 3 (top two rows) and Fig. 5, both the NP and LSTM’s predicted trajectories diverge from the ground truth, but for different reasons, which the videos illuminate. While the NP and LSTM fail to predict plausible physical movement entirely, the NPE’s predictions initially adhere closely to the ground truth, then slowly diverge due to the accumulation of subtle errors, just as the human perceptual system also accumulates errors (Smith and Vul, 2013). However, the NPE preserves the general intuitive physical dynamics that may roughly be consistent with people’s intuitive expectations.
+
+# 3.1 PREDICTION TASK
+
+We consider simple worlds of four balls of uniform mass (Fig. 3a). To measure performance in simulation, we visualize the cosine similarity between the predicted velocity and the ground truth velocity as well as the relative error in magnitude between the predicted velocity and the ground truth velocity over 50 timesteps of simulation. The models take timesteps 1 and 2 as initial input, and then use previous predictions as input to future predictions. To measure progress through training, we also display the Mean Squared Error (MSE) on the normalized velocity.
+
+# 3.2 GENERALIZATION TASK
+
+We test whether learned knowledge of these simple physics concepts can be transferred and extrapolated to worlds with a number of objects previously unseen (Fig. 3b). The unseen worlds (6, 7, 8 balls) in the test data are combinatorially more complex and varied than the observed worlds (3, 4, 5 balls) in the training data. All objects have equal mass. During simulation, the NPE’s predictions are more consistent, whereas the NP and LSTM’s prediction begin to diverge wildly towards the end of 50 timesteps of simulation (Fig. 3b, middle row). The NPE consistently outperforms the baselines by 0.5 to 1 order of magnitude in velocity prediction (Fig. 3b, bottom row).
+
+# 3.3 INFERENCE TASK
+
+We now show that the NPE can infer latent properties such as mass. This proposal is motivated by the experiments in Battaglia et al. (2013), which uses a probabilistic physics simulator to infer various properties of a scene configuration. Whereas the physical rules of their simulator were manually pre-specified, the NPE learns these rules from observation. We train on the same worlds used in both the prediction and generalization tasks, but we uniformly sampled the mass for each ball from the log-spaced set $\{ 1 , 5 , 2 5 \}$ . We chose to use discrete-valued masses to simplify our qualitative understanding of the model’s capacity to infer. For future work we would like to investigate continuously valued masses and evaluate with binary comparisons (e.g. ”Which is heavier?”).
+
+As summarized by Fig. 3c and Fig. 4a, we select scenarios exhibiting collisions with the focus object, fix the masses of all other objects, and score the NPE’s prediction under all possible mass hypotheses for the focus object. The prediction is scored against the ground-truth under the same MSE loss used in training. The hypothesis whose prediction yields the lowest error is the NPE’s maximum likelihood estimate of the focus object’s mass. Outperforming all baselines, the NPE achieves about $90 \%$ accuracy, meaning it has $90 \%$ probability of inferring the correct mass.
+
+![](images/6093b84d8d2ee4c6482a60670345ddc1b48ae0f3a86357390c4354ec123cc435.jpg)  
+Figure 3: Quantitative evaluation (balls): [a,b]: Prediction and generalization tasks. Top two rows: The cosine similarity and the relative error in magnitude. Bottom row: The MSE of velocity on the test set over the course of training. Because these worlds are chaotic systems, it is not surprising that all predictions diverge from the ground truth with time, but NPE consistently outperforms the other two baselines on all fronts, especially when testing on 6, 7, and 8 objects in the generalization task. The NPE’s performance continues to improve with training while the NPE-NN (an NPE without a neighborhood mask, see Sec. 3.4), NP and LSTM quickly plateau. We hypothesize that the NPE’s structured factorization of the state space guides it from wasting time exploring suboptimal programs. [c]: The NPE’s accuracy is significantly greater than the baseline models’ in mass inference. Notably, the NPE achieves similar inference performance whether in the prediction or generalization settings, further showcasing its strong generalization capabilities. The LSTM performs poorest, reaching just above random guessing ( $3 3 \%$ accuracy). [d]: We analyze the effectiveness of different neighborhood thresholds for the NPE on the constant-mass prediction task. The neighborhood threshold is quite robust from 3 to 5 ball radii.
+
+The NPE predicts outputs given inputs and infers inputs given outputs. Though we adopted a particular parametrization of an object, the NPE is not limited to the semantic meaning of the elements of its input, so we expect other latent object properties can be inferred this way. Because the NPE is differentiable, we expect that it can also infer object properties by backpropagating prediction error to its a randomly sampled input. This would be useful for inferring non-categorical values, such as positions of “invisible” objects, whose effects are felt but whose positions are unknown.
+
+# 3.4 NEIGHBORHOOD MASK
+
+In Fig. 3d we vary the NPE’s neighborhood threshold $N ( o _ { f } )$ and evaluate performance on the constant-mass prediction task. $N ( o _ { f } )$ is in units of ball radii, so $N ( o _ { f } ) = 2$ means that a context object is only detected if it is exactly touching the focus object. Because ball radii are 60 pixels and the maximum velocity is 60 pixels per timestep, the maximum distance two balls can initially be before touching at the next timestep is 4 ball radii. Given that velocities were sampled uniformly, it makes sense that the NPE performs well in and is robust2 to the range $N ( o _ { f } ) \in \left[ 3 , 5 \right]$ , but performance drops off with smaller and larger $N ( o _ { f } )$ . It is important to note that different $N ( o _ { f } )$ may work better for different domains and object geometries.
+
+![](images/3383b854b5973a5d0af62bf54985e07788f74a27f6506bbb22d91ba1a8bb1a5c.jpg)  
+Figure 4: Visualizations: The NPE scales to complex dynamics and world configurations while the NP and LSTM cannot. The masses are visualized as: cyan $= 2 5$ , red $= 5$ , yellow-green $= 1$ . [a] Consider the collision in the 7 balls world (circled). In the ground truth, the collision happens between balls 1 and 2, and the NPE correctly predicts this. The NP predicts a slower movement for ball 1, so ball 2 overlaps with ball 3. The LSTM predicts a slower movement and incorrect angle off the world boundary, so ball 2 overlaps with ball 3. [b] At first glance, all models seem to handle collisions well in the $\mathbf { \tilde { \Sigma } } ^ { 6 6 } \mathbf { O } ^ { 5 }$ world (diamond), but when there are internal obstacles (cloud), only the NPE can successfully resolve collisions. This suggests that the NPE pairwise factorization handles object interactions well, letting it generalize to different world configurations, whereas the NP and LSTM have only memorized the geometry of the “O” world.
+
+We include analysis in the prediction and generalization tasks on an NPE without the neighborhood mask, the NPE-NN $\mathrm { N N } = \mathrm { N o }$ Neighborhood). The neighborhood mask gives the NPE about an order of magnitude improvement in velocity prediction loss (Fig. 3a,b: bottom row and Fig. 6). While the NPE loss continues to improve through training, the NPE-NN loss quickly plateaus. It is interesting that the NPE-NN performs no better than both the NP and LSTM in predictive error, but outperforms the LSTM in mass inference. These two observations suggest that computing the interactions the focus object shares with each context object is more effective for inferring a property of the focus object than disregarding these factorized effects. They also suggest that the additional spatial structure from constraining the context space with the neighborhood mask prevents the NPE from naively finding associations with objects that cannot influence the focus object.
+
+In our experiments, the neighborhood mask has the additional practical benefit of reducing computational complexity from $O ( k )$ to $O ( 1 )$ , where $k$ is the number of objects in the scene, because the number of context-focus object pairs the NPE considers is bounded above by the neighborhood mask at a constant number. Though beyond the scope of this work, to extend the functionality of such context selection mechanism to include worlds that contain forces that act from a distance, future instantiations of the NPE may investigate a more general context selection mechanism that can be learned jointly with the other model parameters.
+
+# 3.5 DIFFERENT SCENE CONFIGURATIONS
+
+We demonstrate representing large structures as a composition of smaller objects as building blocks. This is important for testing the NPE’s invariance to scene configuration; the scene configuration should not matter if the underlying physical laws remain the same. These worlds contain 2 balls bouncing around in variations of 4 different wall geometries. “O” and “L” geometries have no internal obstacles and are in the shape of a rectangle and “L” respectively. “U” and “I” have internal obstacles. Obstacles in “U” are linearly attached to the wall like a protrusion, while obstacles in “I”
+
+![](images/2a3b2837e9336194a5a7fca1154ac62174098ee0cdb0f09f3e04e67edc15e834.jpg)  
+Figure 5: Quantitative evalution (walls and obstacles): The compositional state representation simplifies the physical prediction problem to only be over local arrangements of context balls and obstacles, even when the wall geometries are more complex and varied on a macroscopic scale. Therefore, it is not surprising that the models perform consistently across wall geometries. Note that the NPE consistently outperforms the other models, and this gap in performance increases with more varied internal obstacles for the cosine similarity of the velocity angle. This gap is more prominent in “L” and “U” geometries for relative error in magnitude.
+
+have no constraint in position. We randomly vary the position and orientation of the “L” concavity and the “U” protrusion. We randomly sample the positions of the “I” internal obstacles.
+
+We train on conceptually simpler “O” and “L” worlds and test on more complex “U” and “I” worlds. Variations in wall geometries adds to the difficulty of this extrapolation task. At most 12 context objects are present in the focus object’s neighborhood at a time. The “U” geometries have 33 objects in the scene, the most out of all the wall geometries. As shown in Fig. 4b and 5, the NPE is robust to scenes with internal obstacles, even when it has not observed such scenes during training.
+
+# 3.6 ANALYSIS
+
+We explain the NPE’s superior performance in generalization from the perspective of context selection, factorization, and compositionality. By design, all three ingredients transform the testing data distribution to be similar to the training data distribution, such that generalization across variable object count and different scene configurations happens naturally.
+
+Consider generalizing across variable object count. The neighborhood mask selects context objects such that the NPE need only focus on a bounded subset of the objects regardless of the total number of objects. Factorizing the scene into pairwise interactions induces a causal structure between each context object and the focus object, such that no matter the object count, this causal structure remains consistent because the input is merely a set of object pairs. Composing these pairwise interactions together with a summation encourages the encoder output to be additive, such that the decoder receives the appropriate net effect from the context objects, regardless of how many there are.
+
+Consider generalizing across different scene configurations. Our state representation composes larger structures from smaller objects, just as many real-world objects are composed of smaller components. Therefore, even when wall geometries are complex and varied on a macroscopic scale, the input distribution to the NPE remains roughly the same, because the prediction problem still remains only over objects in a local glimpse the entire scene.
+
+# 4 RELATED WORK
+
+Top-down and bottom-up approaches A recent set of top-down approaches investigate probabilistic game physics engines as computational models for physical simulation in humans (Bates et al., 2015; Battaglia et al., 2013; Hamrick et al., 2011; Ullman et al., 2014). However, these models require a full specification of the physical laws and object geometries. Given such a specification, inferring how physical laws compose and apply to a given scenario are their strength, but automatically inferring from visual data what physical laws and object properties are present requires more work in inverse graphics (Chen et al., 2016; Kulkarni et al., 2014; 2015a;b; Whitney et al., 2016) and physics-based visual understanding (Brand, 1997; Wu et al., 2015; 2016). The NPE builds on top of the key structural assumptions of these top-down approaches, but its differentiable architecture opens a possible path for joint training with a vision model that can automatically adapt to the specific physical properties of the scene.
+
+Bottom-up approaches attempt to bypass the intermediate step of finding physics representations and directly map visual observations to physical judgments (Lerer et al., 2016; Li et al., 2016; Mottaghi et al., 2015; 2016) or passive (Lerer et al., 2016; Srivastava et al., 2015; Sutskever et al., 2009) and action-conditioned (Agrawal et al., 2016; Finn et al., 2016; Fragkiadaki et al., 2015b) motion prediction. Because these work historically have not been compositional in nature, they have had limited flexibility to transfer knowledge to conceptually similar worlds where the physics remain the same, but the number of objects or complexity of object configurations varies. Moreover, these approaches above do not infer latent properties as the NPE does.
+
+Other work have taken similar hybrid approaches as the NPE, such as the NeuroAnimator (Grzeszczuk et al., 1998), one of the first work to train a neural network to emulate a physics simulator, and the interaction network (Battaglia et al., 2016), which learns to simulate physics over a graph of objects and their relations.
+
+Sketching The NPE combines a symbolic structure that assumes generic objects and interactions with a differentiability that allows the specific nature of these interactions to be learned from training. This approach of starting with a general sketch of a program and filling in the specifics is inspired by ideas from the program synthesis community (Ellis et al., 2015; Gaunt et al., 2016; Solar-Lezama, 2008). Examples of other work that combine symbolic with neural approaches via sketching include graph-based neural networks (Jain et al., 2016; Li et al., 2015; Scarselli et al., 2009) and transforming autoencoders (Hinton et al., 2011).
+
+Composing functions for reuse Just as the NPE repeatedly applies the same encoder to each object pair, iteratively applies itself to each object in the scene as a focus object, and recursively predicts future timesteps using predictions from previous timesteps, employing function reuse to achieve generalization is also featured in work such as Abelson et al. (1996); Andreas et al. (2016); Lake et al. (2015); Reed and de Freitas (2015); Socher et al. (2011). These work all assemble small subprograms to form larger programs. The NPE also dynamically composes its internal modules (encoder and decoder) based on the number of objects and the arrangement of context objects.
+
+Object-based approaches Fragkiadaki et al. (2015b) and Battaglia et al. (2016) are two notably similar work in the sense that our work and theirs all take an object-based approach to model the bouncing balls environment. Our work was inspired by Fragkiadaki et al. (2015b)’s iterative approach to predicting the motion of each object in turn, conditioned on a context. The key contrast is that their model assumes no relational structure between objects beyond a visual attention window centered around the focus object, whereas ours explicitly processes the interaction between the focus and each context object.
+
+If we compare their simulation videos (Fragkiadaki et al., 2015a) to ours, we see some specific and significant improvements evident in our approach. For example, in their work, the balls appear attracted to each other and to the walls; the balls appear to bounce along the walls even when no attractive force should be present. The balls rarely touch during collisions, but magnetically repel each other when at a short distance. The NPE does not exhibit these behaviors and tends to preserve the intuitive physical dynamics of colliding balls. In addition to these differences, we show strong predictive performance on generalizing to eight balls, five more than the balls in their videos. We also crucially show this performance under stronger generalization conditions, variable mass, and more complex scene configurations.
+
+Recently, Battaglia et al. (2016) independently and in parallel developed an architecture that they call the interaction network for learning to model physical systems. They show how such an architecture can apply to several different kinds of physical systems, including n-body gravitational interactions and a string falling under gravity. Like their work, our model can simulate over many timesteps very effectively when only trained for next-timestep prediction, and can generalize to different world configurations and different numbers of objects.
+
+Compared to the interaction network, a main difference in our architecture is that ours does not take object relations as explicit input, but instead learns the nature of these relations by constraining attention to a neighborhood set of objects. Another difference is in function reuse: we demonstrated that a trained NPE can automatically infer properties of its input such as mass without further retraining. In contrast, they train an additional classifier on top of their model to do inference. Their work also exhibits the four ingredients in our framework, and we view the similarities between their and our work as converging evidence for the utility of object-based representations and compositional model architectures in learning to emulate general-purpose physics engines.
+
+# 5 DISCUSSION
+
+While this paper is not the first to explore learning a physics simulator, here we take the opportunity to highlight the value of this paper’s contributions. We hope these contributions can seed further research that builds on the NPE framework this paper proposes.
+
+We showed that object-based representations, a context selection mechanism, factorization, and compositionality are useful ingredients for learning a physics simulator that generalizes across variable object count and different scene configurations with only spatially and temporally local computation. This generalization is possible because these ingredients transform the testing data distribution to be similar to the training data distribution.
+
+The NPE makes few but strong assumptions about the nature of objects in a physical environment. These assumptions are inductive biases that not only give the NPE enough structure to help constrain it to model physical phenomena in terms of objects but also are general enough for the NPE to learn physical dynamics almost exclusively from observation.
+
+We applied the NPE to simple two-dimensional worlds of bouncing balls ranging in complexity. We showed that NPE achieves low prediction error, extrapolates learned physical knowledge to previously unseen number of objects and world configurations, and can infer latent properties such as mass. We compared against several baselines designed to test the ingredients of the NPE framework and found superior performance when all these ingredients are combined in the NPE. Though we demonstrated the NPE in the balls environment with nonlinear dynamics and complex scene configurations, the state representation and NPE architecture we propose are quite general-purpose because they assume little about the specific dynamics of a scene.
+
+This paper works toward emulating a general purpose physics engine under a framework where visual and physical aspects of a scene are disentangled. Next steps include linking the NPE with perceptual models that extract properties such as position and mass from visual input. Learning to simulate is unsupervised learning of the structure of the environment. When a simulator like the NPE is incorporated into an agent in the context of model-based planning and model-based reinforcement learning, it becomes a prior on the environment that guides learning and reasoning. By combining the expressiveness of physics engines and the adaptability of neural networks in a compositional architecture that supports generalization in fundamental aspects of physical reasoning, the Neural Physics Engine is an important step towards lifting an agent’s ability to think at a level of abstraction where the concept of physics is primitive.
+
+# ACKNOWLEDGMENTS
+
+We thank Tejas Kulkarni for insightful discussions and guidance. We thank Ilker Yildirim, Erin Reynolds, Feras Saad, Andreas Stuhlmuller, Adam Lerer, Chelsea Finn, Jiajun Wu, and the anony- ¨ mous reviewers for valuable feedback. We thank Liam Brummit, Kevin Kwok, and Guillermo Webster for help with matter-js. This work was supported MIT’s SuperUROP and UROP programs, and by the Center for Minds, Brains and Machines under NSF STC award CCF-1231216 and an ONR grant N00014-16-1-2007.
+
+REFERENCES   
+H. Abelson, G. J. Sussman, and J. Sussman. Structure and interpretation of computer programs. Justin Kelly, 1996.   
+P. Agrawal, A. Nair, P. Abbeel, J. Malik, and S. Levine. Learning to poke by poking: Experiential learning of intuitive physics. arXiv preprint arXiv:1606.07419, 2016.   
+A. Alahi, K. Goel, V. Ramanathan, A. Robicquet, L. Fei-Fei, and S. Savarese. Social lstm: Human trajectory prediction in crowded spaces. 2016.   
+J. R. Anderson. Cognitive psychology and its implications . WH Freeman/Times Books/Henry Holt & Co, 1990.   
+J. Andreas, M. Rohrbach, T. Darrell, and D. Klein. Learning to compose neural networks for question answering. In Proceedings of NAACL-HLT, pages 1545–1554, 2016.   
+C. J. Bates, I. Yildirim, J. B. Tenenbaum, and P. W. Battaglia. Humans predict liquid dynamics using probabilistic simulation. 2015.   
+P. Battaglia, R. Pascanu, M. Lai, D. Jimenez Rezende, and K. Koray. Interaction networks for learning about objects, relations and physics. In Advances in Neural Information Processing Systems, 2016.   
+P. W. Battaglia, J. B. Hamrick, and J. B. Tenenbaum. Simulation as an engine of physical scene understanding. Proceedings of the National Academy of Sciences, 110(45):18327–18332, 2013.   
+M. Brand. Physics-based visual understanding. Computer Vision and Image Understanding, 65(2): 192–205, 1997.   
+L. Brummitt. http://brm.io/matter-js, 2014. URL http://brm.io/matter-js.   
+X. Chen, Y. Duan, R. Houthooft, J. Schulman, I. Sutskever, and P. Abbeel. Infogan: Interpretable representation learning by information maximizing generative adversarial nets. In Advances in Neural Information Processing Systems, pages 2172–2180, 2016.   
+R. Collobert, K. Kavukcuoglu, and C. Farabet. Torch7: A matlab-like environment for machine learning. In BigLearn, NIPS Workshop, number EPFL-CONF-192376, 2011.   
+K. Ellis, A. Solar-Lezama, and J. Tenenbaum. Unsupervised learning by program synthesis. In Advances in Neural Information Processing Systems, pages 973–981, 2015.   
+S. Eslami, N. Heess, T. Weber, Y. Tassa, K. Kavukcuoglu, and G. E. Hinton. Attend, infer, repeat: Fast scene understanding with generative models. arXiv preprint arXiv:1603.08575, 2016.   
+C. Finn, I. Goodfellow, and S. Levine. Unsupervised learning for physical interaction through video prediction. arXiv preprint arXiv:1605.07157, 2016.   
+K. Fragkiadaki, P. Agrawal, S. Levine, and J. Malik. Intuitive physics. https://sites. google.com/site/intuitivephysicsnips15/, 2015a. (Accessed on 03/03/2017).   
+K. Fragkiadaki, P. Agrawal, S. Levine, and J. Malik. Learning visual predictive models of physics for playing billiards. arXiv preprint arXiv:1511.07404, 2015b.   
+A. L. Gaunt, M. Brockschmidt, R. Singh, N. Kushman, P. Kohli, J. Taylor, and D. Tarlow. Terpret: A probabilistic programming language for program induction. arXiv preprint arXiv:1608.04428, 2016.   
+T. Gerstenberg, N. Goodman, D. A. Lagnado, and J. B. Tenenbaum. Noisy newtons: Unifying process and dependency accounts of causal attribution. In In proceedings of the 34th. Citeseer, 2012.   
+N. D. Goodman and J. B. Tenenbaum. Probabilistic models of cognition, 2016. URL http: //probmods.org.
+
+R. Grzeszczuk, D. Terzopoulos, and G. Hinton. Neuroanimator: Fast neural network emulation and control of physics-based models. In Proceedings of the 25th annual conference on Computer graphics and interactive techniques, pages 9–20. ACM, 1998.
+
+J. Hamrick, P. Battaglia, and J. B. Tenenbaum. Internal physics models guide probabilistic judgments about object dynamics. 2011.   
+G. E. Hinton, A. Krizhevsky, and S. D. Wang. Transforming auto-encoders. In Artificial Neural Networks and Machine Learning–ICANN 2011, pages 44–51. Springer, 2011.   
+S. Hochreiter and J. Schmidhuber. Long short-term memory. Neural computation, 9(8):1735–1780, 1997.   
+A. Jain, A. R. Zamir, S. Savarese, and A. Saxena. Structural-rnn: Deep learning on spatio-temporal graphs. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 5308–5317, 2016.   
+T. D. Kulkarni, V. K. Mansinghka, P. Kohli, and J. B. Tenenbaum. Inverse graphics with probabilistic cad models. arXiv preprint arXiv:1407.1339, 2014.   
+T. D. Kulkarni, P. Kohli, J. B. Tenenbaum, and V. Mansinghka. Picture: A probabilistic programming language for scene perception. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 4390–4399, 2015a.   
+T. D. Kulkarni, W. F. Whitney, P. Kohli, and J. Tenenbaum. Deep convolutional inverse graphics network. In Advances in Neural Information Processing Systems, pages 2530–2538, 2015b.   
+B. M. Lake, R. Salakhutdinov, and J. B. Tenenbaum. Human-level concept learning through probabilistic program induction. Science, 350(6266):1332–1338, 2015.   
+B. M. Lake, T. D. Ullman, J. B. Tenenbaum, and S. J. Gershman. Building machines that learn and think like people. arXiv preprint arXiv:1604.00289, 2016.   
+N. Leonard, S. Waghmare, and Y. Wang. rnn: Recurrent library for torch. ´ arXiv preprint arXiv:1511.07889, 2015.   
+A. Lerer, S. Gross, R. Fergus, and J. Malik. Learning physical intuition of block towers by example. arXiv preprint arXiv:1603.01312, 2016.   
+W. Li, S. Azimi, A. Leonardis, and M. Fritz. To fall or not to fall: A visual approach to physical stability prediction. arXiv preprint arXiv:1604.00066, 2016.   
+Y. Li, D. Tarlow, M. Brockschmidt, and R. Zemel. Gated graph sequence neural networks. arXiv preprint arXiv:1511.05493, 2015.   
+R. Mottaghi, H. Bagherinezhad, M. Rastegari, and A. Farhadi. Newtonian image understanding: Unfolding the dynamics of objects in static images. arXiv preprint arXiv:1511.04048, 2015.   
+R. Mottaghi, M. Rastegari, A. Gupta, and A. Farhadi. ” what happens if...” learning to predict the effect of forces in images. arXiv preprint arXiv:1603.05600, 2016.   
+Z. W. Pylyshyn and V. Annan. Dynamics of target selection in multiple object tracking (mot). Spatial vision, 19(6):485–504, 2006.   
+S. Reed and N. de Freitas. Neural programmer-interpreters. arXiv preprint arXiv:1511.06279, 2015.   
+F. Scarselli, M. Gori, A. C. Tsoi, M. Hagenbuchner, and G. Monfardini. The graph neural network model. IEEE Transactions on Neural Networks, 20(1):61–80, 2009.   
+K. A. Smith and E. Vul. Sources of uncertainty in intuitive physics. Topics in cognitive science, 5 (1):185–199, 2013.   
+R. Socher, E. H. Huang, J. Pennington, A. Y. Ng, and C. D. Manning. Dynamic pooling and unfolding recursive autoencoders for paraphrase detection. 2011.   
+A. Solar-Lezama. Program synthesis by sketching. ProQuest, 2008.   
+E. S. Spelke. Principles of object perception. Cognitive science, 14(1):29–56, 1990.   
+N. Srivastava, E. Mansimov, and R. Salakhutdinov. Unsupervised learning of video representations using lstms. 2015.   
+I. Sutskever, G. E. Hinton, and G. W. Taylor. The recurrent temporal restricted boltzmann machine. In Advances in Neural Information Processing Systems, pages 1601–1608, 2009.   
+T. Tieleman and G. Hinton. Lecture 6.5—RmsProp: Divide the gradient by a running average of its recent magnitude. COURSERA: Neural Networks for Machine Learning, 2012.   
+T. Ullman, A. Stuhlmuller, and N. Goodman. Learning physics from dynamical scenes. 2014. ¨   
+W. F. Whitney, M. Chang, T. Kulkarni, and J. B. Tenenbaum. Understanding visual concepts with continuation learning. arXiv preprint arXiv:1602.06822, 2016.   
+J. Wu, I. Yildirim, J. J. Lim, B. Freeman, and J. Tenenbaum. Galileo: Perceiving physical object properties by integrating a physics engine with deep learning. In Advances in Neural Information Processing Systems, pages 127–135, 2015.   
+J. Wu, J. J. Lim, H. Zhang, J. B. Tenenbaum, and W. T. Freeman. Physics 101: Learning physical object properties from unlabeled videos. In British Machine Vision Conference, 2016.
+
+# A IMPLEMENTATION
+
+We trained all models using the rmsprop (Tieleman and Hinton, 2012) backpropagation algorithm with a Euclidean loss for 1,200,000 iterations with a learning rate of 0.0003 and a learning rate decay of 0.99 every 2,500 training iterations, beginning at iteration 50,000. We used minibatches of size 50 and used a 70-15-15 split for training, validation, and test data.
+
+All models are implemented using the neural network libraries built by Collobert et al. (2011); Leonard et al. (2015). The NPE encoder consists of a pairwise layer of 25 hidden units and a 5-layer ´ feedforward network of 50 hidden units per layer each with rectified linear activations. Because we use a binary mask to zero out non-neighboring objects, we implement the encoder layers without bias such that non-neighboring objects do not contribute to the encoder activations. The encoding parameters are shared across all object pairs. The decoder is a five-layer network with 50 hidden units per layer and rectified linear activations after all but the last layer. The NP encoder architecture is the same as the NPE encoder, but without the pairwise layer. The NP decoder architecture is the same as the NPE decoder. The LSTM has three layers of 100 hidden units and a linear layer after the last layer. It has rectified linear activations after each layer.
+
+We informally explored several hyperparameters, varying the number of layers from 2 to 5, the hidden dimension from 50 to 100, and learning rates in $\{ 1 \bar { 0 } ^ { - 5 } , 3 \times 1 0 ^ { - 5 } , 1 0 ^ { - \bar { 4 } } , 3 \times 1 0 ^ { - 4 } , 1 0 ^ { - 3 } , 3 \times$ $1 0 ^ { - 3 } \}$ . Though this is far from an exhaustive search, we found that the above hyperparameter settings work well.
+
+# B QUANTITATIVE ANALYSIS
+
+<table><tr><td rowspan=1 colspan=11>Experiments      Train - Test      LSTM             NP             NPE-NN            NPE</td></tr><tr><td rowspan=1 colspan=3>Prediction Task         4-4</td><td rowspan=1 colspan=1>2.177e-03</td><td rowspan=1 colspan=1>2.276e-02</td><td rowspan=1 colspan=1>1.822e-03</td><td rowspan=1 colspan=1>1.923e-02</td><td rowspan=1 colspan=1>2.684e-03</td><td rowspan=1 colspan=1>2.283e-02</td><td rowspan=1 colspan=1>2.469e-04</td><td rowspan=1 colspan=1>4.362e-03</td></tr><tr><td rowspan=1 colspan=3>Prediction Task Variable Mass    4-4</td><td rowspan=1 colspan=1>3.521e-03</td><td rowspan=1 colspan=1>2.725e-02</td><td rowspan=1 colspan=1>2.534e-03</td><td rowspan=1 colspan=1>1.829e-02</td><td rowspan=1 colspan=1>4.278e-03</td><td rowspan=1 colspan=1>2.562e-02</td><td rowspan=1 colspan=1>5.312e-04</td><td rowspan=1 colspan=1>6.379e-03</td></tr><tr><td rowspan=1 colspan=3>345-3</td><td rowspan=1 colspan=1>1.783e-03</td><td rowspan=1 colspan=1>1.872e-02</td><td rowspan=1 colspan=1>5.844e-04</td><td rowspan=1 colspan=1>8.118e-03</td><td rowspan=1 colspan=1>1.667e-03</td><td rowspan=1 colspan=1>1.700e-02</td><td rowspan=1 colspan=1>1.651e-04</td><td rowspan=1 colspan=1>3.523e-03</td></tr><tr><td rowspan=1 colspan=3>345-4</td><td rowspan=1 colspan=1>2.237e-03</td><td rowspan=1 colspan=1>2.336e-02</td><td rowspan=1 colspan=1>1.172e-03</td><td rowspan=1 colspan=1>1.329e-02</td><td rowspan=1 colspan=1>2.554e-03</td><td rowspan=1 colspan=1>2.222e-02</td><td rowspan=1 colspan=1>2.372e-04</td><td rowspan=1 colspan=1>4.508e-03</td></tr><tr><td rowspan=2 colspan=3>345-5Generalization Task345-6</td><td rowspan=1 colspan=1>2.839e-03</td><td rowspan=1 colspan=1>2.909e-02</td><td rowspan=1 colspan=1>1.944e-03</td><td rowspan=1 colspan=1>1.959e-02</td><td rowspan=1 colspan=1>3.543e-03</td><td rowspan=1 colspan=1>2.810e-02</td><td rowspan=1 colspan=1>3.069e-04</td><td rowspan=1 colspan=1>5.514e-03</td></tr><tr><td rowspan=1 colspan=1>3.757e-03</td><td rowspan=1 colspan=1>3.636e-02</td><td rowspan=1 colspan=1>2.897e-03</td><td rowspan=1 colspan=1>2.665e-02</td><td rowspan=1 colspan=1>4.542e-03</td><td rowspan=1 colspan=1>3.381e-02</td><td rowspan=1 colspan=1>4.066e-04</td><td rowspan=1 colspan=1>6.676e-03</td></tr><tr><td rowspan=2 colspan=3>345-7345-8</td><td rowspan=1 colspan=1>5.085e-03</td><td rowspan=1 colspan=1>4.546e-02</td><td rowspan=1 colspan=1>3.894e-03</td><td rowspan=1 colspan=1>3.395e-02</td><td rowspan=1 colspan=1>5.654e-03</td><td rowspan=1 colspan=1>3.944e-02</td><td rowspan=1 colspan=1>4.951e-04</td><td rowspan=1 colspan=1>7.858e-03</td></tr><tr><td rowspan=1 colspan=1>6.943e-03</td><td rowspan=1 colspan=1>5.595e-02</td><td rowspan=1 colspan=1>5.091e-03</td><td rowspan=1 colspan=1>4.182e-02</td><td rowspan=1 colspan=1>6.913e-03</td><td rowspan=1 colspan=1>4.604e-02</td><td rowspan=1 colspan=1>5.992e-04</td><td rowspan=1 colspan=1>9.174e-03</td></tr><tr><td rowspan=1 colspan=3>345-3</td><td rowspan=1 colspan=1>2.663e-03</td><td rowspan=1 colspan=1>2.218e-02</td><td rowspan=1 colspan=1>2.228e-03</td><td rowspan=1 colspan=1>1.638e-02</td><td rowspan=1 colspan=1>2.785e-03</td><td rowspan=1 colspan=1>1.913e-02</td><td rowspan=1 colspan=1>3.546e-04</td><td rowspan=1 colspan=1>4.790e-03</td></tr><tr><td rowspan=1 colspan=3>345-4</td><td rowspan=1 colspan=1>3.588e-03</td><td rowspan=1 colspan=1>2.784e-02</td><td rowspan=1 colspan=1>3.486e-03</td><td rowspan=1 colspan=1>2.375e-02</td><td rowspan=1 colspan=1>4.291e-03</td><td rowspan=1 colspan=1>2.563e-02</td><td rowspan=1 colspan=1>5.393e-04</td><td rowspan=1 colspan=1>6.215e-03</td></tr><tr><td rowspan=2 colspan=3>345-5Generalization Task Variable Mass345-6</td><td rowspan=1 colspan=1>4.719e-03</td><td rowspan=1 colspan=1>3.472e-02</td><td rowspan=1 colspan=1>4.918e-03</td><td rowspan=1 colspan=1>3.164e-02</td><td rowspan=1 colspan=1>5.848e-03</td><td rowspan=1 colspan=1>3.273e-02</td><td rowspan=1 colspan=1>6.983e-04</td><td rowspan=1 colspan=1>7.719e-03</td></tr><tr><td rowspan=1 colspan=1>345-6</td><td rowspan=1 colspan=1>6.389e-03</td><td rowspan=1 colspan=1>4.302e-02</td><td rowspan=1 colspan=1>6.733e-03</td><td rowspan=1 colspan=1>3.982e-02</td><td rowspan=1 colspan=1>7.927e-03</td><td rowspan=1 colspan=1>4.092e-02</td><td rowspan=1 colspan=1>9.414e-04</td><td rowspan=1 colspan=1>9.398e-03</td></tr><tr><td rowspan=1 colspan=2></td><td rowspan=2 colspan=2>345-7345-8</td><td rowspan=1 colspan=1>8.581e-03</td><td rowspan=1 colspan=1>5.276e-02</td><td rowspan=1 colspan=1>8.746e-03</td><td rowspan=1 colspan=1>4.853e-02</td><td rowspan=1 colspan=1>1.012e-02</td><td rowspan=1 colspan=1>4.998e-02</td><td rowspan=1 colspan=1>1.196e-03</td></tr><tr><td></td><td></td><td rowspan=1 colspan=1>1.153e-02</td><td rowspan=1 colspan=1>6.469e-02</td><td rowspan=1 colspan=1>1.086e-02</td><td rowspan=1 colspan=1>5.724e-02</td><td rowspan=1 colspan=1>1.244e-02</td><td rowspan=1 colspan=1>5.967e-02</td><td rowspan=1 colspan=1>1.592e-03</td><td rowspan=1 colspan=1>1.367e-02</td></tr><tr><td rowspan=1 colspan=3>OL-O</td><td rowspan=1 colspan=1>5.967e-03</td><td rowspan=1 colspan=1>5.546e-02</td><td rowspan=1 colspan=1>1.010e-03</td><td rowspan=1 colspan=1>1.358e-02</td><td rowspan=1 colspan=1>N/A</td><td rowspan=1 colspan=1>N/A</td><td rowspan=1 colspan=1>3.338e-04</td><td rowspan=1 colspan=1>5.921e-03</td></tr><tr><td rowspan=2 colspan=3>OL-LDifferent Scene ConfigurationsOL-U</td><td rowspan=1 colspan=1>8.658e-03</td><td rowspan=1 colspan=1>6.995e-02</td><td rowspan=1 colspan=1>2.680e-03</td><td rowspan=1 colspan=1>2.663e-02</td><td rowspan=1 colspan=1>N/A</td><td rowspan=1 colspan=1>N/A</td><td rowspan=1 colspan=1>7.117e-04</td><td rowspan=1 colspan=1>1.019e-02</td></tr><tr><td rowspan=1 colspan=1>1.083e-02</td><td rowspan=1 colspan=1>7.765e-02</td><td rowspan=1 colspan=1>4.152e-03</td><td rowspan=1 colspan=1>3.201e-02</td><td rowspan=1 colspan=1>N/A</td><td rowspan=1 colspan=1>N/A</td><td rowspan=1 colspan=1>8.193e-04</td><td rowspan=1 colspan=1>1.141e-02</td></tr><tr><td rowspan=1 colspan=3>OL--</td><td rowspan=1 colspan=1>1.201e-02</td><td rowspan=1 colspan=1>7.947e-02</td><td rowspan=1 colspan=1>6.206e-03</td><td rowspan=1 colspan=1>3.565e-02</td><td rowspan=1 colspan=1>N/A</td><td rowspan=1 colspan=1>N/A</td><td rowspan=1 colspan=1>1.605e-03</td><td rowspan=1 colspan=1>1.482e-02</td></tr></table>

parse/train/Bkab5dqxe/Bkab5dqxe_content_list.json

@@ -0,0 +1,1047 @@
+[
+    {
+        "type": "text",
+        "text": "A COMPOSITIONAL OBJECT-BASED APPROACH TO LEARNING PHYSICAL DYNAMICS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            823,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Michael B. Chang\\*, Tomer Ullman\\*\\*, Antonio Torralba\\*, and Joshua B. Tenenbaum\\*\\* \\*Department of Electrical Engineering and Computer Science, MIT \\*Department of Brain and Cognitive Sciences, MIT {mbchang,tomeru,torralba,jbt}@mit.edu ",
+        "bbox": [
+            202,
+            174,
+            795,
+            233
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            273,
+            544,
+            290
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We present the Neural Physics Engine (NPE), a framework for learning simulators of intuitive physics that naturally generalize across variable object count and different scene configurations. We propose a factorization of a physical scene into composable object-based representations and a neural network architecture whose compositional structure factorizes object dynamics into pairwise interactions. Like a symbolic physics engine, the NPE is endowed with generic notions of objects and their interactions; realized as a neural network, it can be trained via stochastic gradient descent to adapt to specific object properties and dynamics of different worlds. We evaluate the efficacy of our approach on simple rigid body dynamics in two-dimensional worlds. By comparing to less structured architectures, we show that the NPE’s compositional representation of the structure in physical interactions improves its ability to predict movement, generalize across variable object count and different scene configurations, and infer latent properties of objects such as mass. ",
+        "bbox": [
+            233,
+            308,
+            764,
+            501
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            530,
+            336,
+            545
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Endowing an agent with a program for physical reasoning constrains the agent’s representation of the environment by establishing a prior on the environment’s physics. The agent can leverage these constraints to rapidly learn new tasks, to flexibly adapt to changes in inputs and goals, and to naturally generalize reasoning to novel scenes (Lake et al., 2016). ",
+        "bbox": [
+            174,
+            563,
+            823,
+            617
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "For example, a foundational sense of intuitive physics is a prior that guides humans to decompose a scene into objects and carry expectations of object boundaries and motion across different scenarios (Spelke, 1990). Humans perceive balls on a billiard table not as meaningless patches of color but rather as impermeable objects. They expect balls moving toward each other to bounce a certain way after a collision rather than pass through each other, crumble into pieces, or disperse into smoke. Replace one billiard ball with a bowling ball and expectations for ball-to-ball interactions will differ, but the underlying sense of inertia and collisions remain. Arrange immovable wooden obstacles on the table and expectations for how a ball’s surface interacts with wood remain constant regardless of how the obstacles are arranged. The ability to plan trajectories in this space without having to relearn physics from scratch each time, regardless of whether there are three balls or eight balls, whether there are obstacles or not, whether obstacles are arranged in one way or another, whether or not the configuration of objects has been seen before, suggests that humans leverage a prior on physics to reason at a level of abstraction where objects, relations, and events are primitive. ",
+        "bbox": [
+            174,
+            625,
+            825,
+            804
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "This paper explores the question of building this prior into an agent as a program. We view this program as a simulator that takes input provided by a physical scene and the past states of objects, and outputs the future states and physical properties of relevant objects (Anderson, 1990; Battaglia et al., 2013; Goodman and Tenenbaum, 2016). Our goal is to design a program that naturally generalizes across variable object count and different scene configurations without additional retraining. Our proposed framework, the Neural Physics Engine (NPE), outlines several ingredients useful for realizing these two generalization capabilities. We describe these ingredients in the context of a specific instantiation of the NPE applied to two-dimensional worlds of balls and obstacles. ",
+        "bbox": [
+            174,
+            813,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1.1 A HYBRID DESIGN ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            343,
+            117
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Two general approaches have emerged in the search for a program that captures common-sense physical reasoning. The top-down approach (Bates et al., 2015; Battaglia et al., 2013; Hamrick et al., 2011; Ullman et al., 2014; Wu et al., 2015) formulates the problem as inference over the parameters of a symbolic physics engine, while the bottom-up approach (Agrawal et al., 2016; Fragkiadaki et al., 2015b; Lerer et al., 2016; Li et al., 2016; Mottaghi et al., 2015; 2016; Sutskever et al., 2009) learns to directly map observations to motion prediction or physical judgments. A program under the top-down approach can generalize across any scenario supported by the entities and operators in its description language. However, it may be brittle under scenarios not supported by its description language, and adapting to these new scenarios requires modifying the code or generating new code for the physics engine itself. In contrast, gradient-based bottom-up approaches can apply the same model architecture and learning algorithm to specific scenarios without requiring the physical dynamics of the scenario to be pre-specified. This often comes at the cost of reduced generality: transferring knowledge to new scenes may require extensive retraining, even in cases that seem trivial to human reasoning. ",
+        "bbox": [
+            174,
+            132,
+            825,
+            325
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The NPE takes a step toward bridging the gap between expressivity and adaptability by combining the strengths of both approaches. The NPE framework is realized as a differentiable physics simulator that combines rough symbolic structure with gradient-based learning. It exhibits several strong inductive biases that are explicitly present in symbolic physics engines, such as a notion of objects-specific properties and object interactions. Implemented as a neural network, the NPE can also flexibly tailor itself to specific object properties and dynamics of a given world through training. By design, it can extrapolate to a variable number of objects and different scene configurations with only spatially and temporally local computation. ",
+        "bbox": [
+            174,
+            332,
+            823,
+            444
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1.2 INGREDIENTS USEFUL FOR GENERALIZATION ",
+        "text_level": 1,
+        "bbox": [
+            179,
+            465,
+            524,
+            478
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our framework proposes four key ingredients useful for generalization across variable object count and different scene configurations without additional retraining. The first ingredient is the view of objects as primitives of physical reasoning. The second is a mechanism for selecting context objects given a particular object. Together, these ingredients reflect two natural assumptions about a physical environment: There exist objects and these objects interact in a factorized manner. ",
+        "bbox": [
+            174,
+            492,
+            823,
+            561
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The third and fourth ingredients are factorization and compositionality, which are both applied on two levels: the scene and the network architecture. On the level of the physical scene, the NPE factorizes the scene into object-based representations, and composes smaller building blocks to form larger objects. This method of representation adapts to scene configurations of variable complexity and shape. On the level of the network architecture, the NPE explicitly reflects a causal structure in object interactions by factorizing object dynamics into pairwise interactions. The NPE models the future state of a single object as a function composition of the pairwise interactions between itself and other context objects in the scene. This structure serves to guide learning towards objectbased reasoning and is designed for physical knowledge to transfer across variable number objects anywhere in the scene. ",
+        "bbox": [
+            173,
+            569,
+            825,
+            708
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1.3 A STEP TOWARDS EMULATING A GENERAL-PURPOSE PHYSICS ENGINE ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            731,
+            697,
+            743
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "While previous bottom-up approaches (Sec. 4) have coupled learning vision and learning physical dynamics, we take a different approach for two reasons. First, we see that disentangling the visual properties of an object from its physical dynamics is a step toward achieving the generality of a physics engine. Both vision and dynamics are necessary, but we believe that keeping these functionalities separate is important for common-sense generalization that is robust to cases where the visual appearance changes but the dynamics remain the same. Second, we are optimistic that those two components indeed can be decoupled, that a vision model can map visual input to an intermediate state space, and a dynamics model can evolve objects in that state space through time. For example, there is work in object detection and localization (e.g. Eslami et al. 2016) for extracting position and velocity, as well as work for extracting latent object properties (Wu et al., 2015; 2016). Therefore this paper focuses on learning dynamics in that state space, taking a small step toward emulating a general-purpose physics engine, with the eventual goal of building a system that exhibits the compositionality, modularity, and generality of a physics engine whose internal components can be learned through observation. ",
+        "bbox": [
+            174,
+            757,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/dd6dea5ce4b76d95b0f2f6572777eb2f6e98dab30ac9224461e1400cf71a5ad9.jpg",
+        "image_caption": [
+            "Figure 1: Physics Programs: We consider the space of physics programs over object-based representations under physical laws that are Markovian and translation-invariant. We consider each object in turn and predict its future state conditioned on the past states of itself and its context objects. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            279,
+            106,
+            720,
+            215
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            296,
+            821,
+            325
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In Sec. 2 we present a specific instantiation of the NPE that uses a neighborhood mask to select context objects. In Sec. 3 we apply that instantiation to investigate variations on two-dimensional worlds of balls and obstacles from the matter-js physics engine (Brummitt, 2014) as a testbed for exploring the NPE’s capabilities to model simple rigid-body dynamics. While these worlds are generated from a simplified physics engine, we believe that learning to model such simple physics under the NPE’s framework is a first and necessary step towards emulating the full capacity of a general physics engine, while maintaining a differentiability that can allow it to eventually learn complex real-world physical phenomena that would be challenging to engineer into conventional physics engines. This paper establishes that important step. ",
+        "bbox": [
+            174,
+            332,
+            825,
+            458
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 APPROACH",
+        "text_level": 1,
+        "bbox": [
+            174,
+            478,
+            299,
+            494
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 NEURAL PHYSICS ENGINE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            510,
+            398,
+            523
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We consider in detail a specific instantiation of the NPE that uses a neighborhood mask to select context objects. This section discusses each of the four ingredients of the NPE framework, that, when combined, comprise a neural network-based physics simulator that learns from observation. ",
+        "bbox": [
+            176,
+            535,
+            825,
+            578
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Object-Based Representations We make two observations (Fig. 1) in our factorization of the scene. The first regards spatially local computation. Because physics does not change across inertial frames, it suffices to separately predict the future state of each object conditioned on the past states of itself and the other objects in its neighborhood, similar to Fragkiadaki et al. (2015b). Sec. 3.5 shows that when large structures are represented as a composition of smaller objects, a spatially local attention window helps achieve invariance to scene configuration. The second observation regards temporally local computation. Because physics is Markovian, this prediction need only be for the immediate next timestep, which we show in Sec. 3 is enough to predict physics effectively over long timescales. Given these two observations, it is natural to choose an object-based state representation. A state vector comprises extrinsic properties (position, velocity, orientation, angular velocity), intrinsic properties (mass, object type, object size), and global properties (gravitational, frictional, and pairwise forces) at a given time instance. ",
+        "bbox": [
+            174,
+            593,
+            825,
+            760
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Pairwise Factorization Letting a particular object be the focus object $f$ and all other objects in the scene be context objects $c$ , the NPE models the focus object’s velocity $v _ { f } ^ { [ t + 1 ] }$ as a composition of the pairwise interactions between itself and other neighboring context objects in the scene during time $t \\mathrm { ~ - ~ } 1$ and $t$ . This input is represented as pairs of object state vectors $\\left\\{ \\left( o _ { f } , o _ { c _ { 1 } } \\right) ^ { \\left[ t - 1 , t \\right] } , \\left( o _ { f } , o _ { c _ { 2 } } \\right) ^ { \\left[ t - 1 , t \\right] } , \\ldots \\right\\}$ . As shown in Fig. 2b, the NPE composes an encoder function and a decoder function. The encoder function $f _ { e n c }$ summarizes the interaction of a single object pair. The sum of encodings of all pairs is then concatenated with the focus object’s past state as input to the decoder function. The focus object is a necessary input to the decoder because if there are no neighboring context objects, the summed encoder output would be zero. The decoder function then predicts the focus object’s velocity $v _ { f } ^ { [ t + 1 ] }$ . In practice, the NPE predicts the change $\\Delta v$ between $t$ and $t + 1$ to compute $v ^ { [ t + 1 ] } = v ^ { [ t ] } + \\Delta v$ , and updates position using the velocity as a first-order approximation1. We predict velocity rather than position to help avoid memorizing the environment; training the network to predict position conditions the network on the worlds in the training domain, making it more difficult to transfer knowledge across environments. We do not include acceleration in the state representation because position and velocity fully parametrize an object’s state. Thus acceleration (e.g. collisions) can be learned by observing velocity for two consecutive timesteps, hence our choice for two input timesteps. We explored longer input durations as well and found no additional benefit. ",
+        "bbox": [
+            173,
+            775,
+            825,
+            925
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            102,
+            825,
+            214
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Context Selection Each $\\left( o _ { f } , o _ { c } \\right)$ pair is selected to be in the set of neighbors of $f$ by the neighborhood masking function $\\lfloor \\bar { \\lceil } \\rceil | p _ { c } - p _ { f } ) | | < N ( o _ { f } ) \\rfloor$ , which takes value 1 if the Euclidean distance between the positions $p _ { f }$ and $p _ { c }$ of the focus and context object respectively at time $t$ is less the neighborhood threshold $\\dot { \\boldsymbol { N } } ( \\boldsymbol { o } _ { f } )$ . Many physics engines use a collision detection scheme with two phases. Broad phase is used for computational efficiency and uses a neighborhood threshold to select objects that might, but not necessarily will, collide an object. Narrow phase performs the actual collision detection on that smaller subset of objects and also resolves the collisions for the objects that do collide. Analogously, our neighborhood mask implements broad phase, and the NPE implements narrow phase. The mask only constrains the search space of context objects, and the network figures out how to detect and resolve collisions. This mask is a specific case of a more general attention mechanism to select contextual elements of a scene. ",
+        "bbox": [
+            174,
+            231,
+            825,
+            382
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Function Composition Symbolic physics engines evolve objects through time based on dynamics that dictate their independent behavior (e.g. inertia) and their behavior with other objects (e.g. collisions). Notably, in a particular object’s reference frame, the forces it feels from other objects are additive. The NPE architecture incorporates several inductive biases that reflect this recipe. The composition of $f _ { e n c }$ and $f _ { d e c }$ induce a causal structure on the pairs of objects. We provide a loose interpretation of the encoder output $e _ { c , f }$ as the effect of object $c$ on object $f$ , and require that these effects are additive as forces are. This design allows the NPE to scale naturally to different numbers of neighboring context objects. These inductive biases have the effect of strongly constraining the space of possible simulators that the NPE can learn, focusing on compositional programs that reflect pairwise causal structure in object interactions. ",
+        "bbox": [
+            174,
+            400,
+            825,
+            537
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.2 BASELINES",
+        "text_level": 1,
+        "bbox": [
+            174,
+            556,
+            294,
+            570
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The purpose of contrasting the NPE with the following two baselines is to illustrate the benefit of pairwise factorization and function composition, which are the key architectural features of the NPE. As the architectures for both baselines have been shown to work well in similar tasks, it is not immediately clear whether the NPE’s assumptions are useful or necessary, so these are good baselines for comparison. Viewed in another way, comparing with these baselines is a lesion study on the NPE because each baseline lacks an aspect of the NPE structure. ",
+        "bbox": [
+            174,
+            582,
+            825,
+            665
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "No-Pairwise The No-Pairwise (NP) baseline is summarized by Fig. 2c. It is very similar to the NPE but does not compute pairwise interactions; otherwise its encoder and decoder are the same as the NPE’s. Therefore the NP most directly highlights the value of the NPE’s pairwise factorization. The NP is also a Markovian variant of the Social LSTM (Alahi et al., 2016); it sums the encodings of context objects after encoding each object independently, similar to the Social LSTM’s “social pooling.” Information for modeling how objects interact would only be present after the encoding step. A possible mechanism for predicting dynamics with the NP is if the encoder’s object encoding consists of an abstract object representation and a force field created by that object. Therefore the decoder could apply the sum of the force fields of all context objects to the focus object’s abstract object representation to predict the focus object’s velocity. As Alahi et al. (2016) has demonstrated the Social LSTM’s performance in modeling human trajectories, it would be interesting to see how the same architectural assumptions perform for the physics of moving objects. ",
+        "bbox": [
+            174,
+            681,
+            825,
+            848
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/51572477e5f832e557281e245813f144ff74dcfd13d1891321980c98c31884b5.jpg",
+        "image_caption": [
+            "Figure 2: Scenario and Models: This figure compares the NPE, the NP and the LSTM architectures in predicting the velocity of object 3 for an example scenario [a] of two heavy balls (cyan) and two light balls (yellow-green). Objects 2 and 4 are in object 3’s neighborhood, so object 1 is ignored. [b]: The NPE encoder consists of a pairwise layer (yellow) and a feedforward network (red) and its decoder (blue) is also a feedforward network. The input to the decoder is the concatenation of the summed pairwise encodings and the input state of object 3. [c]: The NP encoder is the same as the NPE encoder, but without the pairwise layer. The NP decoder is the same as the NPE decoder. The input to the decoder is the concatenation of the summed context encodings and the encoding of object 3. [d]: We shuffle the context objects inputted into the LSTM and use a binary flag to indicate whether an object is a context or focus object. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            240,
+            102,
+            758,
+            329
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "LSTM Long Short-Term Memory (LSTM) networks (Hochreiter and Schmidhuber, 1997) have been shown to sequentially attend to objects (Eslami et al., 2016), so it is interesting to test whether a LSTM is well-suited for modeling object interactions, when the object states are explicitly given as input. From a cognitive science viewpoint, an LSTM can be interpreted as a serial mechanism in object tracking (Pylyshyn and Annan, 2006). Our LSTM architecture (Fig. 2d) accepts the state of each context object until the last step, at which it takes in the focus object’s state and predicts its velocity. Because the LSTM moves through the object space sequentially, its lack of factorized compositional structure highlights the value of the NPE’s function composition of the independent interactions between an object and its neighbors. Our notion of compositionality treats each object and pairwise interaction as independently encapsulated in a separate computational entity that can be reused and rearranged; the NPE encoder is a function that is applied to each $\\left( o _ { f } , o _ { c } \\right)$ pair. This function encapsulates this computation and can be repeatedly applied to all neighboring context objects equally, such that the NPE composes this repeated encoding function with the decoder function to predict velocity. The LSTM does not exhibit this notion of compositionality because it is not designed to take advantage of the factorized structure of the scene. Unlike the NPE and NP, the LSTM’s structure does not differentiate between focus and context object, so we add a flag to the state representation to indicate to whether an object is a context or focus object. We shuffle the order of the context objects to account for an ordering bias. ",
+        "bbox": [
+            173,
+            510,
+            825,
+            758
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            780,
+            326,
+            796
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Object-based representations (ingredient 1) are necessary for the other three ingredients, and having explained the motivation for object-based representations in Sec. 1.3 and Sec. 2.1, we now analyze the other three ingredients in the context of several experiments. In the prediction task (Sec. 3.1), we first test if the NPE is even capable of predicting physics when the number of objects is held constant. In the generalization task (Sec. 3.2), we test the NPE’s capability to generalize across variable object count. In the inference task (Sec. 3.3), we test if the NPE can be inverted to infer mass in both the prediction and generalization settings. In these experiments, we compare against the NPE-NN, a modified NPE without the neighborhood mask, to analyze the context selection mechanism (ingredient 2), the NP to analyze factorization (ingredient 3), the LSTM to analyze compositionality (ingredient 4). Sec. 3.4 analyzes the neighborhood mask in depth. We test the NPE’s capability to generalize across different scene configurations in Sec. 3.5. ",
+        "bbox": [
+            174,
+            811,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Using the matter-js physics engine, we evaluate the NPE on worlds of balls and obstacles. These worlds exhibit nonlinear dynamics and support a wide variety of scenarios. Bouncing balls have been of interest in cognitive science to study causality and counterfactual reasoning, as in Gerstenberg et al. (2012). We trained on 3-timestep windows in trajectories of 60 timesteps (10 timesteps $\\approx 1$ second). For a world of $k$ objects, we generate 50,000 such trajectories. For experiments where we train on multiple worlds together, we shuffle the examples across all training worlds and train without a curriculum schedule. All worlds have a vertical dimension of 600 pixels and a horizontal dimension of 800 pixels, and we constrain the maximum velocity of an object to be 60 pixels/second. We normalize positions to $[ 0 , 1 ]$ by dividing by the horizontal dimension, and we normalize velocities to $[ - 1 , 1 ]$ by dividing by the maximum velocity. ",
+        "bbox": [
+            174,
+            152,
+            825,
+            291
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Like those of Battaglia et al. (2016) the NPE predictions can be effective over long timescales even when the NPE is only trained to predict the immediate next time step. Randomly selected simulation videos can be found at $\\mathtt { h t t p s : / / q o o . q l / B W Y u O F }$ . Plots show results over three independent runs averaged over held-out test data with different random seeds. As shown in the graphs in Fig. 3 (top two rows) and Fig. 5, both the NP and LSTM’s predicted trajectories diverge from the ground truth, but for different reasons, which the videos illuminate. While the NP and LSTM fail to predict plausible physical movement entirely, the NPE’s predictions initially adhere closely to the ground truth, then slowly diverge due to the accumulation of subtle errors, just as the human perceptual system also accumulates errors (Smith and Vul, 2013). However, the NPE preserves the general intuitive physical dynamics that may roughly be consistent with people’s intuitive expectations. ",
+        "bbox": [
+            174,
+            297,
+            825,
+            438
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.1 PREDICTION TASK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            455,
+            341,
+            468
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We consider simple worlds of four balls of uniform mass (Fig. 3a). To measure performance in simulation, we visualize the cosine similarity between the predicted velocity and the ground truth velocity as well as the relative error in magnitude between the predicted velocity and the ground truth velocity over 50 timesteps of simulation. The models take timesteps 1 and 2 as initial input, and then use previous predictions as input to future predictions. To measure progress through training, we also display the Mean Squared Error (MSE) on the normalized velocity. ",
+        "bbox": [
+            174,
+            481,
+            825,
+            565
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.2 GENERALIZATION TASK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            582,
+            380,
+            595
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We test whether learned knowledge of these simple physics concepts can be transferred and extrapolated to worlds with a number of objects previously unseen (Fig. 3b). The unseen worlds (6, 7, 8 balls) in the test data are combinatorially more complex and varied than the observed worlds (3, 4, 5 balls) in the training data. All objects have equal mass. During simulation, the NPE’s predictions are more consistent, whereas the NP and LSTM’s prediction begin to diverge wildly towards the end of 50 timesteps of simulation (Fig. 3b, middle row). The NPE consistently outperforms the baselines by 0.5 to 1 order of magnitude in velocity prediction (Fig. 3b, bottom row). ",
+        "bbox": [
+            174,
+            608,
+            825,
+            705
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.3 INFERENCE TASK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            723,
+            334,
+            737
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We now show that the NPE can infer latent properties such as mass. This proposal is motivated by the experiments in Battaglia et al. (2013), which uses a probabilistic physics simulator to infer various properties of a scene configuration. Whereas the physical rules of their simulator were manually pre-specified, the NPE learns these rules from observation. We train on the same worlds used in both the prediction and generalization tasks, but we uniformly sampled the mass for each ball from the log-spaced set $\\{ 1 , 5 , 2 5 \\}$ . We chose to use discrete-valued masses to simplify our qualitative understanding of the model’s capacity to infer. For future work we would like to investigate continuously valued masses and evaluate with binary comparisons (e.g. ”Which is heavier?”). ",
+        "bbox": [
+            174,
+            750,
+            823,
+            861
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As summarized by Fig. 3c and Fig. 4a, we select scenarios exhibiting collisions with the focus object, fix the masses of all other objects, and score the NPE’s prediction under all possible mass hypotheses for the focus object. The prediction is scored against the ground-truth under the same MSE loss used in training. The hypothesis whose prediction yields the lowest error is the NPE’s maximum likelihood estimate of the focus object’s mass. Outperforming all baselines, the NPE achieves about $90 \\%$ accuracy, meaning it has $90 \\%$ probability of inferring the correct mass. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/6093b84d8d2ee4c6482a60670345ddc1b48ae0f3a86357390c4354ec123cc435.jpg",
+        "image_caption": [
+            "Figure 3: Quantitative evaluation (balls): [a,b]: Prediction and generalization tasks. Top two rows: The cosine similarity and the relative error in magnitude. Bottom row: The MSE of velocity on the test set over the course of training. Because these worlds are chaotic systems, it is not surprising that all predictions diverge from the ground truth with time, but NPE consistently outperforms the other two baselines on all fronts, especially when testing on 6, 7, and 8 objects in the generalization task. The NPE’s performance continues to improve with training while the NPE-NN (an NPE without a neighborhood mask, see Sec. 3.4), NP and LSTM quickly plateau. We hypothesize that the NPE’s structured factorization of the state space guides it from wasting time exploring suboptimal programs. [c]: The NPE’s accuracy is significantly greater than the baseline models’ in mass inference. Notably, the NPE achieves similar inference performance whether in the prediction or generalization settings, further showcasing its strong generalization capabilities. The LSTM performs poorest, reaching just above random guessing ( $3 3 \\%$ accuracy). [d]: We analyze the effectiveness of different neighborhood thresholds for the NPE on the constant-mass prediction task. The neighborhood threshold is quite robust from 3 to 5 ball radii. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            103,
+            816,
+            368
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            612,
+            821,
+            640
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The NPE predicts outputs given inputs and infers inputs given outputs. Though we adopted a particular parametrization of an object, the NPE is not limited to the semantic meaning of the elements of its input, so we expect other latent object properties can be inferred this way. Because the NPE is differentiable, we expect that it can also infer object properties by backpropagating prediction error to its a randomly sampled input. This would be useful for inferring non-categorical values, such as positions of “invisible” objects, whose effects are felt but whose positions are unknown. ",
+        "bbox": [
+            174,
+            647,
+            825,
+            729
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.4 NEIGHBORHOOD MASK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            748,
+            377,
+            762
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In Fig. 3d we vary the NPE’s neighborhood threshold $N ( o _ { f } )$ and evaluate performance on the constant-mass prediction task. $N ( o _ { f } )$ is in units of ball radii, so $N ( o _ { f } ) = 2$ means that a context object is only detected if it is exactly touching the focus object. Because ball radii are 60 pixels and the maximum velocity is 60 pixels per timestep, the maximum distance two balls can initially be before touching at the next timestep is 4 ball radii. Given that velocities were sampled uniformly, it makes sense that the NPE performs well in and is robust2 to the range $N ( o _ { f } ) \\in \\left[ 3 , 5 \\right]$ , but performance drops off with smaller and larger $N ( o _ { f } )$ . It is important to note that different $N ( o _ { f } )$ may work better for different domains and object geometries. ",
+        "bbox": [
+            173,
+            773,
+            825,
+            886
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/3383b854b5973a5d0af62bf54985e07788f74a27f6506bbb22d91ba1a8bb1a5c.jpg",
+        "image_caption": [
+            "Figure 4: Visualizations: The NPE scales to complex dynamics and world configurations while the NP and LSTM cannot. The masses are visualized as: cyan $= 2 5$ , red $= 5$ , yellow-green $= 1$ . [a] Consider the collision in the 7 balls world (circled). In the ground truth, the collision happens between balls 1 and 2, and the NPE correctly predicts this. The NP predicts a slower movement for ball 1, so ball 2 overlaps with ball 3. The LSTM predicts a slower movement and incorrect angle off the world boundary, so ball 2 overlaps with ball 3. [b] At first glance, all models seem to handle collisions well in the $\\mathbf { \\tilde { \\Sigma } } ^ { 6 6 } \\mathbf { O } ^ { 5 }$ world (diamond), but when there are internal obstacles (cloud), only the NPE can successfully resolve collisions. This suggests that the NPE pairwise factorization handles object interactions well, letting it generalize to different world configurations, whereas the NP and LSTM have only memorized the geometry of the “O” world. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            104,
+            825,
+            363
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We include analysis in the prediction and generalization tasks on an NPE without the neighborhood mask, the NPE-NN $\\mathrm { N N } = \\mathrm { N o }$ Neighborhood). The neighborhood mask gives the NPE about an order of magnitude improvement in velocity prediction loss (Fig. 3a,b: bottom row and Fig. 6). While the NPE loss continues to improve through training, the NPE-NN loss quickly plateaus. It is interesting that the NPE-NN performs no better than both the NP and LSTM in predictive error, but outperforms the LSTM in mass inference. These two observations suggest that computing the interactions the focus object shares with each context object is more effective for inferring a property of the focus object than disregarding these factorized effects. They also suggest that the additional spatial structure from constraining the context space with the neighborhood mask prevents the NPE from naively finding associations with objects that cannot influence the focus object. ",
+        "bbox": [
+            174,
+            546,
+            825,
+            685
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In our experiments, the neighborhood mask has the additional practical benefit of reducing computational complexity from $O ( k )$ to $O ( 1 )$ , where $k$ is the number of objects in the scene, because the number of context-focus object pairs the NPE considers is bounded above by the neighborhood mask at a constant number. Though beyond the scope of this work, to extend the functionality of such context selection mechanism to include worlds that contain forces that act from a distance, future instantiations of the NPE may investigate a more general context selection mechanism that can be learned jointly with the other model parameters. ",
+        "bbox": [
+            174,
+            693,
+            825,
+            790
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "3.5 DIFFERENT SCENE CONFIGURATIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            813,
+            473,
+            827
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We demonstrate representing large structures as a composition of smaller objects as building blocks. This is important for testing the NPE’s invariance to scene configuration; the scene configuration should not matter if the underlying physical laws remain the same. These worlds contain 2 balls bouncing around in variations of 4 different wall geometries. “O” and “L” geometries have no internal obstacles and are in the shape of a rectangle and “L” respectively. “U” and “I” have internal obstacles. Obstacles in “U” are linearly attached to the wall like a protrusion, while obstacles in “I” ",
+        "bbox": [
+            174,
+            840,
+            825,
+            922
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/2a3b2837e9336194a5a7fca1154ac62174098ee0cdb0f09f3e04e67edc15e834.jpg",
+        "image_caption": [
+            "Figure 5: Quantitative evalution (walls and obstacles): The compositional state representation simplifies the physical prediction problem to only be over local arrangements of context balls and obstacles, even when the wall geometries are more complex and varied on a macroscopic scale. Therefore, it is not surprising that the models perform consistently across wall geometries. Note that the NPE consistently outperforms the other models, and this gap in performance increases with more varied internal obstacles for the cosine similarity of the velocity angle. This gap is more prominent in “L” and “U” geometries for relative error in magnitude. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            103,
+            823,
+            310
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "have no constraint in position. We randomly vary the position and orientation of the “L” concavity and the “U” protrusion. We randomly sample the positions of the “I” internal obstacles. ",
+        "bbox": [
+            174,
+            445,
+            821,
+            473
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We train on conceptually simpler “O” and “L” worlds and test on more complex “U” and “I” worlds. Variations in wall geometries adds to the difficulty of this extrapolation task. At most 12 context objects are present in the focus object’s neighborhood at a time. The “U” geometries have 33 objects in the scene, the most out of all the wall geometries. As shown in Fig. 4b and 5, the NPE is robust to scenes with internal obstacles, even when it has not observed such scenes during training. ",
+        "bbox": [
+            174,
+            481,
+            825,
+            550
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "3.6 ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            568,
+            285,
+            582
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We explain the NPE’s superior performance in generalization from the perspective of context selection, factorization, and compositionality. By design, all three ingredients transform the testing data distribution to be similar to the training data distribution, such that generalization across variable object count and different scene configurations happens naturally. ",
+        "bbox": [
+            174,
+            593,
+            823,
+            648
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Consider generalizing across variable object count. The neighborhood mask selects context objects such that the NPE need only focus on a bounded subset of the objects regardless of the total number of objects. Factorizing the scene into pairwise interactions induces a causal structure between each context object and the focus object, such that no matter the object count, this causal structure remains consistent because the input is merely a set of object pairs. Composing these pairwise interactions together with a summation encourages the encoder output to be additive, such that the decoder receives the appropriate net effect from the context objects, regardless of how many there are. ",
+        "bbox": [
+            174,
+            656,
+            825,
+            753
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Consider generalizing across different scene configurations. Our state representation composes larger structures from smaller objects, just as many real-world objects are composed of smaller components. Therefore, even when wall geometries are complex and varied on a macroscopic scale, the input distribution to the NPE remains roughly the same, because the prediction problem still remains only over objects in a local glimpse the entire scene. ",
+        "bbox": [
+            174,
+            761,
+            823,
+            830
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            851,
+            344,
+            866
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Top-down and bottom-up approaches A recent set of top-down approaches investigate probabilistic game physics engines as computational models for physical simulation in humans (Bates et al., 2015; Battaglia et al., 2013; Hamrick et al., 2011; Ullman et al., 2014). However, these models require a full specification of the physical laws and object geometries. Given such a specification, inferring how physical laws compose and apply to a given scenario are their strength, but automatically inferring from visual data what physical laws and object properties are present requires more work in inverse graphics (Chen et al., 2016; Kulkarni et al., 2014; 2015a;b; Whitney et al., 2016) and physics-based visual understanding (Brand, 1997; Wu et al., 2015; 2016). The NPE builds on top of the key structural assumptions of these top-down approaches, but its differentiable architecture opens a possible path for joint training with a vision model that can automatically adapt to the specific physical properties of the scene. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            214
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Bottom-up approaches attempt to bypass the intermediate step of finding physics representations and directly map visual observations to physical judgments (Lerer et al., 2016; Li et al., 2016; Mottaghi et al., 2015; 2016) or passive (Lerer et al., 2016; Srivastava et al., 2015; Sutskever et al., 2009) and action-conditioned (Agrawal et al., 2016; Finn et al., 2016; Fragkiadaki et al., 2015b) motion prediction. Because these work historically have not been compositional in nature, they have had limited flexibility to transfer knowledge to conceptually similar worlds where the physics remain the same, but the number of objects or complexity of object configurations varies. Moreover, these approaches above do not infer latent properties as the NPE does. ",
+        "bbox": [
+            174,
+            222,
+            825,
+            333
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Other work have taken similar hybrid approaches as the NPE, such as the NeuroAnimator (Grzeszczuk et al., 1998), one of the first work to train a neural network to emulate a physics simulator, and the interaction network (Battaglia et al., 2016), which learns to simulate physics over a graph of objects and their relations. ",
+        "bbox": [
+            174,
+            340,
+            825,
+            395
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sketching The NPE combines a symbolic structure that assumes generic objects and interactions with a differentiability that allows the specific nature of these interactions to be learned from training. This approach of starting with a general sketch of a program and filling in the specifics is inspired by ideas from the program synthesis community (Ellis et al., 2015; Gaunt et al., 2016; Solar-Lezama, 2008). Examples of other work that combine symbolic with neural approaches via sketching include graph-based neural networks (Jain et al., 2016; Li et al., 2015; Scarselli et al., 2009) and transforming autoencoders (Hinton et al., 2011). ",
+        "bbox": [
+            174,
+            414,
+            825,
+            511
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Composing functions for reuse Just as the NPE repeatedly applies the same encoder to each object pair, iteratively applies itself to each object in the scene as a focus object, and recursively predicts future timesteps using predictions from previous timesteps, employing function reuse to achieve generalization is also featured in work such as Abelson et al. (1996); Andreas et al. (2016); Lake et al. (2015); Reed and de Freitas (2015); Socher et al. (2011). These work all assemble small subprograms to form larger programs. The NPE also dynamically composes its internal modules (encoder and decoder) based on the number of objects and the arrangement of context objects. ",
+        "bbox": [
+            174,
+            530,
+            825,
+            627
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Object-based approaches Fragkiadaki et al. (2015b) and Battaglia et al. (2016) are two notably similar work in the sense that our work and theirs all take an object-based approach to model the bouncing balls environment. Our work was inspired by Fragkiadaki et al. (2015b)’s iterative approach to predicting the motion of each object in turn, conditioned on a context. The key contrast is that their model assumes no relational structure between objects beyond a visual attention window centered around the focus object, whereas ours explicitly processes the interaction between the focus and each context object. ",
+        "bbox": [
+            174,
+            645,
+            825,
+            742
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "If we compare their simulation videos (Fragkiadaki et al., 2015a) to ours, we see some specific and significant improvements evident in our approach. For example, in their work, the balls appear attracted to each other and to the walls; the balls appear to bounce along the walls even when no attractive force should be present. The balls rarely touch during collisions, but magnetically repel each other when at a short distance. The NPE does not exhibit these behaviors and tends to preserve the intuitive physical dynamics of colliding balls. In addition to these differences, we show strong predictive performance on generalizing to eight balls, five more than the balls in their videos. We also crucially show this performance under stronger generalization conditions, variable mass, and more complex scene configurations. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            875
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Recently, Battaglia et al. (2016) independently and in parallel developed an architecture that they call the interaction network for learning to model physical systems. They show how such an architecture can apply to several different kinds of physical systems, including n-body gravitational interactions and a string falling under gravity. Like their work, our model can simulate over many timesteps very effectively when only trained for next-timestep prediction, and can generalize to different world configurations and different numbers of objects. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            145
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Compared to the interaction network, a main difference in our architecture is that ours does not take object relations as explicit input, but instead learns the nature of these relations by constraining attention to a neighborhood set of objects. Another difference is in function reuse: we demonstrated that a trained NPE can automatically infer properties of its input such as mass without further retraining. In contrast, they train an additional classifier on top of their model to do inference. Their work also exhibits the four ingredients in our framework, and we view the similarities between their and our work as converging evidence for the utility of object-based representations and compositional model architectures in learning to emulate general-purpose physics engines. ",
+        "bbox": [
+            174,
+            152,
+            825,
+            263
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "5 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            296,
+            310,
+            313
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "While this paper is not the first to explore learning a physics simulator, here we take the opportunity to highlight the value of this paper’s contributions. We hope these contributions can seed further research that builds on the NPE framework this paper proposes. ",
+        "bbox": [
+            174,
+            335,
+            823,
+            378
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We showed that object-based representations, a context selection mechanism, factorization, and compositionality are useful ingredients for learning a physics simulator that generalizes across variable object count and different scene configurations with only spatially and temporally local computation. This generalization is possible because these ingredients transform the testing data distribution to be similar to the training data distribution. ",
+        "bbox": [
+            176,
+            386,
+            823,
+            455
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "The NPE makes few but strong assumptions about the nature of objects in a physical environment. These assumptions are inductive biases that not only give the NPE enough structure to help constrain it to model physical phenomena in terms of objects but also are general enough for the NPE to learn physical dynamics almost exclusively from observation. ",
+        "bbox": [
+            176,
+            462,
+            823,
+            517
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We applied the NPE to simple two-dimensional worlds of bouncing balls ranging in complexity. We showed that NPE achieves low prediction error, extrapolates learned physical knowledge to previously unseen number of objects and world configurations, and can infer latent properties such as mass. We compared against several baselines designed to test the ingredients of the NPE framework and found superior performance when all these ingredients are combined in the NPE. Though we demonstrated the NPE in the balls environment with nonlinear dynamics and complex scene configurations, the state representation and NPE architecture we propose are quite general-purpose because they assume little about the specific dynamics of a scene. ",
+        "bbox": [
+            174,
+            525,
+            825,
+            636
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "This paper works toward emulating a general purpose physics engine under a framework where visual and physical aspects of a scene are disentangled. Next steps include linking the NPE with perceptual models that extract properties such as position and mass from visual input. Learning to simulate is unsupervised learning of the structure of the environment. When a simulator like the NPE is incorporated into an agent in the context of model-based planning and model-based reinforcement learning, it becomes a prior on the environment that guides learning and reasoning. By combining the expressiveness of physics engines and the adaptability of neural networks in a compositional architecture that supports generalization in fundamental aspects of physical reasoning, the Neural Physics Engine is an important step towards lifting an agent’s ability to think at a level of abstraction where the concept of physics is primitive. ",
+        "bbox": [
+            174,
+            643,
+            825,
+            782
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            813,
+            326,
+            824
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We thank Tejas Kulkarni for insightful discussions and guidance. We thank Ilker Yildirim, Erin Reynolds, Feras Saad, Andreas Stuhlmuller, Adam Lerer, Chelsea Finn, Jiajun Wu, and the anony- ¨ mous reviewers for valuable feedback. We thank Liam Brummit, Kevin Kwok, and Guillermo Webster for help with matter-js. This work was supported MIT’s SuperUROP and UROP programs, and by the Center for Minds, Brains and Machines under NSF STC award CCF-1231216 and an ONR grant N00014-16-1-2007. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            922
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES   \nH. Abelson, G. J. Sussman, and J. Sussman. Structure and interpretation of computer programs. Justin Kelly, 1996.   \nP. Agrawal, A. Nair, P. Abbeel, J. Malik, and S. Levine. Learning to poke by poking: Experiential learning of intuitive physics. arXiv preprint arXiv:1606.07419, 2016.   \nA. Alahi, K. Goel, V. Ramanathan, A. Robicquet, L. Fei-Fei, and S. Savarese. Social lstm: Human trajectory prediction in crowded spaces. 2016.   \nJ. R. Anderson. Cognitive psychology and its implications . WH Freeman/Times Books/Henry Holt & Co, 1990.   \nJ. Andreas, M. Rohrbach, T. Darrell, and D. Klein. Learning to compose neural networks for question answering. In Proceedings of NAACL-HLT, pages 1545–1554, 2016.   \nC. J. Bates, I. Yildirim, J. B. Tenenbaum, and P. W. Battaglia. Humans predict liquid dynamics using probabilistic simulation. 2015.   \nP. Battaglia, R. Pascanu, M. Lai, D. Jimenez Rezende, and K. Koray. Interaction networks for learning about objects, relations and physics. In Advances in Neural Information Processing Systems, 2016.   \nP. W. Battaglia, J. B. Hamrick, and J. B. Tenenbaum. Simulation as an engine of physical scene understanding. Proceedings of the National Academy of Sciences, 110(45):18327–18332, 2013.   \nM. Brand. Physics-based visual understanding. Computer Vision and Image Understanding, 65(2): 192–205, 1997.   \nL. Brummitt. http://brm.io/matter-js, 2014. URL http://brm.io/matter-js.   \nX. Chen, Y. Duan, R. Houthooft, J. Schulman, I. Sutskever, and P. Abbeel. Infogan: Interpretable representation learning by information maximizing generative adversarial nets. In Advances in Neural Information Processing Systems, pages 2172–2180, 2016.   \nR. Collobert, K. Kavukcuoglu, and C. Farabet. Torch7: A matlab-like environment for machine learning. In BigLearn, NIPS Workshop, number EPFL-CONF-192376, 2011.   \nK. Ellis, A. Solar-Lezama, and J. Tenenbaum. Unsupervised learning by program synthesis. In Advances in Neural Information Processing Systems, pages 973–981, 2015.   \nS. Eslami, N. Heess, T. Weber, Y. Tassa, K. Kavukcuoglu, and G. E. Hinton. Attend, infer, repeat: Fast scene understanding with generative models. arXiv preprint arXiv:1603.08575, 2016.   \nC. Finn, I. Goodfellow, and S. Levine. Unsupervised learning for physical interaction through video prediction. arXiv preprint arXiv:1605.07157, 2016.   \nK. Fragkiadaki, P. Agrawal, S. Levine, and J. Malik. Intuitive physics. https://sites. google.com/site/intuitivephysicsnips15/, 2015a. (Accessed on 03/03/2017).   \nK. Fragkiadaki, P. Agrawal, S. Levine, and J. Malik. Learning visual predictive models of physics for playing billiards. arXiv preprint arXiv:1511.07404, 2015b.   \nA. L. Gaunt, M. Brockschmidt, R. Singh, N. Kushman, P. Kohli, J. Taylor, and D. Tarlow. Terpret: A probabilistic programming language for program induction. arXiv preprint arXiv:1608.04428, 2016.   \nT. Gerstenberg, N. Goodman, D. A. Lagnado, and J. B. Tenenbaum. Noisy newtons: Unifying process and dependency accounts of causal attribution. In In proceedings of the 34th. Citeseer, 2012.   \nN. D. Goodman and J. B. Tenenbaum. Probabilistic models of cognition, 2016. URL http: //probmods.org. ",
+        "bbox": [
+            171,
+            92,
+            828,
+            925
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "R. Grzeszczuk, D. Terzopoulos, and G. Hinton. Neuroanimator: Fast neural network emulation and control of physics-based models. In Proceedings of the 25th annual conference on Computer graphics and interactive techniques, pages 9–20. ACM, 1998. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "J. Hamrick, P. Battaglia, and J. B. Tenenbaum. Internal physics models guide probabilistic judgments about object dynamics. 2011.   \nG. E. Hinton, A. Krizhevsky, and S. D. Wang. Transforming auto-encoders. In Artificial Neural Networks and Machine Learning–ICANN 2011, pages 44–51. Springer, 2011.   \nS. Hochreiter and J. Schmidhuber. Long short-term memory. Neural computation, 9(8):1735–1780, 1997.   \nA. Jain, A. R. Zamir, S. Savarese, and A. Saxena. Structural-rnn: Deep learning on spatio-temporal graphs. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 5308–5317, 2016.   \nT. D. Kulkarni, V. K. Mansinghka, P. Kohli, and J. B. Tenenbaum. Inverse graphics with probabilistic cad models. arXiv preprint arXiv:1407.1339, 2014.   \nT. D. Kulkarni, P. Kohli, J. B. Tenenbaum, and V. Mansinghka. Picture: A probabilistic programming language for scene perception. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 4390–4399, 2015a.   \nT. D. Kulkarni, W. F. Whitney, P. Kohli, and J. Tenenbaum. Deep convolutional inverse graphics network. In Advances in Neural Information Processing Systems, pages 2530–2538, 2015b.   \nB. M. Lake, R. Salakhutdinov, and J. B. Tenenbaum. Human-level concept learning through probabilistic program induction. Science, 350(6266):1332–1338, 2015.   \nB. M. Lake, T. D. Ullman, J. B. Tenenbaum, and S. J. Gershman. Building machines that learn and think like people. arXiv preprint arXiv:1604.00289, 2016.   \nN. Leonard, S. Waghmare, and Y. Wang. rnn: Recurrent library for torch. ´ arXiv preprint arXiv:1511.07889, 2015.   \nA. Lerer, S. Gross, R. Fergus, and J. Malik. Learning physical intuition of block towers by example. arXiv preprint arXiv:1603.01312, 2016.   \nW. Li, S. Azimi, A. Leonardis, and M. Fritz. To fall or not to fall: A visual approach to physical stability prediction. arXiv preprint arXiv:1604.00066, 2016.   \nY. Li, D. Tarlow, M. Brockschmidt, and R. Zemel. Gated graph sequence neural networks. arXiv preprint arXiv:1511.05493, 2015.   \nR. Mottaghi, H. Bagherinezhad, M. Rastegari, and A. Farhadi. Newtonian image understanding: Unfolding the dynamics of objects in static images. arXiv preprint arXiv:1511.04048, 2015.   \nR. Mottaghi, M. Rastegari, A. Gupta, and A. Farhadi. ” what happens if...” learning to predict the effect of forces in images. arXiv preprint arXiv:1603.05600, 2016.   \nZ. W. Pylyshyn and V. Annan. Dynamics of target selection in multiple object tracking (mot). Spatial vision, 19(6):485–504, 2006.   \nS. Reed and N. de Freitas. Neural programmer-interpreters. arXiv preprint arXiv:1511.06279, 2015.   \nF. Scarselli, M. Gori, A. C. Tsoi, M. Hagenbuchner, and G. Monfardini. The graph neural network model. IEEE Transactions on Neural Networks, 20(1):61–80, 2009.   \nK. A. Smith and E. Vul. Sources of uncertainty in intuitive physics. Topics in cognitive science, 5 (1):185–199, 2013.   \nR. Socher, E. H. Huang, J. Pennington, A. Y. Ng, and C. D. Manning. Dynamic pooling and unfolding recursive autoencoders for paraphrase detection. 2011.   \nA. Solar-Lezama. Program synthesis by sketching. ProQuest, 2008.   \nE. S. Spelke. Principles of object perception. Cognitive science, 14(1):29–56, 1990.   \nN. Srivastava, E. Mansimov, and R. Salakhutdinov. Unsupervised learning of video representations using lstms. 2015.   \nI. Sutskever, G. E. Hinton, and G. W. Taylor. The recurrent temporal restricted boltzmann machine. In Advances in Neural Information Processing Systems, pages 1601–1608, 2009.   \nT. Tieleman and G. Hinton. Lecture 6.5—RmsProp: Divide the gradient by a running average of its recent magnitude. COURSERA: Neural Networks for Machine Learning, 2012.   \nT. Ullman, A. Stuhlmuller, and N. Goodman. Learning physics from dynamical scenes. 2014. ¨   \nW. F. Whitney, M. Chang, T. Kulkarni, and J. B. Tenenbaum. Understanding visual concepts with continuation learning. arXiv preprint arXiv:1602.06822, 2016.   \nJ. Wu, I. Yildirim, J. J. Lim, B. Freeman, and J. Tenenbaum. Galileo: Perceiving physical object properties by integrating a physics engine with deep learning. In Advances in Neural Information Processing Systems, pages 127–135, 2015.   \nJ. Wu, J. J. Lim, H. Zhang, J. B. Tenenbaum, and W. T. Freeman. Physics 101: Learning physical object properties from unlabeled videos. In British Machine Vision Conference, 2016. ",
+        "bbox": [
+            168,
+            143,
+            828,
+            925
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            99,
+            828,
+            410
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A IMPLEMENTATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            361,
+            117
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We trained all models using the rmsprop (Tieleman and Hinton, 2012) backpropagation algorithm with a Euclidean loss for 1,200,000 iterations with a learning rate of 0.0003 and a learning rate decay of 0.99 every 2,500 training iterations, beginning at iteration 50,000. We used minibatches of size 50 and used a 70-15-15 split for training, validation, and test data. ",
+        "bbox": [
+            174,
+            133,
+            823,
+            189
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "All models are implemented using the neural network libraries built by Collobert et al. (2011); Leonard et al. (2015). The NPE encoder consists of a pairwise layer of 25 hidden units and a 5-layer ´ feedforward network of 50 hidden units per layer each with rectified linear activations. Because we use a binary mask to zero out non-neighboring objects, we implement the encoder layers without bias such that non-neighboring objects do not contribute to the encoder activations. The encoding parameters are shared across all object pairs. The decoder is a five-layer network with 50 hidden units per layer and rectified linear activations after all but the last layer. The NP encoder architecture is the same as the NPE encoder, but without the pairwise layer. The NP decoder architecture is the same as the NPE decoder. The LSTM has three layers of 100 hidden units and a linear layer after the last layer. It has rectified linear activations after each layer. ",
+        "bbox": [
+            174,
+            195,
+            825,
+            335
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We informally explored several hyperparameters, varying the number of layers from 2 to 5, the hidden dimension from 50 to 100, and learning rates in $\\{ 1 \\bar { 0 } ^ { - 5 } , 3 \\times 1 0 ^ { - 5 } , 1 0 ^ { - \\bar { 4 } } , 3 \\times 1 0 ^ { - 4 } , 1 0 ^ { - 3 } , 3 \\times$ $1 0 ^ { - 3 } \\}$ . Though this is far from an exhaustive search, we found that the above hyperparameter settings work well. ",
+        "bbox": [
+            174,
+            342,
+            825,
+            398
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "B QUANTITATIVE ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            419,
+            426,
+            435
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/93db9022d82adca92d708a5b8c1a9cfe55d505b3ef4fbe385a1fb705c42737b4.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=11>Experiments      Train - Test      LSTM             NP             NPE-NN            NPE</td></tr><tr><td rowspan=1 colspan=3>Prediction Task         4-4</td><td rowspan=1 colspan=1>2.177e-03</td><td rowspan=1 colspan=1>2.276e-02</td><td rowspan=1 colspan=1>1.822e-03</td><td rowspan=1 colspan=1>1.923e-02</td><td rowspan=1 colspan=1>2.684e-03</td><td rowspan=1 colspan=1>2.283e-02</td><td rowspan=1 colspan=1>2.469e-04</td><td rowspan=1 colspan=1>4.362e-03</td></tr><tr><td rowspan=1 colspan=3>Prediction Task Variable Mass    4-4</td><td rowspan=1 colspan=1>3.521e-03</td><td rowspan=1 colspan=1>2.725e-02</td><td rowspan=1 colspan=1>2.534e-03</td><td rowspan=1 colspan=1>1.829e-02</td><td rowspan=1 colspan=1>4.278e-03</td><td rowspan=1 colspan=1>2.562e-02</td><td rowspan=1 colspan=1>5.312e-04</td><td rowspan=1 colspan=1>6.379e-03</td></tr><tr><td rowspan=1 colspan=3>345-3</td><td rowspan=1 colspan=1>1.783e-03</td><td rowspan=1 colspan=1>1.872e-02</td><td rowspan=1 colspan=1>5.844e-04</td><td rowspan=1 colspan=1>8.118e-03</td><td rowspan=1 colspan=1>1.667e-03</td><td rowspan=1 colspan=1>1.700e-02</td><td rowspan=1 colspan=1>1.651e-04</td><td rowspan=1 colspan=1>3.523e-03</td></tr><tr><td rowspan=1 colspan=3>345-4</td><td rowspan=1 colspan=1>2.237e-03</td><td rowspan=1 colspan=1>2.336e-02</td><td rowspan=1 colspan=1>1.172e-03</td><td rowspan=1 colspan=1>1.329e-02</td><td rowspan=1 colspan=1>2.554e-03</td><td rowspan=1 colspan=1>2.222e-02</td><td rowspan=1 colspan=1>2.372e-04</td><td rowspan=1 colspan=1>4.508e-03</td></tr><tr><td rowspan=2 colspan=3>345-5Generalization Task345-6</td><td rowspan=1 colspan=1>2.839e-03</td><td rowspan=1 colspan=1>2.909e-02</td><td rowspan=1 colspan=1>1.944e-03</td><td rowspan=1 colspan=1>1.959e-02</td><td rowspan=1 colspan=1>3.543e-03</td><td rowspan=1 colspan=1>2.810e-02</td><td rowspan=1 colspan=1>3.069e-04</td><td rowspan=1 colspan=1>5.514e-03</td></tr><tr><td rowspan=1 colspan=1>3.757e-03</td><td rowspan=1 colspan=1>3.636e-02</td><td rowspan=1 colspan=1>2.897e-03</td><td rowspan=1 colspan=1>2.665e-02</td><td rowspan=1 colspan=1>4.542e-03</td><td rowspan=1 colspan=1>3.381e-02</td><td rowspan=1 colspan=1>4.066e-04</td><td rowspan=1 colspan=1>6.676e-03</td></tr><tr><td rowspan=2 colspan=3>345-7345-8</td><td rowspan=1 colspan=1>5.085e-03</td><td rowspan=1 colspan=1>4.546e-02</td><td rowspan=1 colspan=1>3.894e-03</td><td rowspan=1 colspan=1>3.395e-02</td><td rowspan=1 colspan=1>5.654e-03</td><td rowspan=1 colspan=1>3.944e-02</td><td rowspan=1 colspan=1>4.951e-04</td><td rowspan=1 colspan=1>7.858e-03</td></tr><tr><td rowspan=1 colspan=1>6.943e-03</td><td rowspan=1 colspan=1>5.595e-02</td><td rowspan=1 colspan=1>5.091e-03</td><td rowspan=1 colspan=1>4.182e-02</td><td rowspan=1 colspan=1>6.913e-03</td><td rowspan=1 colspan=1>4.604e-02</td><td rowspan=1 colspan=1>5.992e-04</td><td rowspan=1 colspan=1>9.174e-03</td></tr><tr><td rowspan=1 colspan=3>345-3</td><td rowspan=1 colspan=1>2.663e-03</td><td rowspan=1 colspan=1>2.218e-02</td><td rowspan=1 colspan=1>2.228e-03</td><td rowspan=1 colspan=1>1.638e-02</td><td rowspan=1 colspan=1>2.785e-03</td><td rowspan=1 colspan=1>1.913e-02</td><td rowspan=1 colspan=1>3.546e-04</td><td rowspan=1 colspan=1>4.790e-03</td></tr><tr><td rowspan=1 colspan=3>345-4</td><td rowspan=1 colspan=1>3.588e-03</td><td rowspan=1 colspan=1>2.784e-02</td><td rowspan=1 colspan=1>3.486e-03</td><td rowspan=1 colspan=1>2.375e-02</td><td rowspan=1 colspan=1>4.291e-03</td><td rowspan=1 colspan=1>2.563e-02</td><td rowspan=1 colspan=1>5.393e-04</td><td rowspan=1 colspan=1>6.215e-03</td></tr><tr><td rowspan=2 colspan=3>345-5Generalization Task Variable Mass345-6</td><td rowspan=1 colspan=1>4.719e-03</td><td rowspan=1 colspan=1>3.472e-02</td><td rowspan=1 colspan=1>4.918e-03</td><td rowspan=1 colspan=1>3.164e-02</td><td rowspan=1 colspan=1>5.848e-03</td><td rowspan=1 colspan=1>3.273e-02</td><td rowspan=1 colspan=1>6.983e-04</td><td rowspan=1 colspan=1>7.719e-03</td></tr><tr><td rowspan=1 colspan=1>345-6</td><td rowspan=1 colspan=1>6.389e-03</td><td rowspan=1 colspan=1>4.302e-02</td><td rowspan=1 colspan=1>6.733e-03</td><td rowspan=1 colspan=1>3.982e-02</td><td rowspan=1 colspan=1>7.927e-03</td><td rowspan=1 colspan=1>4.092e-02</td><td rowspan=1 colspan=1>9.414e-04</td><td rowspan=1 colspan=1>9.398e-03</td></tr><tr><td rowspan=1 colspan=2></td><td rowspan=2 colspan=2>345-7345-8</td><td rowspan=1 colspan=1>8.581e-03</td><td rowspan=1 colspan=1>5.276e-02</td><td rowspan=1 colspan=1>8.746e-03</td><td rowspan=1 colspan=1>4.853e-02</td><td rowspan=1 colspan=1>1.012e-02</td><td rowspan=1 colspan=1>4.998e-02</td><td rowspan=1 colspan=1>1.196e-03</td></tr><tr><td></td><td></td><td rowspan=1 colspan=1>1.153e-02</td><td rowspan=1 colspan=1>6.469e-02</td><td rowspan=1 colspan=1>1.086e-02</td><td rowspan=1 colspan=1>5.724e-02</td><td rowspan=1 colspan=1>1.244e-02</td><td rowspan=1 colspan=1>5.967e-02</td><td rowspan=1 colspan=1>1.592e-03</td><td rowspan=1 colspan=1>1.367e-02</td></tr><tr><td rowspan=1 colspan=3>OL-O</td><td rowspan=1 colspan=1>5.967e-03</td><td rowspan=1 colspan=1>5.546e-02</td><td rowspan=1 colspan=1>1.010e-03</td><td rowspan=1 colspan=1>1.358e-02</td><td rowspan=1 colspan=1>N/A</td><td rowspan=1 colspan=1>N/A</td><td rowspan=1 colspan=1>3.338e-04</td><td rowspan=1 colspan=1>5.921e-03</td></tr><tr><td rowspan=2 colspan=3>OL-LDifferent Scene ConfigurationsOL-U</td><td rowspan=1 colspan=1>8.658e-03</td><td rowspan=1 colspan=1>6.995e-02</td><td rowspan=1 colspan=1>2.680e-03</td><td rowspan=1 colspan=1>2.663e-02</td><td rowspan=1 colspan=1>N/A</td><td rowspan=1 colspan=1>N/A</td><td rowspan=1 colspan=1>7.117e-04</td><td rowspan=1 colspan=1>1.019e-02</td></tr><tr><td rowspan=1 colspan=1>1.083e-02</td><td rowspan=1 colspan=1>7.765e-02</td><td rowspan=1 colspan=1>4.152e-03</td><td rowspan=1 colspan=1>3.201e-02</td><td rowspan=1 colspan=1>N/A</td><td rowspan=1 colspan=1>N/A</td><td rowspan=1 colspan=1>8.193e-04</td><td rowspan=1 colspan=1>1.141e-02</td></tr><tr><td rowspan=1 colspan=3>OL--</td><td rowspan=1 colspan=1>1.201e-02</td><td rowspan=1 colspan=1>7.947e-02</td><td rowspan=1 colspan=1>6.206e-03</td><td rowspan=1 colspan=1>3.565e-02</td><td rowspan=1 colspan=1>N/A</td><td rowspan=1 colspan=1>N/A</td><td rowspan=1 colspan=1>1.605e-03</td><td rowspan=1 colspan=1>1.482e-02</td></tr></table>",
+        "bbox": [
+            173,
+            457,
+            825,
+            702
+        ],
+        "page_idx": 14
+    }
+]

parse/train/HkwZSG-CZ/HkwZSG-CZ.md

@@ -0,0 +1,463 @@
+# BREAKING THE SOFTMAX BOTTLENECK:A HIGH-RANK RNN LANGUAGE MODEL
+
+Zhilin Yang∗, Zihang Dai∗, Ruslan Salakhutdinov, William W. Cohen
+
+School of Computer Science   
+Carnegie Mellon University   
+{zhiliny,dzihang,rsalakhu,wcohen}@cs.cmu.edu
+
+# ABSTRACT
+
+We formulate language modeling as a matrix factorization problem, and show that the expressiveness of Softmax-based models (including the majority of neural language models) is limited by a Softmax bottleneck. Given that natural language is highly context-dependent, this further implies that in practice Softmax with distributed word embeddings does not have enough capacity to model natural language. We propose a simple and effective method to address this issue, and improve the state-of-the-art perplexities on Penn Treebank and WikiText-2 to 47.69 and 40.68 respectively. The proposed method also excels on the large-scale 1B Word dataset, outperforming the baseline by over 5.6 points in perplexity.1
+
+# 1 INTRODUCTION
+
+As a fundamental task in natural language processing, statistical language modeling has gone through significant development from traditional Ngram language models to neural language models in the last decade (Bengio et al., 2003; Mnih & Hinton, 2007; Mikolov et al., 2010). Despite the huge variety of models, as a density estimation problem, language modeling mostly relies on a universal auto-regressive factorization of the joint probability and then models each conditional factor using different approaches. Specifically, given a corpus of tokens $\mathbf { X } = ( X _ { 1 } , \ldots , X _ { T } )$ , the joint probability $P ( \mathbf { X } )$ factorizes as ${ \begin{array} { r } { { \bar { P } } ( \mathbf { X } ) = { \dot { \prod } } _ { t } { \bar { P } } ( X _ { t } \mid X _ { < t } ^ { - } ) = \prod _ { t } P ( X _ { t } \mid C _ { t } ) } \end{array} }$ , where $C _ { t } = X _ { < t }$ is referred to as the context of the conditional probability hereafter.
+
+Based on the factorization, recurrent neural networks (RNN) based language models achieve stateof-the-art results on various benchmarks (Merity et al., 2017; Melis et al., 2017; Krause et al., 2017). A standard approach is to use a recurrent network to encode the context into a fixed size vector, which is then multiplied by the word embeddings (Inan et al., 2016; Press & Wolf, 2017) using dot product to obtain the logits. The logits are consumed by the Softmax function to give a categorical probability distribution over the next token. In spite of the expressiveness of RNNs as universal approximators (Schäfer & Zimmermann, 2006), an unclear question is whether the combination of dot product and Softmax is capable of modeling the conditional probability, which can vary dramatically with the change of the context.
+
+In this work, we study the expressiveness of the aforementioned Softmax-based recurrent language models from a perspective of matrix factorization. We show that learning a Softmax-based recurrent language model with the standard formulation is essentially equivalent to solving a matrix factorization problem. More importantly, due to the fact that natural language is highly context-dependent, the matrix to be factorized can be high-rank. This further implies that standard Softmax-based language models with distributed (output) word embeddings do not have enough capacity to model natural language. We call this the Softmax bottleneck.
+
+We propose a simple and effective method to address the Softmax bottleneck. Specifically, we introduce discrete latent variables into a recurrent language model, and formulate the next-token probability distribution as a Mixture of Softmaxes (MoS). Mixture of Softmaxes is more expressive than Softmax and other surrogates considered in prior work. Moreover, we show that MoS learns matrices that have much larger normalized singular values and thus much higher rank than Softmax and other baselines on real-world datasets.
+
+We evaluate our proposed approach on standard language modeling benchmarks. MoS substantially improves over the current state-of-the-art results on benchmarks, by up to 3.6 points in terms of perplexity, reaching perplexities 47.69 on Penn Treebank and 40.68 on WikiText-2. We further apply MoS to a dialog dataset and show improved performance over Softmax and other baselines.
+
+Our contribution is two-fold. First, we identify the Softmax bottleneck by formulating language modeling as a matrix factorization problem. Second, we propose a simple and effective method that substantially improves over the current state-of-the-art results.
+
+# 2 LANGUAGE MODELING AS MATRIX FACTORIZATION
+
+As discussed in Section 1, with the autoregressive factorization, language modeling can be reduced to modeling the conditional distribution of the next token $x$ given the context $c$ . Though one might argue that a natural language allows an infinite number of contexts due to its compositionality (Pinker, 1994), we proceed with our analysis by considering a finite set of possible contexts. The unboundedness of natural language does not affect our conclusions, which will be discussed later.
+
+We consider a natural language as a finite set of pairs of a context and its conditional next-token distribution2 ${ \mathcal { L } } ~ = ~ \{ ( c _ { 1 } , { \bar { P } } ^ { * } ( { \bar { X } } | c _ { 1 } ) ) , \cdots , ( c _ { N } , { \bar { P ^ { * } } } ( X | c _ { N } ) ) \}$ , where $N$ is the number of possible contexts. We assume $P ^ { * } > 0$ everywhere to account for errors and flexibility in natural language. Let $\{ x _ { 1 } , x _ { 2 } , \cdot \cdot \cdot , x _ { M } \}$ denote a set of $M$ possible tokens in the language $\mathcal { L }$ . The objective of a language model is to learn a model distribution $P _ { \theta } ( X | C )$ parameterized by $\theta$ to match the true data distribution $P ^ { * } ( X | C )$ .
+
+In this work, we study the expressiveness of the parametric model class $P _ { \theta } ( X | C )$ . In other words, we are asking the following question: given a natural language $\mathcal { L }$ , does there exist a parameter $\theta$ such that $P _ { \theta } ( X | c ) = P ^ { * } ( X | c )$ for all $c$ in $\mathcal { L }$ ?
+
+We start by looking at a Softmax-based model class since it is widely used.
+
+# 2.1 SOFTMAX
+
+The majority of parametric language models use a Softmax function operating on a context vector (or hidden state) $\mathbf { h } _ { c }$ and a word embedding ${ \bf w } _ { x }$ to define the conditional distribution $P _ { \theta } ( x | c )$ . More specifically, the model distribution is usually written as
+
+$$
+P _ { \theta } ( x | c ) = \frac { \exp \mathbf { h } _ { c } ^ { \top } \mathbf { w } _ { x } } { \sum _ { x ^ { \prime } } \exp \mathbf { h } _ { c } ^ { \top } \mathbf { w } _ { x ^ { \prime } } }
+$$
+
+where $\mathbf { h } _ { c }$ is a function of $c$ , and ${ \bf w } _ { x }$ is a function of $x$ . Both functions are parameterized by $\theta$ . Both the context vector $\mathbf { h } _ { c }$ and the word embedding ${ \bf w } _ { x }$ have the same dimension $d$ . The dot product $\mathbf { h } _ { c } ^ { \top } \mathbf { w } _ { x }$ is called a logit.
+
+To help discuss the expressiveness of Softmax, we define three matrices:
+
+$$
+\mathbf { I } _ { \theta } = { \left[ \begin{array} { l } { \mathbf { h } _ { c _ { 1 } } ^ { \mathsf { T } } } \\ { \mathbf { h } _ { c _ { 2 } } ^ { \mathsf { T } } } \\ { \cdots } \\ { \mathbf { h } _ { c _ { N } } ^ { \mathsf { T } } } \end{array} \right] } ; \mathbf { W } _ { \theta } = { \left[ \begin{array} { l } { \mathbf { w } _ { x _ { 1 } } ^ { \mathsf { T } } } \\ { \mathbf { w } _ { x _ { 2 } } ^ { \mathsf { T } } } \\ { \cdots } \\ { \mathbf { w } _ { x _ { M } } ^ { \mathsf { T } } } \end{array} \right] } ; \mathbf { A } = { \left[ \begin{array} { l l l l } { \log P ^ { * } ( x _ { 1 } | c _ { 1 } ) , } & { \log P ^ { * } ( x _ { 2 } | c _ { 1 } ) } & { \cdots } & { \log P ^ { * } ( x _ { M } | c _ { 1 } ) } \\ { \log P ^ { * } ( x _ { 1 } | c _ { 2 } ) , } & { \log P ^ { * } ( x _ { 2 } | c _ { 2 } ) } & { \cdots } & { \log P ^ { * } ( x _ { M } | c _ { 2 } ) } \\ { \vdots } & { \vdots } & { \ddots } & { \vdots } \\ { \log P ^ { * } ( x _ { 1 } | c _ { N } ) , } & { \log P ^ { * } ( x _ { 2 } | c _ { N } ) } & { \cdots } & { \log P ^ { * } ( x _ { M } | c _ { N } ) } \end{array} \right] }
+$$
+
+where $\mathbf { H } _ { \theta } \in \mathbb { R } ^ { N \times d }$ , $\mathbf { W } _ { \theta } \in \mathbb { R } ^ { M \times d }$ , $\mathbf { A } \in \mathbb { R } ^ { N \times M }$ , and the rows of $\mathbf { H } _ { \theta }$ , $\mathbf { W } _ { \theta }$ , and A correspond to context vectors, word embeddings, and log probabilities of the true data distribution respectively. We use the subscript $\theta$ because $( { \bar { \mathbf { H } } } _ { \theta } , \mathbf { W } _ { \theta } )$ is effectively a function indexed by the parameter $\theta$ , from the joint function family $\mathcal { U }$ . Concretely, $\mathbf { H } _ { \theta }$ is implemented as deep neural networks, such as a recurrent network, while $\mathbf { W } _ { \theta }$ is instantiated as an embedding lookup.
+
+We further specify a set of matrices formed by applying row-wise shift to A
+
+$$
+F ( \mathbf { A } ) = \{ \mathbf { A } + \mathbf { A } \mathbf { J } _ { N , M } | \mathbf { A } { \mathrm { ~ i s ~ d i a g o n a l ~ a n d ~ } } \mathbf { \Lambda } \mathbf { A } \in \mathbb { R } ^ { N \times N } \} ,
+$$
+
+where ${ \mathbf { J } } _ { N , M }$ is an all-ones matrix with size $N \times M$ . Essentially, the row-wise shift operation adds an arbitrary real number to each row of A. Thus, $F ( \mathbf { A } )$ is an infinite set. Notably, the set $F ( \mathbf { A } )$ has two important properties (see Appendix A for the proof), which are key to our analysis.
+
+Property 1. For any matrix $\mathbf { A } ^ { \prime }$ , $\mathbf { A } ^ { \prime } \in F ( \mathbf { A } )$ if and only if Softmax $\ v { \Omega } _ { \hat { \mathbf { \theta } } } ( \mathbf { A } ^ { \prime } ) = \ v { P } ^ { * }$ . In other words, $F ( \mathbf { A } )$ defines the set of all possible logits that correspond to the true data distribution.
+
+Property 2. For any $\mathbf { A } _ { 1 } \neq \mathbf { A } _ { 2 } \in F ( \mathbf { A } )$ , $| r a n k ( \mathbf { A } _ { 1 } ) - r a n k ( \mathbf { A } _ { 2 } ) | \leq 1$ . In other words, all matrices in $F ( \mathbf { A } )$ have similar ranks, with the maximum rank difference being $^ { l }$ .
+
+Based on the Property 1 of $F ( \mathbf { A } )$ , we immediately have the following Lemma.
+
+Lemma 1. Given a model parameter $\theta$ , $\mathbf { H } _ { \theta } \mathbf { W } _ { \theta } ^ { \top } \in F ( \mathbf { A } )$ if and only if $P _ { \theta } ( X | c ) = P ^ { * } ( X | c )$ for all c in $\mathcal { L }$ .
+
+Now the expressiveness question becomes: does there exist a parameter $\theta$ and $\mathbf { A } ^ { \prime } \in F ( \mathbf { A } )$ such that
+
+$$
+\mathbf { H } _ { \theta } \mathbf { W } _ { \theta } ^ { \top } = \mathbf { A } ^ { \prime } .
+$$
+
+This is essentially a matrix factorization problem. We want the model to learn matrices $\mathbf { H } _ { \theta }$ and $\mathbf { W } _ { \theta }$ that are able to factorize some matrix $\mathbf { A } ^ { \prime } \in F ( \mathbf { A } )$ . First, note that for a valid factorization to exist, the rank of $\mathbf { H } _ { \theta } \mathbf { W } _ { \theta } ^ { \top }$ has to be at least as large as the rank of $\mathbf { A } ^ { \prime }$ . Further, since $\mathbf { H } _ { \theta } \in \mathbb { R } ^ { N \times d }$ and $\mathbf { W } _ { \theta } \in \mathbb { R } ^ { M \times d }$ , the rank of $\mathbf { H } _ { \theta } \mathbf { W } _ { \theta } ^ { \top }$ is strictly upper bounded by the embedding size $d$ . As a result, if $d \ge \mathrm { r a n k } ( \mathbf { A } ^ { \prime } )$ , a universal approximator can theoretically recover $\mathbf { A } ^ { \prime }$ . However, if $d < \mathrm { r a n k } ( { \bf A } ^ { \prime } )$ , no matter how expressive the function family $\mathcal { U }$ is, no $( \mathbf { H } _ { \theta } , \mathbf { W } _ { \theta } )$ can even theoretically recover $\mathbf { A } ^ { \prime }$ . We summarize the reasoning above as follows (see Appendix A for the proof).
+
+Proposition 1. Given that the function family $\mathcal { U }$ is a universal approximator, there exists a parameter $\theta$ such that $P _ { \theta } ( X | c ) = P ^ { * } ( X | c ) .$ for all $c$ in $\mathcal { L }$ if and only if $d \geq \mathrm { m i n } _ { \mathbf { A } ^ { \prime } \in F ( \mathbf { A } ) } r a n k ( \mathbf { A } ^ { \prime } )$ .
+
+Combining Proposition 1 with the Property 2 of $F ( \mathbf { A } )$ , we are now able to state the Softmax Bottleneck problem formally.
+
+Corollary 1. (Softmax Bottleneck) If $d < r a n k ( \mathbf { A } ) - 1$ , for any function family $\mathcal { U }$ and any model parameter $\theta$ , there exists a context $c$ in $\mathcal { L }$ such that $P _ { \theta } ( X | c ) \neq P ^ { * } ( X | c )$ .
+
+The above corollary indicates that when the dimension $d$ is too small, Softmax does not have the capacity to express the true data distribution. Clearly, this conclusion is not restricted to a finite language $\mathcal { L }$ . When $\mathcal { L }$ is infinite, one can always take a finite subset and the Softmax bottleneck still exists. Next, we discuss why the Softmax bottleneck is an issue by presenting our hypothesis that A is high-rank for natural language.
+
+# 2.2 HYPOTHESIS: NATURAL LANGUAGE IS HIGH-RANK
+
+We hypothesize that for a natural language $\mathcal { L }$ , the log probability matrix A is a high-rank matrix. It is difficult (if possible) to rigorously prove this hypothesis since we do not have access to the true data distribution of a natural language. However, it is suggested by the following intuitive reasoning and empirical observations:
+
+• Natural language is highly context-dependent (Mikolov & Zweig, 2012). For example, the token “north” is likely to be followed by “korea” or “korean” in a news article on international politics, which however is unlikely in a textbook on U.S. domestic history. We hypothesize that such subtle context dependency should result in a high-rank matrix A. • If A is low-rank, it means humans only need a limited number (e.g. a few hundred) of bases, and all semantic meanings can be created by (potentially) negating and (weighted) averaging these bases. However, it is hard to find a natural concept in linguistics and cognitive science that corresponds to such bases, which questions the existence of such bases. For example, semantic meanings might not be those bases since a few hundred meanings may not be enough to cover everyday meanings, not to mention niche meanings in specialized domains. • Empirically, our high-rank language model outperforms conventional low-rank language models on several benchmarks, as shown in Section 3. We also provide evidences in Section 3.3 to support our hypothesis that learning a high-rank language model is important.
+
+Given the hypothesis that natural language is high-rank, it is clear that the Softmax bottleneck limits the expressiveness of the models. In practice, the embedding dimension $d$ is usually set at the scale of $1 0 ^ { 2 }$ , while the rank of A can possibly be as high as $M$ (at the scale of $1 0 ^ { 5 }$ ), which is orders of magnitude larger than $d$ . Softmax is effectively learning a low-rank approximation to $\mathbf { A }$ , and our experiments suggest that such approximation loses the ability to model context dependency, both qualitatively and quantitatively (Cf. Section 3).
+
+# 2.3 EASY FIXES?
+
+Identifying the Softmax bottleneck immediately suggests some possible “easy fixes”. First, as considered by a lot of prior work, one can employ a non-parametric model, namely an Ngram model (Kneser & Ney, 1995). Ngram models are not constrained by any parametric forms so it can universally approximate any natural language, given enough parameters. Second, it is possible to increase the dimension $d$ (e.g., to match $M$ ) so that the model can express a high-rank matrix A.
+
+However, these two methods increase the number of parameters dramatically, compared to using a low-dimensional Softmax. More specifically, an Ngram needs $( N \times M )$ parameters in order to express $\mathbf { A }$ , where $N$ is potentially unbounded. Similarly, a high-dimensional Softmax requires $( M \times$ $M$ ) parameters for the word embeddings. Increasing the number of model parameters easily leads to overfitting. In past work, Kneser & Ney (1995) used back-off to alleviate overfitting. Moreover, as deep learning models were tuned by extensive hyper-parameter search, increasing the dimension $d$ beyond several hundred is not helpful3 (Merity et al., 2017; Melis et al., 2017; Krause et al., 2017).
+
+Clearly there is a tradeoff between expressiveness and generalization on language modeling. Naively increasing the expressiveness hurts generalization. Below, we introduce an alternative approach that increases the expressiveness without exploding the parametric space.
+
+# 2.4 MIXTURE OF SOFTMAXES: A HIGH-RANK LANGUAGE MODEL
+
+We propose a high-rank language model called Mixture of Softmaxes (MoS) to alleviate the Softmax bottleneck issue. MoS formulates the conditional distribution as
+
+$$
+P _ { \theta } ( x | c ) = \sum _ { k = 1 } ^ { K } \pi _ { c , k } { \frac { \exp \mathbf { h } _ { c , k } ^ { \top } \mathbf { w } _ { x } } { \sum _ { x ^ { \prime } } \exp \mathbf { h } _ { c , k } ^ { \top } \mathbf { w } _ { x ^ { \prime } } } } ; ~ { \mathrm { s . t . } } ~ \sum _ { k = 1 } ^ { K } \pi _ { c , k } = 1
+$$
+
+where $\pi _ { c , k }$ is the prior or mixture weight of the $k$ -th component, and $\mathbf { h } _ { c , k }$ is the $k$ -th context vector associated with context $c$ . In other words, MoS computes $K$ Softmax distributions and uses a weighted average of them as the next-token probability distribution. Similar to prior work on recurrent language modeling (Merity et al., 2017; Melis et al., 2017; Krause et al., 2017), we first apply a stack of recurrent layers on top of $\mathbf { X }$ to obtain a sequence of hidden states $( \mathbf { g } _ { 1 } , \cdots , \mathbf { g } _ { T } )$ . The prior and the context vector for context $c _ { t }$ are parameterized as $\begin{array} { r } { \pi _ { c _ { t } , k } = \frac { \exp \mathbf { w } _ { \pi , k } ^ { \top } \mathbf { g } _ { t } } { \sum _ { k ^ { \prime } = 1 } ^ { K } \exp \mathbf { w } _ { \pi , k ^ { \prime } } ^ { \top } \mathbf { g } _ { t } } } \end{array}$ and $\mathbf { h } _ { c _ { t } , k } = \operatorname { t a n h } ( \mathbf { W } _ { h , k } \mathbf { g } _ { t } )$ where ${ \bf w } _ { \pi , k }$ and ${ \bf W } _ { h , k }$ are model parameters.
+
+Our method is simple and easy to implement, and has the following advantages:
+
+• Improved expressiveness (compared to Softmax). MoS is theoretically more (or at least equally) expressive compared to Softmax given the same dimension $d$ . This can be seen by the fact that MoS with $K = 1$ is reduced to Softmax. More importantly, MoS effectively approximates A by
+
+$$
+\hat { \mathbf { A } } _ { \mathrm { M o S } } = \log \sum _ { k = 1 } ^ { K } \mathbf { \Pi } \cdot \exp ( \mathbf { H } _ { \theta , k } \mathbf { W } _ { \theta } ^ { \top } )
+$$
+
+where $\mathbf { I I } _ { k }$ is an $( N \times N )$ diagonal matrix with elements being the prior $\pi _ { c , k }$ . Because $\hat { \bf A } _ { \mathrm { M o S } }$ is a nonlinear function $( l o g \_ s u m \_ e x p )$ of the context vectors and the word embeddings, $\hat { \bf A } _ { \mathrm { M o S } }$ can be arbitrarily high-rank. As a result, MoS does not suffer from the rank limitation, compared to Softmax.
+
+• Improved generalization (compared to Ngram). Ngram models and high-dimensional Softmax (Cf. Section 2.3) improve the expressiveness but do not generalize well. In contrast, MoS does not have a generalization issue due to the following reasons. First, MoS defines the following generative process: a discrete latent variable $k$ is first sampled from $\{ 1 , \cdots , K \}$ , and then the next token is sampled based on the $k$ -th Softmax component. By doing so we introduce an inductive bias that the next token is generated based on a latent discrete decision (e.g., a topic), which is often safe in language modeling (Blei et al., 2003). Second, since $\hat { \bf A } _ { \mathrm { M o S } }$ is defined by a nonlinear function and not restricted by the rank bottleneck, in practice it is possible to reduce $d$ to compensate for the increase of model parameters brought by the mixture structure. As a result, MoS has a similar model size compared to Softmax and thus is not prone to overfitting.
+
+# 2.5 MIXTURE OF CONTEXTS: A LOW-RANK BASELINE
+
+Another possible approach is to directly mix the context vectors (or logits) before taking the Softmax, rather than mixing the probabilities afterwards as in MoS. Specifically, the conditional distribution is parameterized as
+
+$$
+P _ { \theta } ( x | c ) = \frac { \exp { \left( \sum _ { k = 1 } ^ { K } \pi _ { c , k } \mathbf { h } _ { c , k } \right) ^ { \top } \mathbf { w } _ { x } } } { \sum _ { x ^ { \prime } } \exp { \left( \sum _ { k = 1 } ^ { K } \pi _ { c , k } \mathbf { h } _ { c , k } \right) ^ { \top } \mathbf { w } _ { x ^ { \prime } } } } = \frac { \exp { \left( \sum _ { k = 1 } ^ { K } \pi _ { c , k } \mathbf { h } _ { c , k } ^ { \top } \mathbf { w } _ { x } \right) } } { \sum _ { x ^ { \prime } } \exp { \left( \sum _ { k = 1 } ^ { K } \pi _ { c , k } \mathbf { h } _ { c , k } ^ { \top } \mathbf { w } _ { x ^ { \prime } } \right) } } ,
+$$
+
+where $\mathbf { h } _ { c , k }$ and $\pi _ { c , k }$ share the same parameterization as in MoS. Despite its superficial similarity to MoS, this model, which we refer to as mixture of contexts (MoC), actually suffers from the same rank limitation problem as Softmax. This can be easily seen by defining $\begin{array} { r } { \mathbf { h } _ { \mathrm { ~ c ~ } } ^ { \prime } = \sum _ { k = 1 } ^ { K } \pi _ { c , k } \mathbf { h } _ { c , k } } \end{array}$ , which turns the MoC parameterization (2) into Pθ(x|c) = exp h P c wx0 exp h0>w 0 . Note that this is equivalent to the Softmax parameterization (1). Thus, performing mixture in the feature space can only make the function family $\mathcal { U }$ more expressive, but does not change the fact that the rank of $\mathbf { H } _ { \theta } \mathbf { W } _ { \theta } ^ { \dagger }$ is upper bounded by the embedding dimension $d$ . In our experiments, we implement MoC as a baseline and compare it experimentally to MoS.
+
+# 3 EXPERIMENTS
+
+# 3.1 MAIN RESULTS
+
+We conduct a series of experiments with the following settings:
+
+• Following previous work (Krause et al., 2017; Merity et al., 2017; Melis et al., 2017), we evaluate the proposed MoS model on two widely used language modeling datasets, namely Penn Treebank (PTB) (Mikolov et al., 2010) and WikiText-2 (WT2) (Merity et al., 2016) based on perplexity. For fair comparison, we closely follow the regularization and optimization techniques introduced by Merity et al. (2017). We heuristically and manually search hyper-parameters for MoS based on the validation performance while limiting the model size (see Appendix B.1 for our hyper-parameters).
+
+• To investigate whether the effectiveness of MoS can be extended to even larger datasets, we conduct an additional language modeling experiment on the 1B Word dataset (Chelba et al., 2013). Specifically, we lower-case the text and choose the top 100K tokens as the vocabulary. A standard neural language model with 2 layers of LSTMs followed by a Softmax output layer is used as the baseline. Again, the network size of MoS is adjusted to ensure a comparable number of parameters. Notably, dropout was not used, since we found it not helpful to either model (see Appendix B.2 for more details).
+
+• To show that the MoS is a generic structure that can be used to model other context-dependent distributions, we additionally conduct experiments in the dialog domain. We use the Switchboard dataset (Godfrey & Holliman, 1997) preprocessed by Zhao et al. $( 2 0 1 7 ) ^ { 4 }$ to train a Seq2Seq (Sutskever et al., 2014) model with MoS added to the decoder RNN. Then, a $\mathtt { S e q 2 S e q }$ model using Softmax and another one augmented by MoC with comparable parameter sizes are used as baselines. For evaluation, we include both the perplexity and the precision/recall of Smoothed Sentence-level BLEU, as suggested by Zhao et al. (2017). When generating responses, we use beam search with beam size 10, restrict the maximum length to 30, and retain the top-5 responses.
+
+Table 1: Single model perplexity on validation and test sets on Penn Treebank. Baseline results are obtained from Merity et al. (2017) and Krause et al. (2017). $^ \dagger$ indicates using dynamic evaluation.   
+
+<table><tr><td>Model</td><td>#Param</td><td>Validation</td><td>Test</td></tr><tr><td>Mikolov &amp; Zweig (2012)-RNN-LDA +KN-5 + cache</td><td>9M</td><td>=</td><td>92.0</td></tr><tr><td>Zaremba et al. (2014)-LSTM</td><td>20M</td><td>86.2</td><td>82.7</td></tr><tr><td>Gal &amp; Ghahramani (2016)- Variational LSTM(MC)</td><td>20M</td><td>1</td><td>78.6</td></tr><tr><td>Kim etal.(2016)-CharCNN</td><td>19M</td><td>-</td><td>78.9</td></tr><tr><td>Merity et al. (2016)- Pointer Sentinel-LSTM</td><td>21M</td><td>72.4</td><td>70.9</td></tr><tr><td>Grave et al. (2016)-LSTM + continuous cache pointert</td><td>1</td><td>-</td><td>72.1</td></tr><tr><td>Inan et al. (2016)-Tied Variational LSTM+augmented loss</td><td>24M</td><td>75.7</td><td>73.2</td></tr><tr><td>Zilly et al. (2016)- Variational RHN</td><td>23M</td><td>67.9</td><td>65.4</td></tr><tr><td>Zoph &amp; Le (2016)-NAS Cell</td><td>25M</td><td>1</td><td>64.0</td></tr><tr><td>Melis et al. (2017)-2-layer skip connection LSTM</td><td>24M</td><td>60.9</td><td>58.3</td></tr><tr><td>Merity et al.(2017)-AWD-LSTM w/o finetune</td><td>24M</td><td>60.7</td><td>58.8</td></tr><tr><td>Merity et al. (2017) - AWD-LSTM</td><td>24M</td><td>60.0</td><td>57.3</td></tr><tr><td>Ours-AWD-LSTM-MoS w/o finetune</td><td>22M</td><td>58.08</td><td>55.97</td></tr><tr><td>Ours-AWD-LSTM-MoS</td><td>22M</td><td>56.54</td><td>54.44</td></tr><tr><td>Merity et al. (2017)- AWD-LSTM + continuous cache pointert</td><td>24M</td><td>53.9</td><td>52.8</td></tr><tr><td>Krause et al. (2O17)- AWD-LSTM + dynamic evaluation+</td><td>24M</td><td>51.6</td><td>51.1</td></tr><tr><td>Ours - AWD-LSTM-MoS + dynamic evaluation+</td><td>22M</td><td>48.33</td><td>47.69</td></tr></table>
+
+Table 2: Single model perplexity over WikiText-2. Baseline results are obtained from Merity et al. (2017) and Krause et al. (2017). $^ \dagger$ indicates using dynamic evaluation.   
+
+<table><tr><td>Model</td><td>#Param</td><td>Validation</td><td>Test</td></tr><tr><td>Inan et al. (2016)- Variational LSTM+ augmented loss</td><td>28M</td><td>91.5</td><td>87.0</td></tr><tr><td>Grave et al. (2016)-LSTM + continuous cache pointer†</td><td>1</td><td>1</td><td>68.9</td></tr><tr><td>Melis et al. (2017) -2-layer skip connection LSTM</td><td>24M</td><td>69.1</td><td>65.9</td></tr><tr><td>Merity et al. (2017)-AWD-LSTM w/o finetune</td><td>33M</td><td>69.1</td><td>66.0</td></tr><tr><td>Merity et al. (2017)- AWD-LSTM</td><td>33M</td><td>68.6</td><td>65.8</td></tr><tr><td>Ours-AWD-LSTM-MoS w/o finetune</td><td>35M</td><td>66.01</td><td>63.33</td></tr><tr><td>Ours-AWD-LSTM-MoS</td><td>35M</td><td>63.88</td><td>61.45</td></tr><tr><td>Merity et al. (2017)- AWD-LSTM + continuous cache pointer †</td><td>33M</td><td>53.8</td><td>52.0</td></tr><tr><td>Krause et al. (2017)- AWD-LSTM+ dynamic evaluation+</td><td>33M</td><td>46.4</td><td>44.3</td></tr><tr><td>Ours- AWD-LSTM-MoS + dynamical evaluation†</td><td>35M</td><td>42.41</td><td>40.68</td></tr></table>
+
+The language modeling results on PTB and WT2 are presented in Table 1 and Table 2 respectively. With a comparable number of parameters, MoS outperforms all baselines with or without dynamic evaluation, and substantially improves over the current state of the art, by up to 3.6 points in perplexity.
+
+<table><tr><td>Model</td><td>#Param</td><td>Train</td><td>Validation</td><td>Test</td></tr><tr><td>Softmax</td><td>119M</td><td>41.47</td><td>43.86</td><td>42.77</td></tr><tr><td>MoS</td><td>113M</td><td>36.39</td><td>38.01</td><td>37.10</td></tr></table>
+
+Table 3: Perplexity comparison on 1B word dataset. Train perplexity is the average of the last 4,000 updates.
+
+The improvement on the large-scale dataset is even more significant. As shown in Table 3, MoS outperforms Softmax by over 5.6 points in perplexity. It suggests the effectiveness of MoS is not limited to small datasets where many regularization techniques are used. Note that with limited computational resources, we didn’t tune the hyper-parameters for MoS.
+
+Table 4: Evaluation scores on Switchboard.   
+
+<table><tr><td rowspan="2">Model</td><td rowspan="2">Perplexity</td><td colspan="2">BLEU-1</td><td colspan="2">BLEU-2</td><td colspan="2">BLEU-3</td><td colspan="2">BLEU-4</td></tr><tr><td>prec</td><td>recall</td><td>prec</td><td>recall</td><td>prec</td><td>recall</td><td>prec</td><td>recall</td></tr><tr><td>Seq2Seq-Softmax</td><td>34.657</td><td>0.249</td><td>0.188</td><td>0.193</td><td>0.151</td><td>0.168</td><td>0.133</td><td>0.141</td><td>0.111</td></tr><tr><td>Seq2Seq-MoC</td><td>33.291</td><td>0.259</td><td>0.198</td><td>0.202</td><td>0.159</td><td>0.176</td><td>0.140</td><td>0.148</td><td>0.117</td></tr><tr><td>Seq2Seq-MoS</td><td>32.727</td><td>0.272</td><td>0.206</td><td>0.213</td><td>0.166</td><td>0.185</td><td>0.146</td><td>0.157</td><td>0.123</td></tr></table>
+
+Further, the experimental results on Switchboard are summarized in Table $4 ^ { 5 }$ . Clearly, on all metrics, MoS outperforms MoC and Softmax, showing its general effectiveness.
+
+# 3.2 ABLATION STUDY
+
+To further verify the improvement shown above does come from the MoS structure rather than adding another hidden layer or finding a particular set of hyper-parameters, we conduct an ablation study on both PTB and WT2. Firstly, we compare MoS with an MoC architecture with the same number of layers, hidden sizes, and embedding sizes, which thus has the same number of parameters. In addition, we adopt the hyper-parameters used to obtain the best MoS model (denoted as MoS hyper-parameters), and train a baseline AWD-LSTM. To avoid distractive factors and save computational resources, all ablative experiments excluded the use of finetuing and dynamic evaluation.
+
+The results are shown in Table 5. Compared to the vanilla AWD-LSTM, though being more expressive, MoC performs only better on PTB, but worse on WT2. It suggests that simply adding another hidden layer or employing a mixture structure in the feature space does not guarantee a better performance. On the other hand, training AWD-LSTM using MoS hyper-parameters severely hurts the performance, which rules out hyper-parameters as the main source of improvement.
+
+Table 5: Ablation study on Penn Treebank and WikiText-2 without finetuning or dynamical evaluation.   
+
+<table><tr><td></td><td colspan="2">PTB</td><td colspan="2">WT2</td></tr><tr><td>Model</td><td>Validation</td><td>Test</td><td>Validation</td><td>Test</td></tr><tr><td>AWD-LSTM-MoS</td><td>58.08</td><td>55.97</td><td>66.01</td><td>63.33</td></tr><tr><td>AWD-LSTM-MoC</td><td>59.82</td><td>57.55</td><td>68.76</td><td>65.98</td></tr><tr><td>AWD-LSTM (Merity et al. (2017) hyper-parameters)</td><td>61.49</td><td>58.95</td><td>68.73</td><td>65.40</td></tr><tr><td>AWD-LSTM (MoS hyper-parameters)</td><td>78.86</td><td>74.86</td><td>72.73</td><td>69.18</td></tr></table>
+
+# 3.3 VERIFY THE ROLE OF RANK
+
+While the study above verifies that MoS is the key to achieving the state-of-the-art performance, it is still not clear whether the superiority of MoS comes from its potential high rank, as suggested by our theoretical analysis in Section 2. In the sequel, we take steps to verify this hypothesis.
+
+• Firstly, we verify that MoS does induce a high-rank log-probability matrix empirically, while MoC and Softmax fail. On the validation or test set of PTB with tokens $\mathbf { X } = \{ X _ { 1 } , \ldots , \dot { X } _ { T } \}$ , we compute the log probabilities Then, for each model, we st $\{ \log P ( X _ { i } \mid X _ { < i } ) \in \mathbb { R } ^ { M } \} _ { t = 1 } ^ { T }$ for each rs into a ing all three models.matrix, resulting in $T$ $T \times M$ $\hat { \bf A } _ { \mathrm { M o S } }$ , $\hat { \bf A } _ { \mathrm { M o C } }$ and $\hat { \mathbf { A } } _ { \mathrm { S o f t m a x } }$ . Theoretically, the number of non-zero singular values of a matrix is equal to its rank. However, performing singular value decomposition of real valued matrices using numerical approaches often encounter roundoff errors. Hence, we adopt the expected roundoff error suggested by Press (2007) when estimating the ranks of $\hat { \bf A } _ { \mathrm { M o S } }$ , $\begin{array} { r } { \hat { \bf A } _ { \mathrm { M o C } } } \end{array}$ and $\bar { \mathbf { A } } _ { \mathrm { S o f t m a x } }$ . The estimated ranks are shown in Table 6. As predicted by our theoretical analysis, the matrix ranks induced by Softmax and MoC are both limited by the corresponding embedding sizes. By contrast, the matrix rank obtained from MoS does not suffer from this constraint, almost reaching full rank ( $M = 1 0 0 0 0$ ). In appendix C.1, we give additional evidences for the higher rank of MoS.
+
+<table><tr><td>Model</td><td>Validation</td><td>Test</td></tr><tr><td>Softmax</td><td>400</td><td>400</td></tr><tr><td>MoC</td><td>280</td><td>280</td></tr><tr><td>MoS</td><td>9981</td><td>9981</td></tr></table>
+
+Table 6: Rank comparison on PTB. To ensure comparable model sizes, the embedding sizes of Softmax, MoC and MoS are 400, 280, 280 respectively. The vocabulary size, i.e., $M$ , is 10,000 for all models.
+
+Table 7: Empirical rank and test perplexity on PTB with different number of Softmaxes.   
+
+<table><tr><td>#Softmax</td><td>Rank</td><td>Perplexity</td></tr><tr><td>3</td><td>6467</td><td>58.62</td></tr><tr><td>5</td><td>8930</td><td>57.36</td></tr><tr><td>10</td><td>9973</td><td>56.33</td></tr><tr><td>15</td><td>9981</td><td>55.97</td></tr><tr><td>20</td><td>9981</td><td>56.17</td></tr></table>
+
+• Secondly, we show that, before reaching full rank, increasing the number of mixture components in MoS also increases the rank of the log-probability matrix, which in turn leads to improved performance (lower perplexity). Specifically, on PTB, with other hyper-parameters fixed as used in section 3.1, we vary the number of mixtures used in MoS and compare the corresponding empirical rank and test perplexity without finetuning. Table 7 summarizes the results. This clear positive correlation between rank and performance strongly supports the our theoretical analysis in section 2. Moreover, note that after reaching almost full rank (i.e., using 15 mixture components), further increasing the number of components degrades the performance due to overfitting (as we inspected the training and test perplexities).
+
+• In addition, as performance improvement can often come from better regularization, we investigate whether MoS has a better, though unexpected, regularization effect compared to Softmax. We consider the 1B word dataset where overfitting is unlikely and no explicit regularization technique (e.g., dropout) is employed. As we can see from the left part of Table 3, MoS and Softmax achieve a similar generalization gap, i.e., the performance gap between the test set and the training set. It suggests both models have similar regularization effects. Meanwhile, MoS has a lower training perplexity compared to Softmax, indicating that the improvement of MoS results from improved expressiveness.
+
+• The last evidence we provide is based on an inverse experiment. Empirically, we find that when Softmax does not suffer from a rank limitation, e.g., in character-level language modeling, using MoS will not improve the performance. Due to lack of space, we refer readers to Appendix C.2 for details.
+
+# 3.4 ADDITIONAL ANALYSIS
+
+MoS computational time The expressiveness of MoS does come with a computational cost— computing a $K$ -times larger Softmax. To give readers a concrete idea of the influence on training time, we perform detailed analysis in Appendix C.3. As we will see, computational wall time of MoS is actually sub-linear w.r.t. the number of Softmaxes $K$ . In most settings, we observe a two to three times slowdown when using MoS with up to 15 mixture components.
+
+Qualitative analysis Finally, we conduct a case study on PTB to see how MoS improves the next-token prediction in detail. Due to lack of space, we refer readers to Appendix C.4 for details. The key insight from the case study is that MoS is better at making context-dependent predictions. Specifically, given the same immediate preceding word, MoS will produce distinct next-step prediction based on long-term context in history. By contrast, the baseline often yields similar next-step prediction, independent of the long-term context.
+
+# 4 RELATED WORK
+
+In language modeling, Hutchinson et al. (2011; 2012) have previously considered the problem from a matrix rank perspective. However, their focus was to improve the generalization of Ngram language models via a sparse plus low-rank approximation. By contrast, as neural language models already generalize well, we focus on a high-rank neural language model that improves expressiveness without sacrificing generalization. Neubig & Dyer (2016) proposed to mix Ngram and neural language models to unify and benefit from both. However, this mixture might not generalize well since an Ngram model, which has poor generalization, is included. Moreover, the fact that the two components are separately trained can limit its expressiveness. Levy & Goldberg (2014) also considered the matrix factorization perspective, but in the context of learning word embeddings.
+
+In a general sense, Mixture of Softmaxes proposed in this work can be seen as a particular instantiation of the long-existing idea called Mixture of Experts (MoE) (Jacobs et al., 1991). However, there are two core differences. Firstly, MoE has usually been instantiated as mixture of Gaussians to model data in continuous domains (Jacobs et al., 1991; Graves, 2013; Bazzani et al., 2016). More importantly, the motivation of using the mixture structure is distinct. For Gaussian mixture models, the mixture structure is employed to allow for a parameterized multi-modal distribution. By contrast, Softmax by itself can parameterize a multi-modal distribution, and MoS is introduced to break the Softmax bottleneck as discussed in Section 2.
+
+There has been previous work (Eigen et al., 2013; Shazeer et al., 2017) proposing architectures that can be categorized as instantiations of MoC, since the mixture structure is employed in the feature space.6 The target of Eigen et al. (2013) is to create a more expressive feed-forward layer through the mixture structure. In comparison, Shazeer et al. (2017) focuses on a sparse gating mechanism also on the feature level, which enables efficient conditional computation and allows the training of a very large neural architecture. In addition to having different motivations from our work, all these MoC variants suffer from the same rank limitation problem as discussed in Section 2.
+
+Finally, several previous works have tried to introduce latent variables into sequence modeling (Bayer & Osendorfer, 2014; Gregor et al., 2015; Chung et al., 2015; Gan et al., 2015; Fraccaro et al., 2016; Chung et al., 2016). Except for (Chung et al., 2016), these structures all define a continuous latent variable for each step of the RNN computation, and rely on the SGVB estimator (Kingma & Welling, 2013) to optimize a variational lower bound of the log-likelihood. Since exact integration is infeasible, these models cannot estimate the likelihood (perplexity) exactly at test time. Moreover, for discrete data, the variational lower bound is usually too loose to yield a competitive approximation compared to standard auto-regressive models. As an exception, Chung et al. (2016) utilizes Bernoulli latent variables to model the hierarchical structure in language, where the Bernoulli sampling is replaced by a thresholding operation at test time to give perplexity estimation.
+
+# 5 CONCLUSIONS
+
+Under the matrix factorization framework, the expressiveness of Softmax-based language models is limited by the dimension of the word embeddings, which is termed as the Softmax bottleneck. Our proposed MoS model improves the expressiveness over Softmax, and at the same time avoids overfitting compared to non-parametric models and naively increasing the word embedding dimensions. Our method improves the current state-of-the-art results on standard benchmarks by a large margin, which in turn justifies our theoretical reasoning: it is important to have a high-rank model for natural language.
+
+# ACKNOWLEDGMENTS
+
+This work was supported by the DARPA award D17AP00001, the Google focused award, and the Nvidia NVAIL award.
+
+# REFERENCES
+
+Justin Bayer and Christian Osendorfer. Learning stochastic recurrent networks. arXiv preprint arXiv:1411.7610, 2014.
+
+Loris Bazzani, Hugo Larochelle, and Lorenzo Torresani. Recurrent mixture density network for spatiotemporal visual attention. arXiv preprint arXiv:1603.08199, 2016.
+
+Yoshua Bengio, Réjean Ducharme, Pascal Vincent, and Christian Jauvin. A neural probabilistic language model. Journal of machine learning research, 3(Feb):1137–1155, 2003.
+
+David M Blei, Andrew Y Ng, and Michael I Jordan. Latent dirichlet allocation. Journal of machine Learning research, 3(Jan):993–1022, 2003.
+
+Ciprian Chelba, Tomas Mikolov, Mike Schuster, Qi Ge, Thorsten Brants, Phillipp Koehn, and Tony Robinson. One billion word benchmark for measuring progress in statistical language modeling. arXiv preprint arXiv:1312.3005, 2013.
+
+Junyoung Chung, Kyle Kastner, Laurent Dinh, Kratarth Goel, Aaron C Courville, and Yoshua Bengio. A recurrent latent variable model for sequential data. In Advances in neural information processing systems, pp. 2980–2988, 2015.
+
+Junyoung Chung, Sungjin Ahn, and Yoshua Bengio. Hierarchical multiscale recurrent neural networks. arXiv preprint arXiv:1609.01704, 2016.
+
+David Eigen, Marc’Aurelio Ranzato, and Ilya Sutskever. Learning factored representations in a deep mixture of experts. arXiv preprint arXiv:1312.4314, 2013.
+
+Marco Fraccaro, Søren Kaae Sønderby, Ulrich Paquet, and Ole Winther. Sequential neural models with stochastic layers. In Advances in Neural Information Processing Systems, pp. 2199–2207, 2016.
+
+Yarin Gal and Zoubin Ghahramani. A theoretically grounded application of dropout in recurrent neural networks. In Advances in neural information processing systems, pp. 1019–1027, 2016.
+
+Zhe Gan, Chunyuan Li, Ricardo Henao, David E Carlson, and Lawrence Carin. Deep temporal sigmoid belief networks for sequence modeling. In Advances in Neural Information Processing Systems, pp. 2467–2475, 2015.
+
+John J Godfrey and Edward Holliman. Switchboard-1 release 2. Linguistic Data Consortium, Philadelphia, 1997.
+
+Edouard Grave, Armand Joulin, and Nicolas Usunier. Improving neural language models with a continuous cache. arXiv preprint arXiv:1612.04426, 2016.
+
+Alex Graves. Generating sequences with recurrent neural networks. arXiv preprint arXiv:1308.0850, 2013.
+
+Karol Gregor, Ivo Danihelka, Alex Graves, Danilo Jimenez Rezende, and Daan Wierstra. Draw: A recurrent neural network for image generation. arXiv preprint arXiv:1502.04623, 2015.
+
+Brian Hutchinson, Mari Ostendorf, and Maryam Fazel. Low rank language models for small training sets. IEEE Signal Processing Letters, 18(9):489–492, 2011.
+
+Brian Hutchinson, Mari Ostendorf, and Maryam Fazel. A sparse plus low rank maximum entropy language model. In INTERSPEECH, pp. 1676–1679, 2012.
+
+Hakan Inan, Khashayar Khosravi, and Richard Socher. Tying word vectors and word classifiers: A loss framework for language modeling. arXiv preprint arXiv:1611.01462, 2016.
+
+Robert A Jacobs, Michael I Jordan, Steven J Nowlan, and Geoffrey E Hinton. Adaptive mixtures of local experts. Neural computation, 3(1):79–87, 1991.
+
+Yoon Kim, Yacine Jernite, David Sontag, and Alexander M Rush. Character-aware neural language models. In AAAI, pp. 2741–2749, 2016.
+
+Diederik P Kingma and Max Welling. Auto-encoding variational bayes. arXiv preprint arXiv:1312.6114, 2013.
+
+Reinhard Kneser and Hermann Ney. Improved backing-off for m-gram language modeling. In Acoustics, Speech, and Signal Processing, 1995. ICASSP-95., 1995 International Conference on, volume 1, pp. 181–184. IEEE, 1995.
+
+Ben Krause, Emmanuel Kahembwe, Iain Murray, and Steve Renals. Dynamic evaluation of neural sequence models. arXiv preprint arXiv:1709.07432, 2017.
+
+Omer Levy and Yoav Goldberg. Neural word embedding as implicit matrix factorization. In Advances in neural information processing systems, pp. 2177–2185, 2014.
+
+Matt Mahoney. Large text compression benchmark, 2011.
+
+Gábor Melis, Chris Dyer, and Phil Blunsom. On the state of the art of evaluation in neural language models. arXiv preprint arXiv:1707.05589, 2017.
+
+Stephen Merity, Caiming Xiong, James Bradbury, and Richard Socher. Pointer sentinel mixture models. arXiv preprint arXiv:1609.07843, 2016.
+
+Stephen Merity, Nitish Shirish Keskar, and Richard Socher. Regularizing and optimizing lstm language models. arXiv preprint arXiv:1708.02182, 2017.
+
+Tomas Mikolov and Geoffrey Zweig. Context dependent recurrent neural network language model. SLT, 12:234–239, 2012.
+
+Tomas Mikolov, Martin Karafiát, Lukas Burget, Jan Cernocky, and Sanjeev Khudanpur. Recurrent \` neural network based language model. In Interspeech, volume 2, pp. 3, 2010.
+
+Tomáš Mikolov, Ilya Sutskever, Anoop Deoras, Hai-Son Le, Stefan Kombrink, and Jan Cernocky. Subword language modeling with neural networks. preprint (http://www. fit. vutbr. cz/imikolov/rnnlm/char. pdf), 2012.
+
+Andriy Mnih and Geoffrey Hinton. Three new graphical models for statistical language modelling. In Proceedings of the 24th international conference on Machine learning, pp. 641–648. ACM, 2007.
+
+Graham Neubig and Chris Dyer. Generalizing and hybridizing count-based and neural language models. arXiv preprint arXiv:1606.00499, 2016.
+
+Steven Pinker. The language instinct, 1994.
+
+Ofir Press and Lior Wolf. Using the output embedding to improve language models. In EACL, 2017.
+
+William H Press. Numerical recipes 3rd edition: The art of scientific computing. Cambridge university press, 2007.
+
+Anton Maximilian Schäfer and Hans Georg Zimmermann. Recurrent neural networks are universal approximators. In International Conference on Artificial Neural Networks, pp. 632–640. Springer, 2006.
+
+Noam Shazeer, Azalia Mirhoseini, Krzysztof Maziarz, Andy Davis, Quoc Le, Geoffrey Hinton, and Jeff Dean. Outrageously large neural networks: The sparsely-gated mixture-of-experts layer. arXiv preprint arXiv:1701.06538, 2017.
+
+Ilya Sutskever, Oriol Vinyals, and Quoc V Le. Sequence to sequence learning with neural networks. In Advances in neural information processing systems, pp. 3104–3112, 2014.
+
+Li Wan, Matthew Zeiler, Sixin Zhang, Yann L Cun, and Rob Fergus. Regularization of neural networks using dropconnect. In Proceedings of the 30th international conference on machine learning (ICML-13), pp. 1058–1066, 2013.
+
+Wojciech Zaremba, Ilya Sutskever, and Oriol Vinyals. Recurrent neural network regularization. arXiv preprint arXiv:1409.2329, 2014.
+
+Tiancheng Zhao, Ran Zhao, and Maxine Eskenazi. Learning discourse-level diversity for neural dialog models using conditional variational autoencoders. arXiv preprint arXiv:1703.10960, 2017.
+
+Julian Georg Zilly, Rupesh Kumar Srivastava, Jan Koutník, and Jürgen Schmidhuber. Recurrent highway networks. arXiv preprint arXiv:1607.03474, 2016.
+
+Barret Zoph and Quoc V Le. Neural architecture search with reinforcement learning. arXiv preprint arXiv:1611.01578, 2016.
+
+# A PROOFS
+
+# Proof of Property 1
+
+Proof. For any $\mathbf { A } ^ { \prime } \in F ( \mathbf { A } )$ , let $P _ { \mathbf { A ^ { \prime } } } ( X | C )$ denote the distribution defined by applying Softmax on the logits given by $\mathbf { A } ^ { \prime }$ . Consider row $i$ column $j$ , by definition any entry in $\mathbf { A } ^ { \prime }$ can be expressed as $A _ { i j } ^ { \prime } = A _ { i j } + \Lambda _ { i i }$ . It follows
+
+$$
+P _ { { \bf A } ^ { \prime } } ( x _ { j } | _ { c _ { i } } ) = \frac { \exp A _ { i j } ^ { \prime } } { \sum _ { k } \exp A _ { i k } ^ { \prime } } = \frac { \exp ( A _ { i j } + \Lambda _ { i i } ) } { \sum _ { k } \exp ( A _ { i k } + \Lambda _ { i i } ) } = \frac { \exp A _ { i j } } { \sum _ { k } \exp A _ { i k } } = P ^ { * } ( x _ { j } | _ { c _ { i } } )
+$$
+
+For any $\mathbf { A } ^ { \prime \prime } \in \{ \mathbf { A } ^ { \prime \prime } \mid \operatorname { S o f t m a x } ( \mathbf { A } ^ { \prime \prime } ) = P ^ { * } \}$ , for any $i$ and $j$ , we have
+
+$$
+P _ { \mathbf { A } ^ { \prime \prime } } ( x _ { j } | c _ { i } ) = P _ { \mathbf { A } } ( x _ { j } | c _ { i } )
+$$
+
+It follows that for any $i , j$ , and $k$ ,
+
+$$
+{ \frac { P _ { \mathbf { A } ^ { \prime \prime } } ( x _ { j } | c _ { i } ) } { P _ { \mathbf { A } ^ { \prime \prime } } ( x _ { k } | c _ { i } ) } } = { \frac { \exp A _ { i j } ^ { \prime \prime } } { \exp A _ { i k } ^ { \prime \prime } } } = { \frac { \exp A _ { i j } } { \exp A _ { i k } } } = { \frac { P _ { \mathbf { A } } ( x _ { j } | c _ { i } ) } { P _ { \mathbf { A } } ( x _ { k } | c _ { i } ) } }
+$$
+
+As a result,
+
+$$
+A _ { i j } ^ { \prime \prime } - A _ { i j } = A _ { i k } ^ { \prime \prime } - A _ { i k }
+$$
+
+This means each row in $\mathbf { A } ^ { \prime \prime }$ can be obtained by adding a real number to the corresponding row in A. Therefore, there exists a diagonal matrix $\mathbf { A } \in \mathbb { R } ^ { N \times N }$ such that
+
+$$
+\mathbf { A } ^ { \prime \prime } = \mathbf { A } + \mathbf { A } \mathbf { J } _ { N , M }
+$$
+
+It follows that $\mathbf { A } ^ { \prime \prime } \in F ( \mathbf { A } )$ .
+
+# Proof of Property 2
+
+Proof. For any ${ \bf A } _ { 1 }$ and $\mathbf { A } _ { 2 }$ in $F ( \mathbf { A } )$ , by definition we have ${ \bf A } _ { 1 } = { \bf A } + { \bf A } _ { 1 } { \bf J } _ { N , M }$ , and ${ \bf A } _ { 2 } \ =$ $\mathbf { A } + \mathbf { A } _ { 2 } \mathbf { J } _ { N , M }$ where $\pmb { \Lambda } _ { 1 }$ and $\mathbf { { \boldsymbol { \Lambda } } } _ { 2 }$ are two diagonal matrices. It can be rewritten as
+
+$$
+{ \bf A } _ { 1 } = { \bf A } _ { 2 } + ( { \pmb { \Lambda } } _ { 1 } - { \pmb { \Lambda } } _ { 2 } ) { \bf J } _ { N , M }
+$$
+
+Let $S$ be a maximum set of linearly independent rows in ${ \bf A } _ { 2 }$ . Let $\mathbf { e } _ { N }$ be an all-ones vector with dimension $N$ . The $i$ -th row vector $\mathbf { a } _ { 1 , i }$ in ${ \bf A } _ { 1 }$ can be written as
+
+$$
+{ \bf a } _ { 1 , i } = { \bf a } _ { 2 , i } + ( \Lambda _ { 1 , i i } - \Lambda _ { 2 , i i } ) { \bf e } _ { N }
+$$
+
+Because $\mathbf { a } _ { 2 , i }$ is a linear combination of vectors in $S , \mathbf { a } _ { 1 , i }$ is a linear combination of vectors in $S \cup \{ \mathbf { e } _ { N } \}$ . It follows that
+
+$$
+\mathrm { r a n k } ( \mathbf { A } _ { 1 } ) \leq \mathrm { r a n k } ( \mathbf { A } _ { 2 } ) + 1
+$$
+
+Similarly, we can derive
+
+$$
+\mathrm { r a n k } ( \mathbf { A } _ { 2 } ) \leq \mathrm { r a n k } ( \mathbf { A } _ { 1 } ) + 1
+$$
+
+Therefore,
+
+$$
+| \mathrm { r a n k } ( \mathbf { A } _ { 1 } ) - \mathrm { r a n k } ( \mathbf { A } _ { 2 } ) | \leq 1
+$$
+
+# Proof of Proposition 1
+
+Proof. If there exists a parameter $\theta$ such that $P _ { \theta } ( X | c ) = P ^ { * } ( X | c )$ for all $c$ in $\mathcal { L }$ , by Lemma 1, we have $\mathbf { H } _ { \theta } \mathbf { W } _ { \theta } ^ { \top } \in F ( \mathbf { A } )$ . As a result, there exists a matrix $\mathbf { A } ^ { \prime } \in \mathsf { F } ( \mathbf { A } )$ such that $\mathbf { \bar { H } } _ { \theta } \mathbf { W } _ { \theta } ^ { \top } = \mathbf { A } ^ { \prime }$ . Because $\mathbf { H } _ { \theta }$ and $\mathbf { W } _ { \theta }$ are of dimensions $( N \times d )$ and $( M \times d )$ respectively, we have
+
+$$
+d \geq \mathrm { r a n k } ( \mathbf { A } ^ { \prime } ) \geq \operatorname* { m i n } _ { \mathbf { A } ^ { \prime \prime } \in F ( \mathbf { A } ) } \mathrm { r a n k } ( \mathbf { A } ^ { \prime \prime } )
+$$
+
+If $d \geq \mathrm { m i n } _ { \mathbf { A } ^ { \prime \prime } \in F ( \mathbf { A } ) } \mathrm { r a n k } ( \mathbf { A } ^ { \prime \prime } )$ , there exist matrices $\mathbf { A } ^ { \prime } \in F ( \mathbf { A } )$ , $\mathbf { H } ^ { \prime } \in \mathbb { R } ^ { N \times d }$ and $\mathbf { W } ^ { \prime } \in \mathbb { R } ^ { M \times d }$ , such that $\mathbf { A } ^ { \prime }$ can be factorized as $\mathbf { A } ^ { \prime } = \mathbf { H } ^ { \prime } \mathbf { W } ^ { \prime \top }$ . Because $\mathcal { U }$ is a universal approximator, there exists $\theta$ such that $\mathbf { H } _ { \theta } = \mathbf { H } ^ { \prime }$ and $\mathbf { W } _ { \theta } = \mathbf { W } ^ { \prime }$ . By Lemma 1, $P _ { \theta } ( X | c ) = P ^ { * } ( X | c )$ for all $c$ in $\mathcal { L }$ . □
+
+# B EXPERIMENT SETTING AND HYPER-PARAMETERS
+
+# B.1 PTB AND WT2
+
+The hyper-parameters used for MoS in language modeling experiment is summarized below.   
+Table 8: Hyper-parameters used for MoS. V-dropout abbreviates variational dropout (Gal & Ghahramani, 2016). See (Merity et al., 2017) for more detailed descriptions.   
+
+<table><tr><td>Hyper-parameter</td><td>PTB</td><td>WT2</td></tr><tr><td>Learning rate</td><td>20</td><td>15</td></tr><tr><td>Batch size</td><td>12</td><td>15</td></tr><tr><td>Embedding size</td><td>280</td><td>300</td></tr><tr><td>RNN hidden sizes</td><td>[960,960, 620]</td><td>[1150,1150,650]</td></tr><tr><td>Number of mixture components</td><td>15</td><td>15</td></tr><tr><td>Word-level V-dropout</td><td>0.10</td><td>0.10</td></tr><tr><td>Embedding V-dropout</td><td>0.55</td><td>0.40</td></tr><tr><td>Hidden state V-dropout</td><td>0.20</td><td>0.225</td></tr><tr><td>Recurrent weight dropout (Wan et al., 2013)</td><td>0.50</td><td>0.50</td></tr><tr><td>Context vector V-dropout</td><td>0.30</td><td>0.30</td></tr></table>
+
+The hyper-parameters used for dynamic evaluation of MoS is summarized below.
+
+<table><tr><td>Hyper-parameter Batch size</td><td>PTB 100</td><td>WT2 100</td></tr><tr><td>learning rate (n)</td><td>0.002</td><td>0.002</td></tr><tr><td>E</td><td>0.001</td><td>0.002</td></tr><tr><td>入</td><td>0.075</td><td>0.02</td></tr></table>
+
+Table 9: Hyper-parameters used for dynamic evaluation of MoS. See (Krause et al., 2017) for more detailed descriptions.
+
+# B.2 1B WORD DATASET
+
+For training, we use all of the 100 training shards. For validation, we use two shards from the heldout set, namely [heldout-00, heldout-10]. For test, we use another three shards from the heldout set, namely [heldout-20, heldout-30, heldout-40].
+
+The hyper-parameters are listed below.
+
+<table><tr><td>Hyper-parameter</td><td>Softmax</td><td>MoS-7</td></tr><tr><td>Learning rate</td><td>20</td><td>20</td></tr><tr><td>Batch size</td><td>60</td><td>60</td></tr><tr><td>BPTT langth</td><td>35</td><td>35</td></tr><tr><td>Embedding size</td><td>1024</td><td>900</td></tr><tr><td>RNN hidden sizes</td><td>[1024,1024]</td><td>[1024,1024]</td></tr><tr><td>Dropout rate</td><td>0</td><td>0</td></tr></table>
+
+Table 10: Hyper-parameters used for Softmax and MoS in experiment on 1B word dataset.
+
+# C ADDITIONAL EXPERIMENTS
+
+# C.1 HIGHER EMPIRICAL RANK OF MOS COMPARED TO MOC AND SOFTMAX
+
+In section 3, we compute the rank of different models based on the non-zero singular values of the empirical log-likelihood matrix. Since there can be roundoff mistakes, a less error-prone approach is to directly study the distribution of singular values. Specifically, if more singular values have relatively larger magnitude, the rank of the matrix tends to be higher. Motivated from this intuition, we visualize the distribution of the singular values. To account for the different magnitudes of singular values from different models, we first normalize all singular values to [0, 1]. Then, we plot the cumulative percentage of normalized singular values, i.e., percentage of normalized singular values below a threshold, in Figure 1. As we can see, most of the singular values of Softmax and MoC concentrate on an area with very low values. In comparison, the concentration area of the MoS singular values is not only several orders larger, but also spans a much wider region. Intuitively, MoS utilizes the corresponding singular vectors to capture a larger and more diverse set of contexts.
+
+![](images/adce8f38de7cfefe23364912241223e483f7e5d16a0656369c4fdefe6ae649b9.jpg)  
+Figure 1: Cumulative percentage of normalized singulars given a value in [0, 1].
+
+Table 11: Empirical expected pairwise KLD on PTB.   
+
+<table><tr><td>Model</td><td>Validation</td><td>Test</td></tr><tr><td>Softmax</td><td>4.869</td><td>4.763</td></tr><tr><td>MoC</td><td>4.955</td><td>4.864</td></tr><tr><td>MoS</td><td>5.400</td><td>5.284</td></tr></table>
+
+What’s more, another indicator of high rank is that the model can precisely capture the nuance of difference contexts. If a model can better capture the distinctions among contexts, we expect the nextstep conditional distributions to be less similar to each on average. Based on this intuition, we use the expected pairwise Kullback–Leibler divergence (KLD), i.e., $\mathbb { E } _ { c , c ^ { \prime } \sim \mathcal { C } } \left[ \mathrm { K L D } ( P ( X \mid c ) \| P ( X \mid c ^ { \prime } ) ) \right]$ where $\mathcal { C }$ denotes all possible contexts, as another metric to evaluate the ranks of the three models (MoS, MoC and Softmax). Practically, we sample $c , c ^ { \prime }$ from validation or test data of PTB to get the empirical estimations for the three models, which are shown in the right half of Table 11. As we expected, MoS achieves higher expected pairwise KLD, indicating its superiority in covering more contexts of the next-token distribution.
+
+C.2 AN INVERSE EXPERIMENT ON CHARACTER-LEVEL LANGUAGE MODELING   
+
+<table><tr><td>Model</td><td></td><td>#Param</td><td>Train</td><td>Validation</td><td>Test</td></tr><tr><td>Softmax</td><td>(hid1024,emb1024)</td><td>8.42M</td><td>1.35</td><td>1.41</td><td>1.49</td></tr><tr><td>MoS-7</td><td>(hid910,emb510)</td><td>8.45M</td><td>1.35</td><td>1.40</td><td>1.49</td></tr><tr><td>MoS-7</td><td>(hid750,emb750)</td><td>8.45M</td><td>1.38</td><td>1.42</td><td>1.50</td></tr><tr><td>MoS-10</td><td>(hid860, emb452)</td><td>8.43M</td><td>1.35</td><td>1.41</td><td>1.49</td></tr><tr><td>MoS-10</td><td>(hid683,emb683)</td><td>8.43M</td><td>1.38</td><td>1.42</td><td>1.50</td></tr></table>
+
+Table 12: BPC comparison on text8. For MoS, “- $\mathbf { \nabla } \cdot \boldsymbol { n }$ ” indicates using $_ n$ mixtures. “hid” and “emb” denote the hidden size and embedding size respectively.
+
+Here, we detail the inverse experiment, which shows that when Softmax does not suffer from a rank limitation, using MoS will not improve the performance. Notice that character-level language modeling (CharLM) is exactly such a problem, because the rank of the log-likelihood matrix is upper bounded by the vocabulary size, and CharLM usually has a very limited vocabulary (tens of characters). In this case, with the embedding size being hundreds in practice, Softmax is no longer a bottleneck in this task. Hence, we expect MoS to yield similar performance to Softmax on CharLM.
+
+We conduct experiments of CharLM using the text8 dataset (Mahoney, 2011), which consists of 100M characters including only alphabetical characters and spaces derived from Wikipedia. We follow Mikolov et al. (2012) and use the first 90M characters for training, the next 5M for validation and the final 5M for testing. The standard evaluation metric bit-per-character (BPC) is employed. We employ a 1-layer 1024-unit LSTM followed by Softmax as the baseline. For MoS, we consider 7 or 10 mixtures and reduce the hidden and/or embedding size to match the baseline capacity. When decreasing the hidden and/or embedding size, we either keep both the same, or make the hidden size relatively larger. The results are summarized in Table 12. Clearly, the Softmax and MoS obtain the same BPC on the test set and comparable BPC on the validation set, which well match our hypothesis. Since the only difference in word-level language modeling is the existence of the Softmax bottleneck, the distinct behavior of MoS again supports our hypothesis that it is solving the Softmax bottleneck problem.
+
+# C.3 MOS COMPUTATIONAL TIME
+
+Table 13: Training time slowdown compared to Softmax. MoS- $K$ means using $K$ mixture components. “bs” indicates Softmax and MoS use the same batch sizes on one GPU. “best-1” and “best-3” refer to the settings where Softmax and MoS obtain their own best perplexity, with 1 and 3 GPUs respectively.   
+
+<table><tr><td>Model</td><td>PTB/bs</td><td>PTB/best-1</td><td>WT2/bs</td><td>WT2/best-1</td><td>WT2/best-3</td><td>1B/bs</td><td>1B/best-1</td><td>1B/best-3</td></tr><tr><td>Softmax</td><td>1x</td><td>1x</td><td>1x</td><td>1x</td><td>1x</td><td>1x</td><td>1x</td><td>1x</td></tr><tr><td>MoS-5</td><td>1.2x</td><td>1</td><td>1.3x</td><td>1</td><td>1</td><td>一</td><td>1</td><td>1</td></tr><tr><td>MoS-7</td><td>1</td><td></td><td>1</td><td></td><td></td><td>3.8x</td><td>5.7x</td><td>2.1x</td></tr><tr><td>MoS-10</td><td>1.6x</td><td>1</td><td>1.9x</td><td>1</td><td>1</td><td>1</td><td>1</td><td>1</td></tr><tr><td>MoS-15</td><td>1.9x</td><td>2.8x</td><td>2.5x</td><td>6.4x</td><td>2.9x</td><td>1</td><td>1</td><td>1</td></tr></table>
+
+We evaluate the additional computational cost introduced by MoS. We consider two sets of controlled experiments. In the first set, we compare the training time of MoS and Softmax using the same batch sizes. In the second set, we compare the training time of two methods using the hyperparameter settings that achieve the best performance for each model (i.e., the settings in Tables 1, 2, and 3). In both sets, we control two models to have comparable model sizes.
+
+The results on the three datasets are shown in Table 13. Thanks to the efficiency of matrix multiplication on GPU, the computational wall time of MoS is actually sub-linear w.r.t. the number of Softmaxes $K$ . In most settings, we observe a two to three times slowdown when using MoS. Specifically, the “bs” setting measures the computational cost introduced by MoS given enough memory, which is $1 . 9 \mathrm { { x } }$ , $2 . 5 \mathrm { x }$ , and $3 . 8 \mathrm { x }$ slowdown on PTB, WT2, and 1B respectively. The “best-1” setting is usually slower compared to “bs”, because a single batch does not fit into the memory of a single GPU using MoS, in which case we have to split one batch into multiple small ones, resulting in further slowdown. In this sense, the gap between “best-1” and “bs” measures the computational cost introduced due to the increase of memory consumed by MoS. The “best- $. 3 ^ { \circ }$ alleviates this issue by using three GPUs, which allows larger-batch training for MoS. In this case, we reduce the computational cost to $2 . 9 \mathbf { x }$ on WT2 and $2 . 1 \mathbf { x }$ on 1B with our best performing model.
+
+Note that the computational cost is closely related to the batch size, which is interleaved with optimization. Though how batch sizes affect optimization remains an open question and might be task dependent, we believe the “best-1” and “best- $. 3 ^ { \circ }$ settings well reflect the actual computational cost brought by MoS on language modeling tasks.
+
+# C.4 QUALITATIVE ANALYSIS
+
+Since MoC shows a stronger performance than Softmax on PTB, the qualitative study focuses on the comparison between MoC and MoS. Concretely, given the same context (previous tokens), we search for prediction steps where MoS achieves lower negative log loss than MoC by a margin. We show some representative cases in Table 14 with the following observations:
+
+• Comparing the first two cases, given the same preceding word “N”, MoS flexibly adjusts its top predictions based on the different topic quantities being discussed in the context. In comparison, MoC emits quite similar top choices regardless of the context, suggesting its inferiority in make context-dependent predictions.   
+• In the 3rd case, the context is about international politics, where country/region names are likely to appear. MoS captures this nuance well, and yields top choices that can be used to complete a country name given the immediate preceding word “south”. Similarly, in the 4th case, MoS is able to include “ual”, a core entity of discussion in the context, in its top predictions. In contrast, MoC gives rather generic predictions irrieselevant to the context in both cases.   
+• For the 5th and the 6th example, we see MoS is able to exploit less common words accurately according to the context, while MoC fails to yield such choices. This well matches our analysis that MoS has the capacity of modeling context-dependent language.
+
+<table><tr><td rowspan="2">#1 Context</td><td colspan="5">managed properly and with a long-term outlook these can become investment-grade quality prop-</td></tr><tr><td colspan="5">erties &lt;eos&gt; canadian &lt;unk&gt; production totaled N metric tons in the week ended oct. N up N N from the preceding week &#x27;s total of N_?_</td></tr><tr><td>MoS top-5</td><td>million 0.38</td><td>tons 0.24</td><td>billion 0.09</td><td>barrels 0.06</td><td>ounces 0.04</td></tr><tr><td>MoC top-5 Reference</td><td>billion 0.39 canadian &lt;unk&gt; production totaled N metric tons in the week ended oct. N up N N from the</td><td>million 0.36</td><td>trillion 0.05</td><td>&lt;eos&gt; 0.04</td><td>N0.03</td></tr><tr><td>#2 Context</td><td colspan="5">preceding week &#x27;s total of N tons_ statistics canada a federal agency said &lt;eos&gt;^ the thriving &lt;unk&gt; street area offers &lt;unk&gt; of about $ N a square foot as do &lt;unk&gt; locations</td></tr><tr><td></td><td colspan="5">along lower fifth avenue &lt;eos&gt; by contrast &lt;unk&gt; in the best retail locations in boston san fran- cisco and chicago rarely top $ N _？</td></tr><tr><td>MoS top-5</td><td>&lt;eos&gt; 0.36</td><td>a 0.13</td><td>to 0.07</td><td>for 0.07</td><td>and 0.06</td></tr><tr><td>MoC top-5 Reference</td><td>million 0.39 billion 0.36</td><td></td><td>&lt;eos&gt; 0.05</td><td>to 0.04</td><td>of 0.03</td></tr><tr><td></td><td colspan="5">by contrast &lt;unk&gt; in the best retail locations in boston san francisco and chicago rarely top $ N a square foot &lt;eos&gt;</td></tr><tr><td>#3 Context</td><td colspan="5">as other &lt;unk&gt; governments particularly poland and the soviet union have recently discovered initial steps to open up society can create a momentum for radical change that becomes difficult if not impossible to control &lt;eos&gt; as the days go by the south </td></tr><tr><td>MoS top-5 MoC top-5</td><td>africa 0.15 african 0.15</td><td></td><td>&lt;eos&gt; 0.14 of0.06</td><td>korea 0.08 or0.05</td><td>korean 0.05</td></tr><tr><td>Reference</td><td>&lt;eos&gt; 0.38 and 0.08 as the days go by the south african government willbe ever more hard pressed to justify the</td><td></td><td></td><td></td><td>&lt;unk&gt; 0.04</td></tr><tr><td>#4 Context</td><td colspan="5">continued &lt;unk&gt; of mr. &lt;unk&gt; as well as the continued banning of the anc and enforcement of the state of emergency &lt;eos&gt;</td></tr><tr><td></td><td colspan="5">shares of ual the parent of united airlines were extremely active all day friday reacting to news and rumors about the proposed $ N bilion buy-out of the airline by an &lt;unk&gt; group &lt;eos&gt; wall street &#x27;s takeover-stock speculators or risk arbitragers had placed unusually large bets that a takeover would succeed and 二？_</td></tr><tr><td>MoS top-5 MoC top-5</td><td>the 0.14 the 0.10</td><td>that 0.07 &lt;unk&gt; 0.06</td><td>ual 0.07 that 0.05</td><td>&lt;unk&gt; 0.03 in 0.02</td><td>it 0.02 it 0.02</td></tr><tr><td>Reference</td><td colspan="5">wall street &#x27;s takeover-stock speculators or risk arbitragers had placed unusually large bets that a</td></tr><tr><td>#5 Context</td><td colspan="5">takeover would succeed and ual stock would rise &lt;eos&gt; the government is watching closely to see if their presence in the &lt;unk&gt; leads to increased &lt;unk&gt;</td></tr><tr><td></td><td colspan="5">protests and violence if it does pretoria will use this as a reason to keep mr. &lt;unk&gt; behind bars &lt;eos&gt; pretoria has n&#x27;t forgotten why they were allsentenced to life &lt;unk&gt; in the first place for sabotage and _？</td></tr><tr><td>MoS top-5</td><td>&lt;unk&gt; 0.47 &lt;unk&gt; 0.41</td><td>violence 0.11 the 0.03</td><td>conspiracy 0.03 a 0.02</td><td>incest 0.03 other 0.02</td><td>civil 0.03 in 0.01</td></tr><tr><td>MoC top-5 Reference</td><td colspan="5"> pretoria has n&#x27;t forgoten why they were all sentenced to life &lt;unk&gt; in the frst place for sabotage</td></tr><tr><td>#6 Context</td><td colspan="5">and conspiracy to &lt;unk&gt; the government &lt;eos&gt; china&#x27;s &lt;unk&gt; &lt;unk&gt; program has achieved some successes in &lt;unk&gt; runaway economic growth and stabilizing prices but has failed to eliminate serious defects in state planning and an &lt;unk&gt;</td></tr><tr><td></td><td colspan="5">drain on state budgets &lt;eos&gt; the official china daily said retail prices of &lt;unk&gt; foods have n&#x27;t risen since last december but acknowledged that huge government_?_</td></tr><tr><td>MoS top-5</td><td>subsidies 0.15 spending 0.08 officials 0.04 figures 0.03</td><td>efforts 0.03</td><td>officials 0.04</td><td>costs 0.04 &lt;unk&gt; 0.03</td><td>&lt;unk&gt; 0.03 costs 0.03</td></tr><tr><td>MoC top-5 Reference</td><td colspan="5">the official china daily said retail prices of &lt;unk&gt; foods have n&#x27;t risen since last december but ac-</td></tr><tr><td></td><td colspan="5"> knowledged that huge government _subsidies were a main factor in keeping prices down &lt;eos&gt;</td></tr></table>
+
+Table 14: Compaison of next-token prediction on Penn Treebank test data. N stands for a number as the result of preprocessing (Mikolov et al., 2010). The context shown only includes the previous sentence and the current sentence the prediction step resides in.

parse/train/S1l66nNFvB/S1l66nNFvB.md

@@ -0,0 +1,438 @@
+# GRAPH WARP MODULE: AN AUXILIARY MODULE FOR BOOSTING THE POWER OF GRAPH NEURAL NETWORKS IN MOLECULAR GRAPH ANALYSIS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Graph Neural Network (GNN) is a popular architecture for the analysis of chemical molecules, and it has numerous applications in material and medicinal science. Current lines of GNNs developed for molecular analysis, however, do not fit well on the training set, and their performance does not scale well with the complexity of the network. In this paper, we propose an auxiliary module to be attached to a GNN that can boost the representation power of the model without hindering the original GNN architecture. Our auxiliary module can improve the representation power and the generalization ability of a wide variety of GNNs, including those that are used commonly in biochemical applications.
+
+# 1 INTRODUCTION
+
+Recently, Graph Neural Network (GNN) is a popular choice of model in the analysis of molecular datasets in medicinal and material science. Many molecular datasets consist of molecular graphs with feature vectors associated to each atom, and numerous methods based on GNN has been proposed to date just for learning the features of chemical molecules (Wu et al., 2018; Duvenaud et al., 2015; Kearnes et al., 2016; Li et al., 2017; Gilmer et al., 2017; Shang et al., 2018), such as those pertaining to electrical conductivity and toxicity. One problem in the application of GNN to molecular datasets is the difficulty in reducing the training loss. Unlike in the applications of Deep Neural Networks (DNNs) to image datasets, the training loss of GNN on molecular dataset does not decrease consistently with the number of layers nor number of nodes per layers (cf. Fig. 4 in the appendix, thin dashed lines), and this seems to happen to numerous GNN architectures that are used in applications today (Duvenaud et al., 2015; Li et al., 2016; Kipf & Welling, 2017; Xu et al., 2019; Busbridge et al., 2018). Unfortunately, many strong techniques developed for deep CNNs such as ResNet (He et al., 2016) cannot be applied naively to GNN, because the tasks for GNNs are oftentimes fundamentally different in nature from that of standard DNN. For example, each graph data to be passed to the network can differ in size, and it is also often desired that GNN is equivariant (invariant under the reordering of vertices) in general. To the best of the authors’ knowledge, there have not been many studies done to date that directly addressed the problem of training loss.
+
+In this study, we propose graph warp module (GWM), a supernode (Li et al., 2017; Gilmer et al., 2017; Battaglia et al., 2018) based auxiliary module that can be attached to generic GNNs of various types to improve its representation power. The I/O of the auxiliary module is defined independently from the GNN to which it is attached, and the users can install the GWM just by adding a small segment of code.
+
+Our GWM consists of three major components. The first component is virtual supernode (Li et al., 2017; Gilmer et al., 2017), which communicates with all nodes in the graph and promotes the remote message passing. The second and third components are attention unit (Vaswani et al., 2017; Velickovi ˇ c et al., 2018) and gating units (Cho et al., 2014). These adaptive weighting functions in the ´ module help to adjust the flow of messages and deliver a message of appropriate strength to each node in the graph.
+
+Our GWM can consistently improve the performance of various types of GNN on various types of dataset. In Fig. 1 we show the effect of GWM on the performance of four types of GNNs with the same embedding dimension and the same number of layers on four molecular graph datasets. As we can see in the figure, the attachment of GWM reduces both train loss and test loss for all but three model-dataset pairs. The GWM provides not only more representation powers (less train loss), but also better generalization performances (less test loss) for various GNNs.
+
+![](images/530c9bde2c6bf0f173487d05b803750490f07a47b4f007fb3f4206b0ead7737d.jpg)  
+Figure 1: Train loss reduction and test loss reduction achieved by GWM on various modeldataset pair. The shape of each point presents the dataset used, and the color of each point presents the GNN model used. The horizontal axis denotes the ratio of reduced training loss, and the vertical axis denotes that of the test loss. That the x-coordinate of a point is positive implies that the attachment of GWM improved the train performance for the corresponding model-dataset pair. That the ycoordinate of a point is positive implies that GWM improves the test-performance.
+
+As we will show in section 4.4, we can further improve the positive effect of GWM using hyperparameter optimization softwares such as Optuna (Akiba et al., 2019).
+
+Our contributions are as follows:
+
+1. We introduce GWM, an auxiliary module that can help improve the representation power of the GNNs that are designed for the analysis of small graphs.   
+2. We show that the attachment of GWM can improve both the representation power and the generalization ability of various GNN models on many popular molecular graph datasets.
+
+# 2 RELATED WORK
+
+# 2.1 VIRTUAL SUPERNODE
+
+A common challenge in the application of GNNs to a graphical dataset is the difficulty in propagating the information across remote parts of graphs. Previously proposed solutions include sub-sampling (Hamilton et al., 2017) and pooling of neighbor nodes (Ying et al., 2018). However, these clustering approaches are not too effective on the analysis of small graphs, in which every node can have a strong influence on the graph label.
+
+In this study, we use supernode (Gilmer et al., 2017; Li et al., 2017; Pham et al., 2017) to promote the global propagation of the information in molecular graphs. By adding a supernode to a graph, we can allow any pair of nodes in the graph to communicate through the supernode in one hop. Battaglia et al. (Battaglia et al., 2018) discusses a framework of GNNs that generalizes the supernodeaugmented GNNs. One advantage of the supernode-based approach is that we can modify the network architecture while keeping the original GNN model intact. However, naive addition of a supernode to a graph can potentially lead to inadvertent over-smoothing of information propagation (c.f. (Li et al., 2018)). In our study, we therefore make the supernode a module by combining it with a gated message passing mechanism. This auxiliary module enables us to regulate the amount and type of information that is propagated through the feature space of the supernode.
+
+# 2.2 MESSAGE PASSING AND ATTENTION/GATE MECHANISM IN GNN
+
+The supernode in our GWM transmits information using the mechanism of message passing neural network (MPNN) (Gilmer et al., 2017), which is defined recursively as follows by composing multiple layers of the form:
+
+$$
+h _ { \ell , i } = \mathcal { F } _ { \ell } \left( \{ h _ { \ell - 1 , j } ; j \in N ( i ) \cup \{ i \} \} \right)
+$$
+
+where $i , j$ are indices of nodes in a graph. $h _ { \ell , i }$ is the feature vector of the node $i$ at the \`th layer, $N ( i )$ is the neighborhood of the node $i$ , and $\mathcal { F } _ { \ell }$ is an appropriate choice of function that updates the feature vectors of the previous layer. That is, MPNNs work by passing the information of each node to its neighbors in a recursive manner. Various methods are proposed for the choice of $\mathcal { F }$ and for the method of pooling the information of the neighbors of each node (Schlichtkrull et al., 2017; Kipf & Welling, 2017; Li et al., 2016; Bruna & Szlam, 2014; Duvenaud et al., 2015).
+
+![](images/4b9e1bc622d9b43f6a9dad292eb2b5b0d6a6c787d82c5a5efe81d5df28f2474c.jpg)  
+Figure 2: The overview of the proposed Graph Warp Module (GWM). A GWM consists of a supernode, a transmitter unit, and a warp gate unit. A GWM can be added to the original GNN as an auxiliary module. At each layer, the supernode and the main network communicate through the transmitter and the warp gate.
+
+Attention mechanism is a mechanism that helps the network regulate the importance of each node/edge in message passing (cf. (Wang et al., 2018)). A Relational GCN (Schlichtkrull et al., 2017) assumes that the aggregation weights of $h _ { \ell - 1 , j }$ is fixed a priori in all $\mathcal { F } _ { \ell }$ . With such architectures, however, one cannot regulate the higher order correlation amongst the outputs from each node. Graph Attention Networks (GATs) (Velickovi ˇ c et al., 2018) introduce a self-attention mechanism (Vaswani et al., ´ 2017), which is equipped with a trainable set of weights that controls the importance of edges for each node. The relational graph attention network (RGAT) (Busbridge et al., 2018) also builds upon GAT and constructed multiple types of attentions derived from relation-type-wise intermediate node representations. Finally, a GRU (Cho et al., 2014) is a gating mechanism originally introduced for recurrent neural networks. Gated Graph sequence Neural Networks (GGNN) (Li et al., 2016) are the first to apply GRUs to the GNNs, and their method aims to introduce a recurrence relation between successive layers. Although not in the form of super-node, a very recent paper (anonymous, 2019) uses a mechanism that combines GGNN and self-attention to capture both local and global relationships of a graph structure of program source codes. Our GWM is equipped with both multirelational attention mechanisms and GRUs to grant the module greater flexibility for the transmission of message between supernode and the bulk nodes.
+
+# 3 GRAPH WARP MODULE
+
+Our Graph Warp Module (GWM) is made of three building blocks: (1) a supernode, (2) a transmitter unit, and (3) a warp gate unit (Fig. 2). In a GWM-attached GNN, information is propagated across the graph through communication between the supernode and the original (main) GNN at each layer. Messages from the supernode and the main GNN are transmitted to the warp gate through the transmitter unit, and the results of the communication are passed back to the module/main network through the warp gate units. In this section, we describe the Graph Warp Module in detail, and present the motivation of our design.
+
+# 3.1 PREMISE: VANILLA GNN AND ITS I/O
+
+Before describing our GWM, we need to present the I/O notation for the family of GNNs we consider, and explain how they will be used when a GWM is attached to a GNN. We denote an arbitrary graph with the edge set $E$ and the node set $V$ as $G = ( V , E )$ . We will label the nodes in $V$ as $i = 1 , 2 , . . . | V |$ , and represent each edge as a pair of nodes in $V$ . The adjacency matrix $\mathcal { A } \in \mathbb { R } ^ { | V | \times | V | }$ is a matrix whose $( i , j )$ th entry is the weight assigned to the edge between the node $i$ and the node $j$ . Each instance of data passed to the GNN is a set of input feature vectors. We denote an input feature vector associated with node $i$ as $x _ { i }$ . The type of GNN that we consider computes the output recursively by applying a composition of smooth functions $\mathcal { F } _ { \ell }$ to $x _ { i } \mathbf { s }$ . With the understanding that $x _ { j } = h _ { 0 , j }$ , let $h _ { \ell , i } ^ { - } = \bar { \mathcal { F } } _ { \ell - 1 , i } ( \bar { h _ { \ell - 1 , j } } ; j \in V ) \in \mathbb { R } ^ { d }$ be the vector of features to be assigned to the $i$ th node by the \`th layer of the GNN. When the GNN is operating on its own without the attachment of a GWM, the GNN updates a feature vector using $h _ { \ell , i } \overset { - } { = } \mathcal { F } _ { \ell - 1 , i } ( h _ { \ell - 1 , j } ; j \in V ) \in \mathbb { R } ^ { d }$ . Finally, the GNN reports some form of the aggregation of $\{ h _ { L , i } ; i \in V \}$ as the final Readout output.
+
+When a GWM is attached to the GNN, the main(bulk) GNN is requested to report $\mathcal { F } _ { \ell - 1 , i } ( h _ { \ell - 1 , j } ; j \in$ $V ) \in \mathbb { R } ^ { d }$ as the message from the $\ell - 1$ th main layer to the module, where it is treated as an element in the intermodule hyperspace and is mixed with the transmission from the supernode. The GWM will return the mixed message $h _ { \ell }$ back to the \`th layer of the main GNN. At the same time, the GWM requests a transmission message from the main GNN to the $\ell \mathrm { t h }$ supernode. The module will mix the transmission and the message from the $\ell - 1$ 1th supernode and return the mixed message $g _ { \ell }$ to the \`th supernode. The final output is produced by aggregating $\{ h _ { L , i } ; i \in V \}$ and $g _ { L }$ .
+
+# 3.2 SUPERNODE
+
+A supernode is a special node that is connected to nodes in the original graph to promote global information propagation across the network (Fig. 2). A supernode is to be prepared for each \`th layer of the main GNN, and we associate a feature vector $g _ { \ell }$ to the supernode at the \`th layer. At each layer, the transmitter requests the following from the supernode: (1) a message $\mathcal { G } _ { \ell } \left( g _ { \ell } \right)$ for the $\ell + 1 { \mathrm { t h } }$ layer and (2) a transmission to the main network, where $\mathcal { G } _ { \ell }$ is an appropriate choice of a smooth function.
+
+Because a supernode is a superficial variable, we must initialize $g _ { 0 }$ manually. For instance, we can use some form of aggregation of the global graph features (e.g. a number of nodes or edges, graph diameter, girth, cycle number, min, max, histogram, or an average of input node features, . . . ). A detailed example of the aggregated feature is presented in the appendix.
+
+# 3.3 TRANSMITTER UNIT
+
+The transmitter unit handles the communications between the main GNN module and the GWM (Fig. 3). The transmitter module is responsible for translating the messages from the recipient into a form that can be mixed in the intermodule hyperspace. We will use multiple types of messages and thus use a separate attention mechanism for each type of message. Before transmitting messages from the main GNN to the supernode, the transmitter uses the $K$ -head attention mechanism to aggregate messages of each type. We enumerate the components included therein:
+
+• $m _ { \ell , k } ^ { \mathrm { m a i n } \to \mathrm { s u p e r } }$ : aggregated message of head $k$ from the main GNN to the supernode at layer $\ell$ • $h _ { \ell } ^ { \mathrm { m a i n \to s u p e r } }$ : transmission from the main GNN to the supernode, derived from $m _ { \ell , k } ^ { \mathrm { m a i n \to s u p e r } }$ . • g\` $g _ { \ell } ^ { \mathrm { s u p e r } \to \mathrm { m a i n } }$ : transmission from the supernode to the main at layer $\ell$ .
+
+The transmissions are to be constructed from the following set of equations. For a vector $v$ , we use $v _ { m : n } \in \mathbb { R } ^ { ( m - n ) d }$ to denote the concatenation of the vectors $v _ { m } , v _ { m + 1 } , \ldots \in \mathbb { R } ^ { d }$ . Throughout, we use capital letters to denote the trainable coefficients.
+
+$$
+h _ { \ell } ^ { \mathrm { m i n \to s u p e r } } = \operatorname { t a n h } \left( W _ { \ell } m _ { \ell , 1 : k } ^ { \mathrm { m a i n \to s u p e r } } \right) \in \mathbb { R } ^ { D ^ { \prime } } ,
+$$
+
+$$
+m _ { \ell , k } ^ { \mathrm { m i n \to s u p e r } } = \sum _ { i } \alpha _ { \ell , i , k } U _ { \ell , k } h _ { \ell - 1 , i } \in \mathbb { R } ^ { D ^ { \prime } } ,
+$$
+
+$$
+\alpha _ { \ell , i , k } = \mathrm { s o f t m a x } \left( h _ { \ell - 1 , i } ^ { T } A _ { \ell , k } g _ { \ell - 1 } \right) \in \left( 0 , 1 \right) ,
+$$
+
+where $\alpha _ { \ell , i , k }$ denotes an attention weight of the ith node at the $k$ th head (type) and the lth layer.
+
+The transmission from the supernode to the main is simply given by:
+
+$$
+g _ { \ell } ^ { \mathrm { s u p e r } \to \mathrm { m a i n } } = \operatorname { t a n h } \left( F _ { \ell } g _ { \ell - 1 } \right) \in \mathbb { R } ^ { D } .
+$$
+
+![](images/7baa670cd478bf2da997409d1317772ca21713af22c2fd2eef4139b5ed06cc88.jpg)  
+Figure 3: Details of the GWM computations.
+
+There is no analogue of $m$ for the supernode because we are not considering a set of messages of different types to be transmitted from the supernode.
+
+# 3.4 WARP GATE
+
+The warp gate is responsible for merging the transmitted messages and for passing the results to the supernode and the main network through self recurrent units. The gate uses warp gate coefficients to control the mixing-rate of the messages. The components of the warp Gate are:
+
+• $h _ { \ell } ^ { 0 }$ : inputs to the GRU unit at \`th layer that transmits the message to the main GNN.   
+• $g _ { \ell } ^ { 0 }$ : inputs to the GRU unit at \`th layer that transmits the message to the supernode.   
+• $\hat { h } _ { \ell , i }$ : the message $\mathcal { F } _ { \ell - 1 , i } ( h _ { \ell - 1 , k } ; k \in V ) \in \mathbb { R } ^ { D }$ from the $\ell - 1$ th layer of the main network, expressed in the intermodule hyperspace.   
+• $\hat { g } _ { \ell }$ : the message $\mathcal { G } _ { \ell - 1 } \left( g _ { \ell - 1 } \right) \in \mathbb { R } ^ { D ^ { \prime } }$ from the $\ell - 1$ th supernode, where $\mathcal { G }$ is an appropriate smooth function with outputs in the intermodule hyperspace. $z _ { \ell , i }$ : tensor of warp gate coefficients for the transmission from the supernode to the main   
+• GNN. $z _ { \ell , i } ^ { ( S ) }$ : tensor of warp gate coefficients for the transmission from the main GNN to the
+
+The module then mixes the transmissions and the messages from the previous layer by applying the following gated interpolations:
+
+$$
+h _ { \ell , i } ^ { 0 } = ( 1 - z _ { \ell , i } ) \odot \hat { h } _ { \ell - 1 , i } + z _ { l , i } \odot g _ { \ell } ^ { \mathrm { s u p e r  m a i n } } \in \mathbb { R } ^ { D } ,
+$$
+
+$$
+g _ { \ell } ^ { 0 } = z _ { \ell } ^ { ( S ) } \odot h _ { \ell } ^ { \mathrm { m a i n \to s u p e r } } + ( 1 - z _ { \ell } ^ { ( S ) } ) \odot \hat { g } _ { \ell } \in \mathbb { R } ^ { D ^ { \prime } } ,
+$$
+
+$$
+\boldsymbol { z } _ { \ell , i } = \sigma \left( H _ { \ell } \boldsymbol { \tilde { h } } _ { \ell , i } + G _ { \ell } g _ { \ell } ^ { \mathrm { s u p e r } \to \mathrm { m i n } } \right) , \quad \boldsymbol { z } _ { \ell } ^ { ( S ) } = \sigma \left( H _ { \ell } ^ { ( S ) } h _ { \ell } ^ { \mathrm { m i n } \to \mathrm { s u p e r } } + G _ { \ell } ^ { ( S ) } \hat { g } _ { \ell } \right) ,
+$$
+
+where $\sigma$ is a nonlinear function whose range lies in [0, 1]. Finally, the warp gate returns the mixed messages to the main GNN and the supernode through gated recurrent unit (GRU) $\mathbf { S }$ :
+
+$$
+h _ { \ell , i } = { \bf G R U } \left( h _ { \ell - 1 , i } , h _ { \ell , i } ^ { 0 } \right) \in \mathbb { R } ^ { D } , \quad g _ { \ell } = { \bf G R U } \left( g _ { \ell - 1 } , g _ { \ell } ^ { 0 } \right) \in \mathbb { R } ^ { D ^ { \prime } } .
+$$
+
+As for the structure of GRU, we used the original design introduced by (Cho et al., 2014).
+
+As we will show with ablation studies (Sec. 4.4), every component of GWM is essential in making the module work. The Attention coefficients (Eqs.(3,4)) are important because the amount and the type of information that must be transmitted to remote nodes may differ for different nodes. The Gating coefficients (Eqs.(6-8)) are important because we want to regulate the transmission from each node in the graph to the supernode and vice versa. We use different recurring units (Eq.9) for the transmission from the module to the supernode and the transmission from the module to the main network for each layer because the amount of the information that must be reinforced may differ for the main network and the supernode at each layer.
+
+# 3.4.1 COMPUTATIONAL COMPLEXITY
+
+Let $V$ be the vertex set, $K$ be the number of attention heads, and $D$ be the dimension of the node embedding. Then the additional computational cost incurred by the attachment of GWM is at most $O ( | V | K D ^ { 2 } )$ . As for the actual computation time, GWM attached module consumes approximately double the time of the original unattached version.
+
+# 4 EXPERIMENTS
+
+In this section, we present our experimental results on multiple molecular graph datasets, testing the efficacy of the GWM for graph regression tasks and graph classification tasks.
+
+# 4.1 DATASETS
+
+We used four datasets collected in MoleculeNet (Wu et al., 2018). These datasets are described in the SMILES string format, which admits the graph representations we described above. For details, please see (Wu et al., 2018).
+
+For the graph regression tasks, we used the QM9 dataset and the Lipophilicity (LIPO) dataset. QM9 is a dataset with numerical labels, containing about 133K drug-like molecules with 12 important chemical-energetic, electronic, and thermodynamic properties, such as HOMO, LUMO, and electron gaps. The LIPO dataset is another numeric-valued dataset, containing the solubility values of roughly 4K drug molecules. Each instance of data in these datasets is a pair of a molecular graph and a numerical value(s): the 12 chemical properties in the QM9 dataset, and the solubility in the LIPO dataset. For both datasets, the task is to predict the numerical value(s) from the molecular graph. We evaluated the performance of the models using mean absolute errors (MAEs). We report the averaged MAE over 12 sub-tasks (properties) for QM9.
+
+For the graph classification tasks, we used the Tox21 and the HIV datasets. The Tox21 dataset contains about 8K pairs of molecular graph and 12 dimensional binary vector that represent the experimental outcomes of toxicity measurements on 12 different targets. The HIV dataset contains roughly 42K pairs of molecular graph and binary label that represent the medicinal effect of the molecule. For these datasets, the task is to predict the binary label(s) from the molecular graph. For these tasks, we use ROC-AUC values as a measure of performance. We report the averaged ROC-AUC over 12 sub-tasks (targets) for Tox21.
+
+Throughout, we used the train/validation/test data splits of the “scaffold” type, which is considered by (Ruddigkeit et al., 2012; Ramakrishnan et al., 2014) as the difficult type for test predictions. Please find the appendix for details.
+
+# 4.2 CHOICES OF THE MAIN GNN MODELS AND IMPLEMENTATIONS
+
+We test GWMs on various GNN models. Neural Fingerprints (NFP) (Duvenaud et al., 2015) and Weavenet (Kearnes et al., 2016) are relatively classical baselines. A Gated Graph Neural Network (GGNN) (Li et al., 2016) is a strong GRU-based GNN. Renormalized Spectral Graph Convolutional Network (RSGCN1) (Kipf & Welling, 2017), a popular GNN model approximating a CNN for graphs (Defferrard et al., 2016). The relational graph attention network (RGAT) (Busbridge et al., 2018) uses multiple attention mechanisms for a set of edge types. Graph Isomorphism Network (GIN) (Xu et al., 2019) employs multi layer perceptrons within each layer for richer transformations.
+
+We implement all models in Chainer (Tokui et al., 2015). In the readout layer, we first aggregate all information from the main nodes in the same way as in the original paper, concatenated the result with the features from the supernode, and passed the concatenated tensor to a fully connected layer.
+
+<table><tr><td rowspan=1 colspan=1>Model Name (emulating)</td><td rowspan=1 colspan=1>Attention</td><td rowspan=1 colspan=1>Gatings</td><td rowspan=1 colspan=1>GRUs</td></tr><tr><td rowspan=1 colspan=1>Simple supernode (Li et al.,2017; Pham et al., 2017)NoGate GWM (Gilmer et al., 2017)Proposed GWM</td><td rowspan=1 colspan=1>√</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>√ (supernode only)√</td></tr></table>
+
+Table 1: Supernode-based models validated in the Experiment 4.4. Note that the “simple supernode” ablation model and the model used in (Pham et al., 2017) allow bi-directional message passings between original nodes and the supernode while the one used in (Li et al., 2017) only allows directional messages from the original nodes to the supernode.
+
+For evaluation, we used a softmax cross entropy for classification tasks and a mean squared error for regression tasks. We use a fixed set of hyperparameters throughout the study.
+
+All models were trained with Adam (Kingma & Ba, 2015). We report the results of the model snapshots of the epoch for which the best validation score was achieved. For implementation details including readouts and hyperparameters, please read the appendix.
+
+# 4.3 TRAINING AND TEST LOSS REDUCTION
+
+We explain the details of the experiment that produced the result presented in Fig. 1. For this experiment, we reported the average $\bar { r }$ of the loss reduction ratio $\begin{array} { r } { r = \frac { \mathcal { L } - \mathcal { L } ^ { ( + ) } } { \left\| L \right\| } } \end{array}$ for both training loss and test loss over 10 runs. $\mathcal { L }$ denotes the loss of the vanilla model, and $\mathcal L ^ { ( + ) }$ denote the loss of the GWM-installed model. $\bar { r } _ { t r a i n }$ denotes a reduction ratio of the training loss, and $\bar { r } _ { t e s t }$ denotes a reduction ratio of the test loss.
+
+Fig. 1 is the scatter plot of the $\left( \bar { r } _ { t r a i n } , \bar { r } _ { t e s t } \right)$ , with the dotted slope representing $\bar { r } _ { t r a i n } = \bar { r } _ { t e s t }$ . For all GNNs and datasets, we set $L = 3$ and $D = 5 0$ . As we can see in the plot, $\bar { r } _ { t r a i n } \mathbf { s }$ were negative for the two GNNs in the HIV dataset (blue and brown circles). $\bar { r } _ { t r a i n }$ for GGNN on QM9 (blue cross) was a very small negative value). For the other 13 (model-dataset) pairs, the attachment of GWM consistently reduces the training loss( i.e. improves the fit to the training graph datasets. ) Remarkably, 15 out of 16 pairs had positive $\bar { r } _ { t e s t } { \bf s }$ : the GWM improved generalization performances in most cases. It is worthy of note that $\bar { r } _ { t r a i n }$ and $\bar { r } _ { t e s t }$ are positively correlated in this scatter plot. We were able to obtain similar results for all other choices of hyperparameters we tested. For the results with different hyperparameter values, see the appendix. This result implies that our GWM has the general effect of improving the generalization performance by augmenting the representation power of the main GNN.
+
+# 4.4 EFFECT OF THE GWM ON THE REPRESENTATION POWER OF MODEL SPACE
+
+In the second experiment, we studied the effect of GWM on the representation power of GNN models. To compare the GWM-augmented GNNs with their vanilla GNN counterparts on fair grounds, we used Bayesian optimization to optimize the number of layers and the dimension of feature vectors for each model-dataset pair we tested. Hyperparameters are optimized via the Optuna (Akiba et al., 2019) library.
+
+We conducted a set of ablation studies to investigate the effect of (1) attention mechanism, (2) Gating mechanism, and (3) the Recurrent unit. We used two ablation models. Simple supernode model is a supernode without attention, gatings, and GRU functions. This ablation model can be considered a variant of (Pham et al., 2017)’s supernode model in which the supernode and the bulk networks communicate with each other in bidirectional manner. This model can be also considered as an extended version of supernode proposed in (Li et al., 2017).
+
+NoGate GWM is a GWM without gatings, and it lacks GRU for the main GNN.
+
+Table 1 summarizes the details of our ablation studies. For the detailed formulations of the two ablation models, please see the appendix.
+
+Table 2 and Table 3 respectively present the MAEs on the regression tasks and the ROC-AUCs for the classification tasks, averaged over 10 random runs. In the tables, bold faces indicate the improvements from the vanilla GNN and asterisks indicate the best model among supernode models for each (dataset, GNN) pair. Full tables with standard deviations are presented in the appendix. As we can see in the tables, the proposed GWM improves the generalization performances for 23 out of 24 (model-dataset) pairs. These results suggest that the proposed (full) GWM can improve GNNs’ performances irrespective of the choice of GNN models and the dataset.
+
+Table 2: MAEs on the LIPO dataset and QM9 dataset. Smaller values are better. Scores on QM9 are the average MAEs over 12 sub-tasks. The score of select models are presented in the appendix.   
+
+<table><tr><td rowspan=1 colspan=1>Dataset</td><td rowspan=1 colspan=1>GNN model</td><td rowspan=1 colspan=1>NFP</td><td rowspan=1 colspan=1>Weave</td><td rowspan=1 colspan=1>RGAT</td><td rowspan=1 colspan=1>GGNN</td><td rowspan=1 colspan=1>RSGCN</td><td rowspan=1 colspan=1>GIN</td><td rowspan=1 colspan=1># Improved</td></tr><tr><td rowspan=3 colspan=1>LIPO</td><td rowspan=3 colspan=1>vanilla GNN+Simple Supernode+NoGate GWM+Proposed GWM</td><td rowspan=3 colspan=1>.677.693.675.672*</td><td rowspan=3 colspan=1>1.191.01.721.688*</td><td rowspan=3 colspan=1>.753.740.688.659*</td><td rowspan=2 colspan=1>.582.604.576</td><td rowspan=1 colspan=1>.801.775</td><td rowspan=2 colspan=1>.844.819.847</td><td rowspan=3 colspan=1>14/65/66/6</td></tr><tr><td rowspan=1 colspan=1>.787</td></tr><tr><td rowspan=1 colspan=1>.569*</td><td rowspan=1 colspan=1>.752*</td><td rowspan=1 colspan=1>.784*</td></tr><tr><td rowspan=1 colspan=1>QM9</td><td rowspan=1 colspan=1>vanilla GNN+Simple Supernode+NoGate GWM+Proposed GWM</td><td rowspan=1 colspan=1>6.167.686.846.64*</td><td rowspan=1 colspan=1>6.385.515.40*5.90</td><td rowspan=1 colspan=1>8.969.009.218.39*</td><td rowspan=1 colspan=1>4.925.415.524.88*</td><td rowspan=1 colspan=1>15.214.612.511.9*</td><td rowspan=1 colspan=1>14.011.5*12.911.8</td><td rowspan=1 colspan=1>-3/63/65/6</td></tr></table>
+
+Table 3: ROC-AUCs on the HIV dataset and Tox21 dataset. Larger values are better. Scores on Tox21 are the average MAEs over 12 sub-tasks. Scores of select models are presented in the appendix.   
+
+<table><tr><td>Dataset</td><td>GNN model</td><td>NFP</td><td>Weave</td><td>RGAT</td><td>GGNN</td><td>RSGCN</td><td>GIN</td><td>#Improved</td></tr><tr><td rowspan="2">HIV</td><td>vanilla GNN +Simple supernode</td><td>.724 .707</td><td>.670 .676</td><td>.707 .704</td><td>.746 .764*</td><td>.746 .728</td><td>.729 .729</td><td>= 2/6</td></tr><tr><td>+NoGate GWM</td><td>.714</td><td>.680</td><td>.726</td><td>.744</td><td>.742</td><td>.739</td><td>3/6</td></tr><tr><td rowspan="4">Tox21</td><td>+Proposed GWM vanilla GNN</td><td>.731* .763</td><td>.681* .710</td><td>.748* .764</td><td>.762 .757</td><td>.758* .760</td><td>.755* .740</td><td>6/6</td></tr><tr><td>+Simple supernode</td><td>.770</td><td>.750</td><td>.787*</td><td>.790</td><td>.770*</td><td>.763</td><td>- 6/6</td></tr><tr><td>+NoGate GWM</td><td>.775*</td><td>.764</td><td>.786</td><td>.792*</td><td></td><td></td><td></td></tr><tr><td>+Proposed GWM</td><td>.769</td><td>.767*</td><td>.787*</td><td>.785</td><td>.759 .766</td><td>.766 .768*</td><td>5/6 6/6</td></tr></table>
+
+A few words of caution are in order here. Two ablation models did not improve the generalization of GNNs for the QM9 and the HIV datasets (see the column “# Improved”). This suggests an appropriate combination of attentions, gatings, and GRUs is essential in making the supernode effective for the analysis of molecular graph datasets.
+
+We shall emphasize that the goal of this study is not to find the specific network architecture that achieves the states of the art performance for selected datasets2. Instead, the goal of our work is propose an attachable module that improves the representation power and a generalization performance irrespective of the choice of GNN architecture. As we can see in the presented result, the attachment of GWM improves the result in most cases; one of the results of our GWM attached model for Tox21 is actually SOTA (0.787, achieved by GWM attached RGAT).
+
+# 5 CONCLUSION
+
+For a generic DNN, numerous effective installable modules have been proposed for the improvement of the model (e.g. (Srivastava et al., 2014; Ioffe & Szegedy, 2015; Miyato et al., 2018; He et al., 2016)). The proposed GWM is the first of its kind to be installed to a generic GNN as an auxiliary module. Experimental results show that the GWM can generally improve the representation power as well as the generalization performance of a GNN, irrespective of the choice of GNN architecture and the molecular graph datasets. We would like to emphasize that the choice of the internal structure of GWM is not limited to the ones we described in this study, and that there are possibly numerous ways to construct a GWM-like module. For example, there is no provable justification for the use of a linear transformation in the transmissions or a bilinear form in the attention coefficients $\alpha$ . Effective choices of supernode features are also open to further research. Our study can possibly open an entirely new avenue for the architectural study of GNNs.
+
+# REFERENCES
+
+Takuya Akiba, Shotaro Sano, Toshihiko Yanase, Takeru Ohta, and Masanori Koyama. Optuna: A Next-generation Hyperparameter Optimization Framework. In Proceedings of the ACM SIGKDD International Conference on Knowledge Discovery and Data Mining (KDD), 2019.
+
+anonymous. Global Relational Models of Source Code. OpenReview, pp. https://openreview.net/forum?id=B1lnbRNtwr, 2019.
+
+Peter W. Battaglia, Jessica B. Hamrick, Victor Bapst, Alvaro Sanchez-gonzalez, Vinicius Zambaldi, Mateusz Malinowski, Andrea Tacchetti, David Raposo, Adam Santoro, Ryan Faulkner, Caglar Gulcehre, Francis Song, Andrew Ballard, Justin Gilmer, George Dahl, Ashish Vaswani, Kelsey Allen, Charles Nash, Victoria Langston, Chris Dyer, Nicolas Heess, Daan Wierstra, Pushmeet Kohli, Matt Botvinick, Oriol Vinyals, Yujia Li, and Razvan Pascanu. Relational inductive biases , deep learning , and graph networks. arXiv, pp. 1806.01261v3 [cs.LG], 2018.
+
+Joan Bruna and Arthur Szlam. Spectral Networks and Deep Locally Connected Networks on Graphs. In Proceedings of the 2nd International Conference on Learning Representations (ICLR), 2014.
+
+Dan Busbridge, Dane Sherburn, Pietro Cavallo, and Nils Y. Hammerla. Relational Graph Attention Networks. OpenReview, 2018.
+
+Kyunghyun Cho, Bart Van Merriënboer, Caglar Gulcehre, Dzmitry Bahdanau, Fethi Bougares, Holger Schwenk, and Yoshua Bengio. Learning phrase representations using rnn encoder-decoder for statistical machine translation. In Proceedings of the 2014 Conference on Empirical Methods in Neural Language Processing (EMNLP), pp. 1724–1734, 2014.
+
+Michaël Defferrard, Xavier Bresson, and Pierre Vandergheynst. Convolutional Neural Networks on Graphs with Fast Localized Spectral Filtering. In Advances in Neural Information Processing Systems 29 (Proceedings of NIPS), 2016.
+
+David Duvenaud, Dougal Maclaurin, Jorge Aguilera-Iparraguirre, Rafael Gómez-Bombarelli, Timothy Hirzel, Alán Aspuru-Guzik, and Ryan P. Adams. Convolutional Networks on Graphs for Learning Molecular Fingerprints. In Advances in Neural Information Processing Systems 28 (Proceedings of NIPS), pp. 2224–2232, 2015. URL http://arxiv.org/abs/1509. 09292.
+
+Justin Gilmer, Samuel S. Schoenholz, Patrick F. Riley, Oriol Vinyals, and George E. Dahl. Neural Message Passing for Quantum Chemistry. In Proceedings of the 34th International Conference on Machine Learning (ICML), pp. 1263–1272, 2017. URL http://arxiv.org/abs/1704. 01212.
+
+Will Hamilton, Zhitao Ying, and Jure Leskovec. Inductive representation learning on large graphs. In Advances in Neural Information Processing Systems 30 (Proceedings of NIPS), 2017.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep Residual Learning for Image Recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 1–9, 2016. URL http://arxiv.org/abs/1512.03385.
+
+Sergey Ioffe and Christian Szegedy. Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift. In Proceedings of the 32nd International Conference on Machine Learning (ICML), pp. 448–456, 2015.
+
+Steven Kearnes, Kevin McCloskey, Marc Berndl, Vijay Pande, and Patrick Riley. Molecular graph convolutions: moving beyond fingerprints. Journal of Computer-Aided Molecular Design, 30(8): 595–608, 2016.
+
+Diederik P. Kingma and Jimmy Lei Ba. Adam: a Method for Stochastic Optimization. In Proceedings of the 3rd International Conference on Learning Representations (ICLR), 2015.
+
+Thomas N. Kipf and Max Welling. Semi-supervised Classification with Graph Convolutional Networks. In Proceedings of the 5th International Conference on Learning Representations (ICLR), 2017.
+
+Junying Li, Deng Cai, and Xiaofei He. Learning Graph-Level Representation for Drug Discovery. arXiv, pp. 1709.03741v2 [cs,LG], 2017.
+
+Qimai Li, Zhichao Han, and Xiao-ming Wu. Deeper Insights into Graph Convolutional Networks for Semi-supervised Learning. In Proceedings of the 32nd AAAI Conference on Artificial Intelligence (AAAI-18), 2018.
+
+Yujia Li, Daniel Tarlow, Marc Brockschmidt, and Richard Zemel. Gated Graph Sequence Neural Networks. In Proceedings of the 4th International Conference on Learning Representations (ICLR), 2016.
+
+Minh-Thang Luong, Hieu Pham, and Christopher D. Manning. Effective Approaches to Attentionbased Neural Machine Translation. In Proceedings of the 2015 Conference on Empirical Methods in Natural Language Processing (EMNLP), 2015.
+
+Takeru Miyato, Toshiki Kataoka, Masanori Koyama, and Yuichi Yoshida. Spectral Normalization for Generative Adversarial Networks. In Proceedings of the 6th International Conference on Learning Representations (ICLR), 2018.
+
+Trang Pham, Truyen Tran, Hoa Dam, and Svetha Venkatesh. Graph Classification via Deep Learning with Virtual Nodes. arXiv, pp. 1708.04357v1, 2017.
+
+Raghunathan Ramakrishnan, Pavlo O. Dral, Matthias Rupp, and O. Anatole von Lilienfeld. Quantum chemistry structures and properties of 134 kilo molecules. Scientific Data, 1:140022, 2014.
+
+Lars Ruddigkeit, Ruud van Deursen, Lorenz C. Blum, and Reymond Jean-Louis. Enumeration of 166 billion organic small molecules in the chemical universe database gdb-17. Journal of chemical information and modeling, 52(11):2864–2875, 2012.
+
+Michael Schlichtkrull, Thomas N. Kipf, Peter Bloem, Rianne van den Berg, Ivan Titov, and Max Welling. Modeling Relational Data with Graph Convolutional Networks. arXiv, pp. 1703.06103v4 [stat.ML], 2017.
+
+Chao Shang, Qinqing Liu, Ko-shin Chen, Jiangwen Sun, Jin Lu, Jinfeng Yi, and Jinbo Bi. Edge Attention-based Multi-Relational Graph Convolutional Networks. arXiv, pp. 1802.04944v1 [stat.ML], 2018.
+
+Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: A Simple Way of Prevent Neural Networks from Overfitting. Journal of Machine Learning Research, 15:1929–1958, 2014.
+
+Seiya Tokui, Kenta Oono, Shohei Hido, and Justin Clayton. Chainer: a Next-Generation Open Source Framework for Deep Learning. In Proceedings of Workshop on Machine Learning Systems (LearningSys) in The Twenty-ninth Annual Conference on Neural Information Processing Systems (NIPS), 2015. URL https://chainer.org/.
+
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention Is All You Need. In Advances in Neural Information Processing Systems 30 (Proceedings of NIPS), 2017.
+
+Petar Velickovi ˇ c, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Liò, and Yoshua ´ Bengio. Graph Attention Networks. In Proceedings of the 6th International Conference on Learning Representations (ICLR), 2018.
+
+Xiaolong Wang, Ross Girshick, Abhinav Gupta, and Kaiming He. Non-local Neural Networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2018.
+
+Zhenqin Wu, Bharath Ramsundar, Evan N Feinberg, Joseph Gomes, Caleb Geniesse, Aneesh S Pappu, Karl Leswing, and Vijay Pande. MoleculeNet : A Benchmark for Molecular Machine Learning. Chemical Science, 9(2):513–530, 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 (ICLR), 2019.
+
+Kevin Yang, Kyle Swanson, Wengong Jin, Connor Coley, Philipp Eiden, Hua Gao, Angel GuzmanPerez, Timothy Hopper, Brian Kelley, Miriam Mathea, Andrew Palmer, Volker Settels, Tommi Jaakkola, Klavs Jensen, and Regina Barzilay. Are Learned Molecular Representations Ready For Prime Time? arXiv, pp. 1904.01561, 2019.
+
+Rex Ying, Jiaxuan You, Christopher Morris, Xiang Ren, William L. Hamilton, and Jure Leskovec. Hierarchical Graph Representation Learning with Differentiable Pooling. In Advances in Neural Information Processing Systems 31 (Proceedings of NeurIPS), 2018.
+
+# A OUR FORMULATION OF RGAT
+
+Apart from the original RGAT (Busbridge et al., 2018), we have developed a similar GNN in a slightly different formulation. Followings are our RGAT formulation:
+
+$$
+\begin{array} { r } { h _ { \ell + 1 , i } = \mathrm { t a n h } \left( W _ { l } \mathbf { c o n c a t } _ { k = 1 } ^ { K } \tilde { h } _ { \ell , i , k } \right) , \ } \\ { \tilde { h } _ { \ell , i , k } = F _ { \ell , k } h _ { \ell , i } + \displaystyle \sum _ { j \in N _ { i } } \alpha _ { i , j , k } G _ { \ell , k } h _ { \ell , j } , \ } \\ { \alpha _ { i , j , k } = \mathbf { s o f t m a x } \left( a \left( h _ { \ell , i } , h _ { \ell , j } ; A _ { \ell , k , e _ { i , j } } \right) \right) . \ } \\ { a \left( h _ { \ell , i } , h _ { \ell , j } ; A _ { \ell , k , e _ { i , j } } \right) = h _ { \ell , i } ^ { T } A _ { \ell , k , e _ { i , j } } h _ { \ell , j } . \ } \end{array}
+$$
+
+$W , F , G , A$ are the coefficient matrix to be tuned. $\ell$ is the index of the layer up to $L , k$ is the index of the attention head up to $K , i , j$ are the index of the nodes up to $N$ , $e _ { i , j } = r$ is the index of the edge type up to $R$ .
+
+The main point is the edge type information in Eq.13. The edge type $e _ { i , j } = r$ switches the weight matrix of the attention similarity function, $a$ . This means that the associations between nodes should be computed dependent on the edge type. This is a natural assumption for chemical molecular graphs. Typically we have multiple bond types between nodes $=$ atoms: single-bond, double-bound, triple-bond, and the aromatic ring. It is natural to assume that interactions between atoms are affected by the bond types among the atoms.
+
+The main differences from the original RGAT lie in the Eq.11. The original RGAT assumes that the weight matrix $G$ is also dependent on the edge type $( G _ { \ell , k , e _ { i , j } } )$ while we omit this dependency. Also, the original RGAT does not provide a self-link weight matrix $F$ while we do. We made these changes based on our preliminary experiments. We found our formulation is better than the original RGAT formulation in the MoleculeNet dataset, in terms of the training stability and the generalization performances.
+
+Another difference is the choice of the attention function. In our formulation, the attention similarity measure $a ( \cdot )$ is defined by the general attention in (Luong et al., 2015) while the original GAT (Velickovi ˇ c et al., 2018) and the RGAT (Busbridge et al., 2018) employed a simpler ´ concat attention.
+
+# B OUR IMPLEMENTATION OF GIN
+
+We implement the simplest GIN: 2-layer MLP with ReLU activation for each layer and a bias parameter $\epsilon$ fixed at 0. We regularize GIN with dropout (Srivastava et al., 2014), instead of batchnormalization (Ioffe & Szegedy, 2015). This is because the batch-normalization of the ChainerChemistry library did not correctly treat the padded node elements in the minibatches when we conducted the experiments.
+
+# C EXPERIMENTS DETAILS: GENERAL ISSUES
+
+# C.1 GRAPH DATA REPRESENTATION
+
+All datasets used in our experiments are taken from the MoleculeNet(Wu et al., 2018). Four used datasets are provided in the SMILES format. A SMILES format is a line notation for describing the structure of chemical compounds. We decode a SMILES molecular data into a graph representation of the molecule. A node in the graph corresponds to an atom. Each atom node is associated with the symbolic label of the atom name (“H”, “C”, ...). An edge in the graph corresponds to a bond between atoms. Each bond edge is associated with the bond type information (single-, double-, ....).
+
+Given the graph, we extract input feature vectors for node $x _ { i }$ and that of supernode $x ^ { \prime }$ . $x _ { i }$ , the input feature vector for the node $i$ is a $D$ -dimensional continuous vector, which is an embedded vector of the one-hot atom label vector with a trainable linear transformation. $X ^ { \prime }$ , The input feature vector for the supernode is a $D ^ { \prime }$ -dimensional continuous vector, which again is an embedded vector of some graph-global features with a trainable linear transformation. Choices for the graph-global features are detailed in the following section.
+
+The edge information is converted in an adjacency matrix, $\mathcal { A }$
+
+# C.2 EXPLICIT FEATURES FOR SUPERNODE
+
+Since the supernode does not exist in the original graph $G$ , we have no observable cues for the supernode. For simplicity, we propose to use an aggregation of node features, such as:
+
+• Histograms of discrete labels attached to original nodes   
+• Averages, maximums, minimums, or medians of numerical attributes attached to original nodes   
+• Histograms of edge types if the graph is multiple relational graph.   
+• Number of nodes, graph diameters, modularity, and other simple statistics for graph structure.
+
+We can augment the super feature vector $x ^ { \prime }$ if some additional information about the graph is provided. Essentially, these simple aggregations of the feature vectors do not bring new information into the network. However we found that the graph-wise super feature input boosts the performance of the learned network model.
+
+# C.3 DATA SPLITS
+
+In chemical datasets, a totally random shuffling of samples into train/val/test subsets is not always a valid way of data splitting. Therefore MoleculeNet provides several ways of data splitting. The “random” split is the random sample shuffling that are most familiar to the machine learning community. The “scaffold” split separate samples based on the molecular two-dimensional structure. Since the scaffold split separates structurally different molecules into different subsets, “it offers a greater challenge for learning algorithms than the random split” (Wu et al., 2018). Throughout the paper, we adopt the scaffold split to assess the full potential of the GWM-attaching GNNs.
+
+The actual construction of the scaffold split train/validation/test subsets has a freedom of algorithm choices. We basically adopted the algorithm provided by the deepchem3 library, which is the standard split algorithm for many papers. However, for the experiment of train/test loss comparison, we adopted the algorithm provided by the Chainer Chemistry library.
+
+# C.4 READOUT LAYER
+
+In many applications of GNNs users may expect a single fixed-length vector representing the characteristics of the graph $G$ . So we add the ’readout’ layer to aggregate the original node hidden states $\{ H _ { \ell } \}$ and the global node hidden states $\{ g _ { \ell } \}$ .
+
+A main issue in the readout unit is how to aggregate the original nodes, whose number varies for each graph. A simple way is to take an arithmetic average (sum) of the $h \mathrm { s }$ at the $L$ -th layer, but we can also use a DNN to compute (non-linear) “average” of $h \mathrm { s }$ (Li et al., 2016; Gilmer et al., 2017). After the aggregation of the node hidden states, we simply concatenate it with $g \mathbf { s }$ and apply some transformations to achieve the readout vector, $r$ :
+
+$$
+r = { \bf D N N } _ { r 1 } \left( \mathrm { c o n c a t } \left[ { \bf D N N } _ { r 2 } \left( H _ { L } \right) , g _ { L } \right] \right) .
+$$
+
+In the above equation, $\mathrm { D N N } _ { r 1 }$ is a multi-layer perceptron or a fully connected layer to mix the concatenated hidden vectors. We adopted a simple fully-connected layer for $\mathrm { D N N } _ { r 1 }$ in this paper. $\mathrm { D N N } _ { r 2 }$ is a specific readout unit accompanied with a original GNN to aggregate variable-length $H _ { L }$ .
+
+# C.5 OPTIMIZER
+
+All models were trained with Adam (Kingma & Ba, 2015), $\alpha = 0 . 0 0 1$ , $\beta _ { 1 } = 0 . 9$ , and $\beta _ { 2 } = 0 . 9 9 9$ .
+
+C.6 ABLATION MODELS FORMULATION
+
+Here we detail the formulation of the ablation models used in the main comparison experiments (Sec.   
+4.4).
+
+As written in the main manuscript, we formulate the two ablation models (Table 1) as follows. A simple supernode model is an ablation model without attentions, gates, nor the GRUs, and it can be considered as a variant of (Li et al., 2017; Pham et al., 2017) with bidirectional communication between the supernode and the bulk, omitting all attentions and gates. First, there is no attention for the Transmitter. So the message from the main nodes to the supernode is just a sum of hidden vectors, $h _ { \ell - 1 , : }$ :
+
+$$
+h _ { \ell } ^ { \mathrm { m i n \to s u p e r } } = \operatorname { t a n h } \left( W _ { \ell } \sum _ { i } h _ { \ell - 1 , i } \right) \in \mathbb { R } ^ { D ^ { \prime } } .
+$$
+
+Originally there is no messages from the supernode to the main GNN in (Li et al., 2017), but we allow such a simple message in this ablation model:
+
+$$
+g _ { \ell } ^ { \mathrm { s u p e r }  \mathrm { m a i n } } = \operatorname { t a n h } ( F _ { \ell } g _ { \ell - 1 } ) \in \mathbb { R } ^ { D ^ { \prime } } .
+$$
+
+Messages are merged by simple linear combinations, instead of gates and GRUs, following (Li et al., 2017):
+
+$$
+\begin{array} { r } { h _ { \ell , i } = Z _ { \ell , 1 } \hat { h } _ { \ell , i } + Z _ { \ell , 2 } g _ { \ell } ^ { \mathrm { s u p e r \to m a i n } } \in \mathbb { R } ^ { D } , } \\ { g _ { \ell } = Z _ { \ell , 1 } ^ { ( S ) } h _ { \ell } ^ { \mathrm { m a i n \to s u p e r } } + Z _ { \ell , 2 } ^ { ( S ) } \hat { g } _ { \ell } \in \mathbb { R } ^ { D ^ { \prime } } . } \end{array}
+$$
+
+We find it difficult to fully recover the supernode of (Gilmer et al., 2017) since their description on the supernode is quite limited. Thus, a NoGate GWM model, which surrogates (Gilmer et al., 2017), only capture the essence of their supernode: no gatings for merger, and GRU is not installed for the nodes of the main GNN. In this model, we use the same attention-based Transmitter unit as in Eqs.(2-6). We reduce the adaptive gatings in the Warp unit by a simple averaging, and omit the GRU for $h _ { \ell , i }$ .
+
+$$
+\begin{array} { r l } & { h _ { \ell , i } ^ { 0 } = Z _ { \ell , 1 } \hat { h } _ { \ell - 1 , i } + Z _ { \ell , 2 } g _ { \ell } ^ { \mathrm { s u p e r \to m a i n } } \in \mathbb { R } ^ { D } , } \\ & { \quad g _ { \ell } ^ { 0 } = Z _ { \ell , 1 } ^ { ( S ) } h _ { \ell } ^ { \mathrm { m a i n \to s u p e r } } + Z _ { \ell , 2 } ^ { ( S ) } \hat { g } _ { \ell } \in \mathbb { R } ^ { D ^ { \prime } } , } \\ & { \quad \quad \quad h _ { \ell , i } = h _ { \ell , i } ^ { 0 } \in \mathbb { R } ^ { D } , } \\ & { \quad \quad \quad g _ { \ell } = \mathbf { G } \mathbf { R } \mathbf { U } \left( g _ { \ell - 1 } , g _ { \ell } ^ { 0 } \right) \in \mathbb { R } ^ { D ^ { \prime } } . } \end{array}
+$$
+
+# C.7 HYPERPARAMETER
+
+We fix a part of hyperparameters throughout the experiments, which does not influence performances so much: the number of heads in all multi-head attention mechanisms to $K = 8$ , and used $R = 4$ edge types for the multi-relational mechanism in all models. Also, at every layer, we set the dimension of the supernode feature to be the same as that of the features of the nodes in the main GNN.
+
+In the next section, we list the other hyperparameters (the number of layers $L$ , the dimension of feature vectors $D ( = D ^ { \prime } )$ ) used in several experiments/figures, as well other experimental/implementation details.
+
+# C.8 COMPUTATIONAL ENVIRONMENT
+
+We use a single GPU (mainly nvidia Tesla V100) for an experimental run. A run roughly takes 1 hour to 1 day, depending on the hyperparameters and the GNN models.
+
+![](images/8beef3ad30831e3ca451cef4ec31e7676265bb73aaabc23765b5222e981a3337.jpg)  
+Figure 4: Training losses of various GNN models on a molecule graph dataset (Tox21). The horizontal axis denotes the number of GNN layers (the left panel) or the dimension of the node feature vectors (the right panel). Color denotes the GNN model. Thinner dashed lines are the losses of the vanilla GNNs, while thicker solid lines show the losses of the GNNs attached with the proposed Graph Warp Module (“GWM”). Scores are partially unavailable due to memory shortages.
+
+# D EXPERIMENTS DETAILS: FOR EACH EXPERIMENT
+
+In this section, we report details for each experiment, including the chosen hyperparameters and additional results.
+
+D.1 TRAINING LOSS BEHAVIORS OVER NUMBER OF LAYERS AND EMBEDDING DIMENSIONS
+
+We used the Tox21 dataset to confirm behaviors of training losses, mentioned in the first paragraph of the introduction (Fig. 4).
+
+To study the effect of the number of layers $L$ (the left panel), we fixed the dimension $D = 3 2$ . To study the effect of the feature vector dimensions $D$ (the right panel), we fixed the number of layers $L = 4$ .
+
+All models are trained for 30 epochs.
+
+Thinner dashed lines in Fig. 4 plot the training losses of original networks (w/o GWM). Thick solid lines in Fig. 4 plot the training losses of networks augmented with GWM. In general, GWM has an effect of decreasing the training loss for most choices of numbers of layers and dimensions of the node feature vectors, for all GNNs. In general, similar results are obtained from the other three datasets so we omit these figures.
+
+# D.2 SECTION 4.3: TRAIN AND TEST LOSS REDUCTION
+
+In the experiment in the Section 4.3 (Fig. 1), we align the hyperparameters including $L , D$ among a vanilla GNN and its GWM-installed counterpart, to compare the loss function values. We used four datasets. For each dataset, we fixed $L$ and $D$ for all GNN models to compare the loss reduction performances.
+
+In Fig. 1, $L = 3$ and $D = 5 0$ for all GNNs and datasets. In preliminary experiments, we manually changed Ls $( \in \{ 2 , 3 , 4 \} )$ and $D \mathrm { s } \left( \in 3 2 , 5 0 , 1 0 0 , 1 5 0 \right)$ in some extent, but found the overall tendency of the scatter plots does not dramatically change. This is partially understood from the Figure 1 in the main manuscript: the loss curves of the vanilla GNNs and their GWM-augmented counterparts evolve in roughly parallel. This implies the ratios of loss reductions are not so much dependent on the hyperparameter choices.
+
+Here we show the results of other hyperparameter settings. All cases we observe the similar plot patterns.
+
+Fig. 5 is the scatter plot of the $\left( \bar { r } _ { t r a i n } , \bar { r } _ { l o s s } \right)$ , $L = 3$ and $D = 3 2$ . In this case, two HIV dataset plus one case for QM9 reported the increase of the training loss. For other 13 pairs, the GWM successfully reduce the training losses. It is remarkable that all 16 plots have positive test loss reduction rates: namely, the generalization performances are improved by the GWM in this choice of the hyperparameters.
+
+![](images/5bf18d9b8499058b40fb299d5202275656f5542bf60d8b9901237dd936fea7fe.jpg)  
+Figure 5: Train (horizontal) and test (vertical) loss reduction ratios on various pairs of GNN models and datasets. $L = 3$ , $D = 3 2$ . Each plot presents the rational train/test loss reductions induced by the GWM attachment for a specific pair of (dataset(symbol), GNN(color)).
+
+![](images/58c3531d7a8e2f7abbc4e241f2c44e76386af6c104759935c1d07c506b039785.jpg)  
+Figure 6: Train (horizontal) and test (vertical) loss reduction ratios on various pairs of GNN models and datasets. $L = 4$ , $D = 1 0 0$ . Each plot presents the rational train/test loss reductions induced by the GWM attachment for a specific pair of (dataset(symbol), GNN(color)).
+
+Fig. 6 is the scatter plot of the $\left( \bar { r } _ { t r a i n } , \bar { r } _ { l o s s } \right)$ , $L = 4$ and $D = 1 0 0$ . In this case, only two cases of the HIV datasets record the negative $\bar { r } _ { t r a i n }$ values. For other 14 pairs, the GWM successfully reduce the training losses and 13 out of these 14 pairs have positive $\bar { r } _ { t e s t } { \bf s }$ .
+
+All models were trained for 30 epochs.
+
+D.3 SECTION 4.4: THE FULL COMPARISON
+
+For the experiments in the Section 4.3 (Table 2 and 3 in the main manuscript), we employed the Bayesian optimization to tune $L$ and $D$ for each combinations of a dataset and a GNN model. The Bayesian optimization (BO) trials were conducted by the Optuna library, with 200 sampling (searches) for each combination. Ranges of the BO search is: $2 \leq L \leq 8$ , $4 \le D \le 5 1 2$ .
+
+Chosen $L s$ and $D \mathrm { s }$ are presented in the Table 4.
+
+Note that GWM-attached GNNs tend to perform better with deeper architecture (i.e larger $L$ ), when the vanilla GNNs without GWM do not change its overall performance with the number of layers (Table 4). The performance of the GWM-attached models often improve with the number of layers until the model depth reaches quite a large number ( 8) (e.g. [QM9, GGNN+Proposed GWM], [HIV, GIN $+$ Proposed GWM]). Out of 24 pairs $_ { \cdot = 4 }$ datasets $\times ~ 6$ GNN models), 11 pairs perform better with deeper architecture when deployed with GWM.
+
+For the QM9 dataset, we trained the models for 50 epochs. For the HIV and the Tox21 dataset, we trained the models for 100 epochs. For the LIPO dataset, we trained the models for 200 epochs.
+
+<table><tr><td rowspan=1 colspan=1>Dataset</td><td rowspan=1 colspan=1>GNN model</td><td rowspan=1 colspan=1>NFP</td><td rowspan=1 colspan=1>WeaveNet</td><td rowspan=1 colspan=1>RGAT</td><td rowspan=1 colspan=1>GGNN</td><td rowspan=1 colspan=1>RSGCN</td><td rowspan=1 colspan=1>GIN</td></tr><tr><td rowspan=3 colspan=1>LIPO</td><td rowspan=3 colspan=1>vanilla GNN+Simple Supernode+NoGate GWM+Proposed GWM</td><td rowspan=3 colspan=1>(4,232)(2,71)(2,65)(5,231)</td><td rowspan=3 colspan=1>(3,50)(3,9)(2,14)(4,15)</td><td rowspan=1 colspan=1>(4,9)(3,8)</td><td rowspan=1 colspan=1>(4,32)(4,18)</td><td rowspan=3 colspan=1>(5,19)(2,27)(2,15)(4,22)</td><td rowspan=3 colspan=1>(6,19)(3,14)(6,9)(2,26)</td></tr><tr><td rowspan=1 colspan=1>(3,12)</td><td rowspan=2 colspan=1>(5,30)(6,127)</td></tr><tr><td rowspan=1 colspan=1>(5,19)</td></tr><tr><td rowspan=1 colspan=1>QM9</td><td rowspan=1 colspan=1>vanilla GNN+Simple Supernode+NoGate GWM+Proposed GWM</td><td rowspan=1 colspan=1>(5,86)(5,44)(4,48)(5,72)</td><td rowspan=1 colspan=1>(3,22)(3,111)(5,250)(3,104)</td><td rowspan=1 colspan=1>(4,40)(6,34)(4,31)(4,156)</td><td rowspan=1 colspan=1>(5,71)(5,60)(6,50)(8,50)</td><td rowspan=1 colspan=1>(4,100)(5,69)(4,48)(4,36)</td><td rowspan=1 colspan=1>(4,250)(3,22)(4,34)(4,23)</td></tr><tr><td rowspan=1 colspan=1>HIV</td><td rowspan=1 colspan=1>vanilla GNN+Simple supernode+NoGate GWM+Proposed GWM</td><td rowspan=1 colspan=1>(6,213)(3,30)(4,46)(3,200)</td><td rowspan=1 colspan=1>(2,65)(3,39)(3,20)(3,92)</td><td rowspan=1 colspan=1>(3,28)(2,9)(2,12)(3,23)</td><td rowspan=1 colspan=1>(6,29)(4,54)(2,51)(8,135)</td><td rowspan=1 colspan=1>(4,57)(4,255)(3,27)(3,106)</td><td rowspan=1 colspan=1>(2,72)(5,93)(3,60)(8,38)</td></tr><tr><td rowspan=2 colspan=1>Tox21</td><td rowspan=2 colspan=1>vanilla GNN+Simple supernode+NoGate GWM+Proposed GWM</td><td rowspan=2 colspan=1>(3,204)(5,129)(2,123)(3,106)</td><td rowspan=2 colspan=1>(5,90)(6,31)(2,157)(4,19)</td><td rowspan=1 colspan=1>(3,19)</td><td rowspan=1 colspan=1>(6,36)</td><td rowspan=2 colspan=1>(5,70)(5,119)(4,31)(8,32)</td><td rowspan=2 colspan=1>(5,103)(5,157)(6,117)(6,102)</td></tr><tr><td rowspan=1 colspan=1>(2,36)(3,43)(3,37)</td><td rowspan=1 colspan=1>(6,136)(5,79)(7,48)</td></tr></table>
+
+Table 4: Hyperparameters $L$ and $D$ for the experiment in Section 4.4. The format of the table cells is: $( L , D )$ .
+
+Tables 5 and 6 are the full lists of the main comparison experiments in the main manuscript, with the standard deviation values in parentheses.
+
+<table><tr><td rowspan=2 colspan=3>（954)444(770) 653(840) 448.（110) *481511414.44(11) *1151111355111.1) 7.1GIN</td></tr><tr><td rowspan=1 colspan=1>（954)444(770) 653(840) 448.（110) *4815</td><td rowspan=1 colspan=1>11414.44(11) *1151111355111.1) 7.1</td></tr><tr><td rowspan=1 colspan=1>PSSCN</td><td rowspan=1 colspan=1>(000.)117.(110) LL(840) 781（14114</td><td rowspan=1 colspan=1>175.55.55[11:1) .71111555554(84/1) *615</td></tr><tr><td rowspan=1 colspan=1>SNNN</td><td rowspan=1 colspan=1>35535315（654) 447.3573.).3325(570.) *3755</td><td rowspan=1 colspan=1>17451554J5111111543:524(337) *3.5</td></tr><tr><td rowspan=1 colspan=1>RAAY</td><td rowspan=1 colspan=1>(75551155（71012154(£10) 889(910&#x27;)*6$9°</td><td rowspan=1 colspan=1>(761) 968（660) 00.685 35.6(637) *38</td></tr><tr><td rowspan=1 colspan=1>Maaeeee</td><td rowspan=1 colspan=1>(7111 777(717:) 11.0(711 3155(S01&#x27;) *889*</td><td rowspan=1 colspan=1>635) 33.933555153332) *3553855) 56.4</td></tr><tr><td rowspan=1 colspan=1>JH</td><td rowspan=1 colspan=1>(040:) LL9&#x27;(777.)3679(/1.) 1/9.(40.) *7/9.</td><td rowspan=1 colspan=1>1151 5511711)89.6(855)55.9(095) *59.9</td></tr><tr><td rowspan=1 colspan=1>GNPou Nng</td><td rowspan=1 colspan=1>Tprrsnt sreeie1N GteN1PP PosocoNNG eA</td><td rowspan=1 colspan=1>Tpruursnt srrritgJN tEN1PP posodoYin JiiNN</td></tr><tr><td rowspan=1 colspan=1>Jaaeter</td><td rowspan=1 colspan=1>OdII</td><td rowspan=1 colspan=1>6NO</td></tr></table>
+
+<table><tr><td rowspan=1 colspan=2>1170) 600(173) 5555113 7111（600） *S55*GIN</td><td rowspan=1 colspan=1>(/00) 04L（900)95(800&#x27;) 99L&#x27;（∠00) *89L’</td></tr><tr><td rowspan=1 colspan=1>PPSCN</td><td rowspan=1 colspan=1>(111.) 111.(600) 87（741)4（173 *3254</td><td rowspan=1 colspan=1>(700) 095(900） *0LL(/00) 655(900) 69L&#x27;</td></tr><tr><td rowspan=1 colspan=1>GNNN</td><td rowspan=1 colspan=1>(810)944)(410) *94（900) )(910) 794</td><td rowspan=1 colspan=1>(600)496(900&#x27;) 06L&#x27;(800) *76L(100) 185</td></tr><tr><td rowspan=1 colspan=1>RAAT</td><td rowspan=1 colspan=1>(710.770(110) 441.1472/9544（610) *847.</td><td rowspan=1 colspan=1>(100)4404（S00) *∠82(600&#x27;) 98L(600&#x27;) *L8L’</td></tr><tr><td rowspan=1 colspan=1>Mwaeeeee</td><td rowspan=1 colspan=1>(170.) 0079(130.) 957.(£40) 089(010&#x27;) *189*</td><td rowspan=1 colspan=1>(771) 0004(115 11(110) 411（170） *∠9L</td></tr><tr><td rowspan=1 colspan=1>NHH</td><td rowspan=1 colspan=1>(/11)7(773) 1535（810)4111113*33100</td><td rowspan=1 colspan=1>(100)395(800&#x27;) 0LL&#x27;(L00) *SLL(∠00&#x27;) 69L’</td></tr><tr><td rowspan=1 colspan=1>GPow Nng</td><td rowspan=1 colspan=1>Tprans sreeiteTN eENNNnl eiN1rp posocood</td><td rowspan=1 colspan=1>Tprnrrn saaritJn GteNPip ppsocoNNnn el</td></tr><tr><td rowspan=1 colspan=2>Jareter</td><td rowspan=1 colspan=1>[7X01</td></tr></table>
+
+Finally we present the detailed reports on the sub-tasks of QM9 and Tox21. These datasets consists of 12 sub-tasks and so far we reported the sub-task-averaged scores. Below we report the scores changes brought by GWM-attached GNNs in Table 7 (QM9) and Table 8 (Tox21). For QM9, we report the relative reductions of MAE in percentage $( \% )$ . For Tox21, we report the improvements of binary classification accuracy in percentage $( \% )$ . Numbers of sub-tasks improved by GWM (positive value slots) are in good accordance with the score gains in Table 2 and Table 3.
+
+Table 7: Relative reduction of MAE $( \% )$ ) GWM, 12 tasks in QM9. Larger values are better.   
+
+<table><tr><td>GNN/Tasks</td><td>mu</td><td>alpha</td><td>HOMO</td><td>LUMO</td><td>gap</td><td>r2</td><td>zpve</td><td>cv</td><td>u0</td><td>u298</td><td>h298</td><td>g298</td></tr><tr><td>GGNN</td><td>-0.6</td><td>-0.9</td><td>1.0</td><td>1.6</td><td>4.6</td><td>2.9</td><td>19</td><td>0.3</td><td>-3.9</td><td>-4.8</td><td>-8.3</td><td>-4.2</td></tr><tr><td>WeaveNet</td><td>-2.2</td><td>-0.3</td><td>27</td><td>-35</td><td>52</td><td>6.7</td><td>107</td><td>-11</td><td>84</td><td>91</td><td>86</td><td>87</td></tr></table>
+
+Table 8: Improvements of binary classification accuracy $( \% )$ by GWM, 12 tasks in Tox21. Larger values are better.   
+
+<table><tr><td>GNN/Tasks</td><td>Task1</td><td>Task2</td><td>Task3</td><td>Task4</td><td>Task5</td><td>Task6</td></tr><tr><td>RGAT GGNN</td><td>0.9 0.0</td><td>0.2 3.7</td><td>0.7 2.1</td><td>0.5 1.1</td><td>1.2 1.5</td><td>0.2 16</td></tr><tr><td>GNN/Tasks</td><td>Task7</td><td>Task8</td><td>Task9</td><td>Task10</td><td>Task11</td><td>Task12</td></tr><tr><td>RGAT GGNN</td><td>-0.5 5.9</td><td>1.2 2.8</td><td>-0.0 0.7</td><td>0.2 1.0</td><td>1.9 2.4</td><td>0.4 1.5</td></tr></table>

parse/train/Wz-t1oOTWa/Wz-t1oOTWa.md

@@ -0,0 +1,522 @@
+# Linear Contextual Bandits with Adversarial Corruptions
+
+Anonymous Author(s)   
+Affiliation   
+Address   
+email
+
+# Abstract
+
+1 We study the linear contextual bandits problem in the presence of adversarial   
+2 corruption, where the interaction between the player and a possibly infinite decision   
+3 set is contaminated by an adversary that can corrupt the reward up to a corruption   
+4 level $C$ measured by the sum of the largest alteration on rewards in each round.   
+5 We present a variance-aware algorithm that is adaptive to the level of adversarial   
+6 contamination $C$ . The key algorithmic design includes (1) a multi-level partition   
+7 scheme of the observed data, (2) a cascade of confidence sets that are adaptive to   
+8 the level of the corruption, and (3) a variance-aware confidence set construction   
+9 that can take advantage of low-variance reward. We further prove that the regret   
+10 of the proposed algorithm is $\widetilde { O } ( C ^ { 2 } d \sqrt { \textstyle \sum _ { t = 1 } ^ { T } \sigma _ { t } ^ { 2 } } + C ^ { 2 } \sqrt { d T } + C R \sqrt { d T } )$ , where   
+11 $d$ is the dimension of context vectors, $T$ is the number of rounds, $R$ is the range   
+12 of noise and $\sigma _ { t } ^ { 2 } , t = 1 \ldots , T$ are the variances of instantaneous reward. We also   
+13 prove a gap-dependent regret bound for the proposed algorithm, which is instance  
+14 dependent and thus leads to better performance on good practical instances. To the   
+15 best of our knowledge, this is the first variance-aware corruption robust algorithm   
+16 for contextual bandits.
+
+# 17 1 Introduction
+
+18 Multi-armed bandits algorithms are widely applied in online advertising (Li et al., 2010), clinical   
+19 trials (Villar et al., 2015), recommendation system (Deshpande and Montanari, 2012) and many other   
+20 real-world tasks. In the model of multi-armed bandits, the algorithm needs to decide which action   
+21 (or arm) to take (or pull) at each round and receive a reward for the chosen action. In the stochastic   
+22 setting, the reward is subject to a fixed but unknown distribution for each action. In reality, however,   
+23 these rewards can easily be “corrupted” by some malicious users. A typical example is click fraud   
+24 (Lykouris et al., 2018), where botnets simulate the legitimate users clicking on an ad to fool the   
+25 recommendation systems. This motivates the studies of the bandits algorithms that are robust to   
+26 adversarial corruptions.   
+27 For example, Lykouris et al. (2018) introduced a bandit model in which an adversary could corrupt   
+28 the stochastic reward generated by an arm pull. They proposed an algorithm and show that the   
+29 regret of this “middle ground” scenario degrades smoothly with the amount of corruption injected   
+30 by the adversary. Gupta et al. (2019) proposed an alternative algorithm which gives a significant   
+31 improvement in regret.   
+32 While the algorithms that are robust to the corruptions have been studied in the setting of multi-armed   
+33 bandits in a number of prior works, they are still understudied in the setting of linear contextual   
+34 bandits. The linear contextual bandits problem can be regarded as an extension of the multi-armed   
+35 bandit problem to linear optimization, in order to tackle an unfixed and possibly infinite set of feasible   
+36 actions. There is a large body of literature on efficient algorithms for linear contextual bandits with   
+37 no corruptions (Abe et al., 2003; Auer, 2002; Chu et al., 2011; Dani et al., 2008; Rusmevichientong   
+38 and Tsitsiklis, 2010; Abbasi-Yadkori et al., 2011; Li et al., 2019b), to mention a few. The significance   
+39 of this setting lies in the fact that linear regression approaches are widely used in recommendation   
+40 systems and advertising (Li et al., 2010; Jhalani et al., 2016; Deshpande and Montanari, 2012). Linear   
+41 contextual bandits with adversarial corruptions is an arguably more challenging setting since most of   
+42 the previous corruption-robust algorithms are based on the idea of action elimination (Lykouris et al.,   
+43 2018; Gupta et al., 2019; Bogunovic et al., 2021), which is not applicable to the contextual bandits   
+44 settings where the decision set is time varying and possibly infinite at each round. In Garcelon et al.   
+45 (2020), it is shown that a malicious agent can force a linear contextual bandit algorithm to take any   
+46 desired action $T - o ( T )$ times over $T$ rounds, while applying adversarial corruptions to rewards with   
+47 a cumulative cost that only grow logarithmically. This poses a big challenge for designing corruption   
+48 robust algorithms for linear contextual bandits.   
+49 In this paper, we make a first attempt to study a linear contextual bandit model where an adversary   
+50 can corrupt the rewards up to a corruption level $C$ , which is defined as the the sum of biggest   
+51 alteration the adversary made on rewards in each round. We propose a linear contextual bandits   
+52 algorithm that is robust to reward corruption, dubbed multi-level optimism-in-the-face-of-uncertainty   
+53 weighted learning (Multi-level OFUL). More specifically, our algorithm consists of the following   
+54 novel techniques: (1) We design a multi-level partition scheme and adopt the idea of sub-sampling to   
+55 do the robust estimation of the model parameters; (2) We maintain a cascade of candidate confidence   
+56 sets corresponding to different corruption level (which is unknown) and randomly select a confidence   
+57 set at each round to take the action; and (3) We design confidence sets that depend on the variances   
+58 of rewards, which lead to a potentially tighter regret bound.
+
+59 Our contributions are summarized as follows:
+
+• We propose a variance-aware algorithm which is adaptive to the amount of adversarial corruptions $C$ . To the best of our knowledge, it is the first algorithm for the setting of linear contextual bandits 2 with adversarial corruptions which does not rely on the finite number of actions and other additional 3 assumptions.
+
+• We prove that the regret of our algorithm is in 64 $\begin{array} { r } { \widetilde { O } \left( C ^ { 2 } d \sqrt { \sum _ { t = 1 } ^ { T } \sigma _ { t } ^ { 2 } } + C ^ { 2 } \sqrt { d T } + C R \sqrt { d T } \right) } \end{array}$ , where   
+65 $d$ is the dimension of context vectors, $T$ is the number of rounds, $R$ is the range of noise and $\sigma _ { t } ^ { 2 } , t =$   
+66 $1 \ldots , T$ are the variances of instantaneous reward. Our regret upper bound has a multiplicative   
+67 dependence on $C ^ { 2 }$ which indicates that our algorithm achieves a sub-linear regret when the   
+68 corruption level satisfies $C = o ( T ^ { 1 / 4 } )$ .
+
+• We also derive a gap-dependent regret bound $\begin{array} { r } { \widetilde { O } \left( \frac { 1 } { \Delta } \cdot C ^ { 2 } R ^ { 2 } d + \frac { 1 } { \Delta } \cdot d ^ { 2 } C ^ { 2 } \operatorname* { m a x } _ { t \in \left[ T \right] } \sigma _ { t } ^ { 2 } \right) } \end{array}$ for our proposed algorithm, which is instance-dependent and thus leads to a better performance on good practical instances.
+
+72 Notation. We use lower case letters to denote scalars, and use lower and upper case bold face letters   
+73 to denote vectors and matrices respectively. We denote by $[ n ]$ the set $\{ 1 , \ldots , n \}$ . For a vector $\mathbf { x } \in \mathbb { R } ^ { d }$   
+74 and matrix $\pmb { \Sigma } \in \mathbb { R } ^ { d \times d }$ , a positive semi-definite matrix, we denote by $\lVert \mathbf { x } \rVert _ { 2 }$ the vector’s Euclidean   
+75 norm and define $\| \mathbf { x } \| _ { \Sigma } = \sqrt { \mathbf { x } ^ { \top } \Sigma \mathbf { x } }$ . For two positive sequences $\left\{ a _ { n } \right\}$ and $\left\{ b _ { n } \right\}$ with $n = 1 , 2 , \ldots ,$   
+76 we write $a _ { n } = O ( b _ { n } )$ if there exists an absolute constant $C > 0$ such that $a _ { n } \leq C b _ { n }$ holds for all   
+77 $n \geq 1$ and write $a _ { n } = \Omega ( b _ { n } )$ if there exists an absolute constant $C > 0$ such that $a _ { n } \geq C b _ { n }$ holds   
+78 for all $n \geq 1$ . We use ${ \widetilde { O } } ( \cdot )$ to further hide the polylogarithmic factors. We use $\Im ( \cdot )$ to denote the   
+79 indicator function.
+
+# 80 2 Related Work
+
+81 Bandits with Adversarial Attacks: There is a large body of literature on the problems of multi  
+82 armed bandits with adversarial corruptions. Most research in this area aims to design algorithms that   
+83 achieve desirable regret bound in both stochastic multi-armed bandits and adversarial bandits, known   
+84 as “the best of both worlds” guarantees (Bubeck and Slivkins, 2012; Seldin and Slivkins, 2014; Auer   
+85 and Chiang, 2016; Seldin and Lugosi, 2017; Zimmert and Seldin, 2019). These works mainly focus   
+86 on achieving bounds in the worst case and the case where there is no adversary. As a result, these   
+87 algorithms are either not robust to instances that moderate amount of corruptions occur, or suffer   
+88 from restrictive assumptions on adversarial corruptions. Distinctive from the above line of research,   
+89 Lykouris et al. (2018) focus on a variant of classic multi-armed bandit model in which each pull of an   
+90 arm generates a stochastic reward that may be contaminated by an adversary before it is revealed   
+91 to the player. In their work, the corruption level $C$ is defined as $\begin{array} { r } { C = \sum _ { t } \mathbf { \dot { m } } \mathrm { a x } _ { a } | r ^ { t } ( a ) - r _ { S } ^ { t } ( a ) | } \end{array}$   
+92 where $\bar { r } _ { S } ^ { t } ( a )$ is the stochastic reward of arm $a$ and $r ^ { t } ( a )$ is the corrupted reward of arm $a$ at round $t$ .   
+93 They develop algorithms adaptive to the unknown corruption level, which achieves an $O ( K ^ { 1 . 5 } C \sqrt { T } )$   
+94 regret bound. Gupta et al. (2019) proposed an improved algorithm that can achieve a regret bound   
+95 with only additive dependence on $C$ .   
+96 On the other hand, many research efforts have also been devoted into designing adversarial attacks   
+97 that cause standard algorithms to fail (Jun et al., 2018; Liu and Shroff, 2019; Gupta et al., 2019;   
+98 Garcelon et al., 2020).   
+99 Linear Bandits with Corruptions: Li et al. (2019a) studied stochastic linear bandits with adversarial   
+100 corruptions and achieved $\widetilde { \cal O } ( \textstyle { \frac { 1 } { \Delta } } \cdot d ^ { 5 / 2 } C + \textstyle { \frac { 1 } { \Delta ^ { 2 } } } \cdot d ^ { 6 } )$ regret bound where $d$ is the dimension of the context   
+101 vectors, $\Delta$ is the gap between the rewards of the best and the second best action in the decision   
+102 set $\mathcal { D }$ . The distinction between Li et al. (2019a) and our work is that Li et al. (2019a) considers a   
+103 fixed decision set $\mathcal { D }$ throughout all $T$ rounds, while we consider contextual bandits with changing   
+104 decision set observed before each round. Bogunovic et al. (2021) also studied linear bandits with   
+105 adversarial corruptions and considered the setting under the assumption that context vectors undergo   
+106 small random perturbations, which is previously introduced by Kannan et al. (2018). Aside from   
+107 the additional assumption, another major distinction in Bogunovic et al. (2021) is that the number   
+108 of actions $k$ is finite and the regret bound depends on $k$ in the contextual setting with unknown   
+109 corruption level $C$ . Recently, Lee et al. (2021) considered corrupted linear bandits with a finite and   
+110 fixed decision set and achieve an instance-independent regret of $\widetilde { O } ( d \sqrt { T } + C )$ . Though both their   
+111 work and the work by Li et al. (2019a) focus on corrupted linear stochastic bandits, Lee et al. (2021)   
+112 have a slightly different definition of regret and adopt a strong assumption on corruptions that in   
+113 each round $t$ , the corruptions on rewards are linear in the actions. Neu and Olkhovskaya (2020)   
+114 studied linear contextual bandits with a finite decision set (i.e., $K$ actions) and an adversary. Unlike   
+115 our model, they assume that the adversary can add an arbitrary noise to the loss under a limited   
+116 amount $\epsilon$ and prove an $\widetilde { O } ( ( K d ) ^ { \frac { 1 } { 3 } } T ^ { \frac { 2 } { 3 } } ) + \epsilon \cdot \sqrt { d } T$ regret bound for their proposed algorithm. Kapoor   
+117 et al. (2019) considered the corrupted linear contextual bandits setting under a strong assumption on   
+118 corruptions that for any prefix, at most an $\eta$ fraction of the rounds are corrupted.
+
+# 19 3 Preliminaries
+
+In this paper, we study linear contextual bandits with adversarial corruptions. We will introduce our model and some basic concepts in this section.
+
+122 Corrupted linear contextual bandits. We consider the the linear contextual bandits model studied   
+123 in Abbasi-Yadkori et al. (2011) under the same corruption studied by Lykouris et al. (2018). In detail,   
+124 distinctive from the linear contextual bandits Abbasi-Yadkori et al. (2011), the interaction between   
+125 the agent and the environment is now contaminated by an adversary. The protocol between the agent   
+126 and the adversary at each round $t \in [ T ]$ can be described as follows:
+
+1. At the beginning of round $t$ , the environment generates an arbitrary decision set $\mathcal { D } _ { t } \subseteq \mathbb { R } ^ { d }$ where each element represents a feasible action that can be selected by the agent.   
+9 2. The environment generates stochastic reward function $r _ { t } ^ { \prime } ( \mathbf { a } ) = \langle \mathbf { a } , \mu ^ { * } \rangle + \epsilon _ { t } ( \mathbf { a } )$ together with an upper bound on the standard variance of $\boldsymbol { \epsilon } _ { t } ( \mathbf { a } )$ , i.e., $\sigma _ { t } ( \mathbf { a } )$ for all $\mathbf { a } \in \mathcal { D } _ { t }$ .   
+1 3. The adversary observes $D _ { t } , r _ { t } ^ { \prime } ( \mathbf { a } ) , \sigma _ { t } ( \mathbf { a } )$ for all $\mathbf { a } \in \mathcal { D } _ { t }$ and decides a corrupted reward function   
+32 $r _ { t }$ defined over $\mathcal { D } _ { t }$ .   
+4. The agent observes $\mathcal { D } _ { t }$ and selects $\mathbf { a } _ { t } \in \mathcal { D } _ { t }$ .   
+34 5. The adversary observes $\mathbf { a } _ { t }$ and then returns $r _ { t } ( \mathbf { a } _ { t } )$ and $\sigma _ { t } ( \mathbf { a } _ { t } )$ .   
+35 6. The agent observes $r _ { t } ( \mathbf { a } _ { t } ) , \sigma _ { t } ( \mathbf { a } _ { t } )$ . $\mathcal { F } _ { t }$ be the $\sigma$ -algebra generated by $\mathcal { D } _ { 1 : t } , \mathbf { a } _ { 1 : t - 1 } , \epsilon _ { 1 : t - 1 } , r _ { 1 : t - 1 }$ and $\sigma _ { 1 : t - 1 }$ .
+
+136 Let
+
+At step 2, 137 $\mu ^ { * }$ is a hidden vector unknown to the agent which can be observed by the adversary at the 138 beginning. We assume that for all $t \geq 1$ and all $\mathbf { a } \in \mathcal { D } _ { t }$ , $\| \mathbf { a } \| _ { 2 } \leq A$ , $| \langle \mathbf { a } , \pmb { \mu } ^ { * } \rangle | \overset { } { \leq } 1$ and $\| \pmb { \mu } ^ { * } \| _ { 2 } \leq B$ 139 almost surely. $\epsilon _ { t } ( \mathbf { a } )$ can be any form of random noise as long as it satisfies
+
+$$
+\forall t \geq 1 , \forall \mathbf { a } \in \mathcal { D } _ { t } , | \epsilon _ { t } ( \mathbf { a } ) | \leq R , \quad \mathbb { E } [ \epsilon _ { t } ( \mathbf { a } ) | \mathcal { F } _ { t } ] = 0 , \quad \mathbb { E } [ \epsilon _ { t } ^ { 2 } ( \mathbf { a } ) | \mathcal { F } _ { t } ] \leq \sigma _ { t } ^ { 2 } ( \mathbf { a } ) .
+$$
+
+140 This assumption on $\epsilon _ { t }$ is a variant of that in Zhou et al. (2020): We now require the noise to be   
+141 generated for all $\mathbf { a } \in \mathcal { D } _ { t }$ in advance before the adversary decides the corrupted reward function. Our   
+142 assumption on noises is more general than those in (Li et al., 2019a; Bogunovic et al., 2021; Kapoor   
+143 et al., 2019) where they are assumed to be 1-sub-Gaussian or Gaussian.   
+144 At step 3, we assume that the adversary has observed all the previous information and thus may   
+145 predict which policy the agent will take at the current round. However, since the agent can take a   
+146 randomized policy, the adversary may not know exactly which action the agent will take.
+
+147 Corruption level. We define corruption level
+
+$$
+C = \frac { 1 } { R + 1 } \sum _ { t = 1 } ^ { T } \operatorname* { s u p } _ { \mathbf { a } \in \mathcal { D } _ { t } } | r _ { t } ^ { \prime } ( \mathbf { a } ) - r _ { t } ( \mathbf { a } ) | .
+$$
+
+148 to indicate the level of adversarial contamination. We say a model is $C$ -corrupted if the corruption   
+149 level is no larger than $C$ .
+
+Our definition of corret al. (2019) where t n leveefine $C = { \bar { \sum } } _ { t = 1 } ^ { T } \operatorname* { m a x } _ { \mathbf { a } } | r _ { t } ^ { \prime } ( \mathbf { a } ) - { \bar { r } } _ { t } ( \mathbf { a } ) |$ Lykouris et al. (2018) and Guptain our notation of rewards. We $R$   
+rewards are in range $[ 0 , 1 ]$ .
+
+Regret. Since the actions selected by the agent may not be deterministic, we define the regret for this 5 model as follows:
+
+$$
+\mathbf { R e g r e t } ( T ) = \sum _ { t = 1 } ^ { T } \langle \mathbf { a } _ { t } ^ { * } , \pmb { \mu } ^ { * } \rangle - \mathbb { E } \left[ \sum _ { t = 1 } ^ { T } \langle \mathbf { a } _ { t } , \pmb { \mu } ^ { * } \rangle \right] .
+$$
+
+156 Our definition follows from the definition in Gupta et al. (2019) where the standard metric in stochastic   
+157 multi-armed bandit models of pseudo-regret is adopted. But note that we need to take the expectation   
+158 on $\textstyle \sum _ { t = 1 } ^ { T } r _ { t } ^ { \prime } ( \mathbf { a } _ { t } )$ (the second term in (3.3)), since a randomized policy is applied in each round.   
+59 Gap. Let $\Delta _ { t }$ be the gap between the rewards of the best and the second best action in the decision set   
+60 $\mathcal { D } _ { t }$ as defined in Dani et al. (2008) which can be formally written as
+
+$$
+\Delta _ { t } = \operatorname* { m i n } _ { \mathbf { a } \in \mathcal { D } _ { t } , \mathbf { a } \notin \mathcal { A } _ { t } ^ { * } } \left( \left. \mathbf { a } _ { t } ^ { * } , \pmb { \mu } ^ { * } \right. - \left. \mathbf { a } , \pmb { \mu } ^ { * } \right. \right) .
+$$
+
+where 161 $\begin{array} { r } { \mathcal { A } _ { t } ^ { * } = \mathrm { a r g m a x } _ { \mathbf { a } \in \mathcal { D } _ { t } } \langle \mathbf { a } , \pmb { \mu } ^ { * } \rangle } \end{array}$ and $\mathbf { a } _ { t } ^ { * }$ is an arbitrary element in $\boldsymbol { \mathcal { A } } _ { t } ^ { * }$ . Let $\Delta$ denotes the smallest 162 gap $\mathrm { m i n } _ { t \in [ T ] } \Delta _ { t }$ .
+
+# 163 4 The Proposed Algorithm
+
+164 In this section, we propose a variance-aware algorithm, Multi-level OFUL, in Algorithm 1, to tackle   
+165 the corrupted linear contextual bandits problem. At the core of our algorithm is an action partition   
+166 scheme to group historical selected actions and use them to select the future actions in different   
+167 groups with different probabilities. Such a scheme is introduced to deal with the unknown corruption   
+168 level. For simplicity, we denote $r _ { t } ( \mathbf { a } _ { t } ) , \sigma _ { t } ( \mathbf { a } _ { t } )$ in Section 3 by $r _ { t } , \sigma _ { t }$ in our algorithm.   
+169 Main difficulty in our setting. We begin with the main difficulty that prevents us from applying   
+170 existing algorithms to our setting. Consider a simpler setting where the agent knows the corruption   
+171 level $C$ in prior, and we have $\sigma _ { t } = R$ for all $t$ . Then we can apply OFUL (Abbasi-Yadkori et al.,   
+172 2011) to solve our problem. In detail, in each round we estimate $\mu ^ { * }$ by $\pmb { \mu } _ { t }$ , which is the minimizer of   
+173 the following ridge regression problem:
+
+$$
+\pmb { \mu } _ { t } = \underset { \pmb { \mu } \in \mathbb { R } ^ { d } } { \operatorname { a r g m i n } } \lambda \| \pmb { \mu } \| _ { 2 } ^ { 2 } + \sum _ { i = 1 } ^ { t - 1 } [ \langle \pmb { \mu } , \mathbf { a } _ { i } \rangle - r _ { i } ] ^ { 2 } .
+$$
+
+# Algorithm 1 Multi-level OFUL
+
+1: Set the largest level of confidence sets: $\ell _ { \mathrm { m a x } } \gets \lceil \log _ { 2 } 2 T \rceil$ .   
+2: For $\ell \in [ \ell _ { \mathrm { m a x } } ]$ , set $\pmb { \Sigma } _ { 1 , \ell }  \lambda \mathbf { I } , \pmb { \mu } _ { 1 , \ell }  \mathbf { 0 } , \mathbf { c } _ { 1 , \ell }  \mathbf { 0 }$ .   
+3: Set $\pmb { \Sigma } _ { 1 }  \lambda \mathbf { I }$ , $\pmb { \mu } _ { 1 }  \mathbf { 0 } , \mathbf { c } _ { 1 }  \mathbf { 0 }$ .   
+4: for $t = 1 , \cdots , T$ do   
+5: Observe $\mathcal { D } _ { t }$ .   
+6: for $\ell = 1 , \cdots , \ell _ { \mathrm { m a x } } { \bf d o }$   
+7: Set $\beta _ { t , \ell }$ and $\mathit { \Omega } \gamma _ { t , \ell }$ as defined in (4.5) and (4.6).   
+8: $\begin{array} { r l } & { \mathcal { C } _ { t , \ell } ^ { \prime }  \{ \mu \vert \Vert \mu - \mu _ { t } \Vert _ { \Sigma _ { t } } \leq \beta _ { t , \ell } \} \cap \{ \mu \vert \Vert \mu - \mu _ { t , \ell } \Vert _ { \Sigma _ { t , \ell } } \leq \gamma _ { t , \ell } \} . } \\ & { \mathcal { C } _ { t , \ell }  \{ \mathcal { C } _ { t , \ell } ^ { \prime } , \quad \mathcal { C } _ { t , \ell } ^ { \prime } \neq \mathcal { D }  } \end{array}$   
+9:   
+10: end for   
+11: Set $f ( t ) = { \left\{ \begin{array} { l l } { \ell } \\ { 1 } \end{array} \right. }$ with probability 2−\` 1 < \` ≤ \`max   
+otherwise   
+12: Select $\mathbf { a } _ { t } \gets \mathrm { a r g m a x } _ { \mathbf { a } \in \mathcal { D } _ { t } } \operatorname* { m a x } _ { \pmb { \mu } \in \mathcal { C } _ { t , f ( t ) } } \langle \pmb { \mu } , \mathbf { a } \rangle$ and observe $r _ { t } , \sigma _ { t }$ .   
+13: 14: $\begin{array} { r } { \Sigma _ { t + 1 } \gets \Sigma _ { t } + \mathbf { a } _ { t } \mathbf { a } _ { t } ^ { \top } / \overline { { \sigma } } _ { t } ^ { 2 } , \mathbf { c } _ { t + 1 } \gets \mathbf { c } _ { t } + r _ { t } \mathbf { a } _ { t } / \overline { { \sigma } } _ { t } ^ { 2 } , \mu _ { t + 1 } \gets \Sigma _ { t + 1 } ^ { - 1 } \mathbf { c } _ { t + 1 } . } \end{array}$ $\overline { { \sigma } } _ { t } = \operatorname* { m a x } \{ ( R + 1 ) / \sqrt { d } , \sigma _ { t } \}$   
+15: for $\ell \neq f ( t )$ do   
+16: $\Sigma _ { t + 1 , \ell } \gets \Sigma _ { t , \ell } , \mathbf { c } _ { t + 1 , \ell } \gets \mathbf { c } _ { t , \ell } , \mu _ { t + 1 , \ell } \gets \mu _ { t , \ell } .$   
+17: end for   
+18: $\begin{array} { r } { \sum _ { t + 1 , f ( t ) }  \sum _ { t , f ( t ) } + \mathbf { a } _ { t } \mathbf { a } _ { t } ^ { \top } / \overline { { \sigma } } _ { t } ^ { 2 } , \mathbf { c } _ { t + 1 , f ( t ) }  \mathbf { c } _ { t , f ( t ) } + r _ { t } \mathbf { a } _ { t } / \overline { { \sigma } } _ { t } ^ { 2 } . } \end{array}$   
+19: $\pmb { \mu } _ { t + 1 , f ( t ) }  \pmb { \Sigma } _ { t + 1 , f ( t ) } ^ { - 1 } \mathbf { c } _ { t + 1 , f ( t ) }$ t.   
+20: end for   
+174 By slightly modifying the self-normalized martingale concentration inequality proposed in Abbasi  
+175 Yadkori et al. (2011), we can conclude that $\mu ^ { * }$ belongs to the ellipsoid $\| \pmb { \mu } - \pmb { \mu } _ { t } \| _ { \pmb { \Sigma } _ { t } ^ { - 1 } } \leq \beta _ { t }$ with high   
+176 probability, where $\beta _ { t } = \widetilde { O } ( R \sqrt { d } + C \sqrt { d } )$ . Such a confidence bound leads to a final regret which   
+177 has a polynomial dependence on $C$ . However, such a simple approach have two limitations. First,   
+178 the agent does not know $C$ apriori in our setting, thus it is impossible to set $\beta _ { t }$ to be dependent on   
+179 $C$ . Second, vanilla ridge regression estimator does not consider different variances $\sigma _ { t }$ in each round,   
+180 thus it only gives a very conservative estimation.   
+181 Action partition scheme. To address the unknown $C$ issue, besides the original estimator $\pmb { \mu } _ { t }$ which   
+182 uses all previous data, Algorithm 1 maintains several additional learners to learn $\mu ^ { * }$ at different   
+183 accuracy level simultaneously, and it randomly selects one of the learners with different probabilities   
+184 at each round. Such a “parallel learning” idea is inspired by Lykouris et al. (2018). In detail,   
+185 we partition the observed data into $\ell _ { \mathrm { m a x } }$ levels indexed by $[ \ell _ { \mathrm { m a x } } ]$ and maintain $\ell _ { \mathrm { m a x } }$ sub-sampled   
+186 estimators $\mu _ { t , 1 } , \cdots , \mu _ { t , \ell _ { \mathrm { m a x } } }$ . According to line 11, the observed data in round $t$ goes into level $\ell$ with   
+187 probability $2 ^ { - \ell }$ if $1 < \ell \leq \ell _ { \mathrm { m a x } }$ and it goes to level 1 with probability $\begin{array} { r } { 1 - \sum _ { \ell = 2 } ^ { \ell _ { \mathrm { m a x } } } 2 ^ { - \ell } = 1 / 2 + 2 ^ { - \ell _ { \mathrm { m a x } } } } \end{array}$ .   
+188 The intuition is that if $2 ^ { \ell } \geq C$ , then the corruption level experienced by level $\ell$
+
+$$
+\mathrm { C o r r u p t i o n } _ { t , \ell } = \sum _ { i = 1 } ^ { t } \frac { \mathbb { 1 } ( f ( i ) = \ell ) } { R + 1 } \cdot \operatorname* { s u p } _ { \mathbf { a } \in \mathcal { D } _ { i } } | r _ { i } ( \mathbf { a } ) - r _ { i } ^ { \prime } ( \mathbf { a } ) |
+$$
+
+189 can be bounded by some quantity that is independent of $C$ . That says, the individual learners whose   
+190 level is greater than $\log C$ can learn $\mu ^ { * }$ successfully, even with the corruption. For the learners whose   
+191 level is less than $\log C$ , we can also control the error by controlling the probability for the agent to   
+192 select them.   
+193 Weighted regression estimator. After introducing the partition scheme, we still need to deal   
+194 with the varying variance (heteroscedastic) case. Similar to (Kirschner and Krause, 2018; Zhou   
+195 et al., 2020), we proposed the following weighted ridge regression estimator, which incorporates the   
+196 variance information of the rewards into estimation:
+
+$$
+\pmb { \mu } _ { t } = \underset { \pmb { \mu } \in \mathbb { R } ^ { d } } { \operatorname { a r g m i n } } \lambda \| \pmb { \mu } \| _ { 2 } ^ { 2 } + \sum _ { i = 1 } ^ { t - 1 } [ \langle \pmb { \mu } , \mathbf { a } _ { i } \rangle - r _ { i } ] ^ { 2 } / \overline { { \sigma } } _ { i } ^ { 2 } .
+$$
+
+197 Here $\overline { { \sigma } } _ { t }$ is defined as the upper bound of the true variance $\sigma _ { t }$ in line 13. The closed-form solution to   
+198 (4.3) is calculated at each round in line 14. The use of $\overline { { \sigma } } _ { t }$ , as we will show later, makes our estimator   
+199 more efficient in the heteroscedastic case. Meanwhile, we also apply our weighted regression   
+200 estimator to each individual learner, and their estimator $\pmb { \mu } _ { t , \ell }$ can be written as follows:
+
+$$
+\pmb { \mu } _ { t , \ell } = \underset { \pmb { \mu } \in \mathbb { R } ^ { d } } { \operatorname { a r g m i n } } \lambda \| \pmb { \mu } \| _ { 2 } ^ { 2 } + \sum _ { i = 1 } ^ { t - 1 } \pmb { 1 } ( f ( i ) = \ell ) \cdot [ \langle \pmb { \mu } , \mathbf { a } _ { i } \rangle - r _ { i } ] ^ { 2 } / \overline { { \sigma } } _ { i } ^ { 2 } .
+$$
+
+201 The closed-form solution to (4.4) is calculated at each round in lines 15–20.
+
+202 Final Multi-Level confidence sets. With the estimators $\pmb { \mu } _ { t }$ , $\mathbf { \nabla } \cdot \mu _ { t , 1 } , \cdot \cdot \cdot \mathbf { \nabla } , \mu _ { t , \ell _ { \mathrm { m a x } } }$ at the beginning of   
+203 round $t$ , we define a cascade of candidate confidence sets as in lines 6–10, where
+
+$$
+\begin{array} { r } { \beta _ { t , \ell } = 8 \sqrt { d \log \frac { ( R + 1 ) ^ { 2 } \lambda + t A ^ { 2 } } { ( R + 1 ) ^ { 2 } \lambda } \log ( 4 t ^ { 2 } / \delta ) } + 4 \sqrt { d } \log ( 4 t ^ { 2 } / \delta ) + 2 ^ { \ell } \sqrt { d } + \sqrt { \lambda } B , } \\ { \gamma _ { t , \ell } = 8 \sqrt { d \log \frac { ( R + 1 ) ^ { 2 } \lambda + t A ^ { 2 } } { ( R + 1 ) ^ { 2 } \lambda } \log ( 8 t ^ { 2 } T / \delta ) } + 4 \sqrt { d } \log ( 8 t ^ { 2 } T / \delta ) + \overline { { C } } _ { \ell } \sqrt { d } + \sqrt { \lambda } B , } \end{array}
+$$
+
+with 204 $\overline { { C } } _ { \ell } = \log ( 2 \ell ^ { 2 } / \delta ) + 3$ . For simplicity, we define
+
+$$
+\ell ^ { * } = \operatorname* { m a x } \{ 2 , \lceil \log _ { 2 } C \rceil \}
+$$
+
+05 as an important threshold in our later proof for regret bound analysis. Later we will prove that $\mathcal { C } _ { t , \ell }$ contains 06 $\mu ^ { * }$ for all $\ell \geq \ell ^ { * }$ , $t \geq 1$ with high probability.
+
+207 Note that each candidate confidence set can be written as the intersection of two ellipsoids. The   
+208 intuition behind our construction of candidate confidence sets is that we hope that $\mathcal { C } _ { t , \ell }$ is robust   
+209 enough to handle the $2 ^ { \ell }$ -corrupted case, i.e., $\mu ^ { * } \in \mathcal { C } _ { t , \ell }$ with high probability. To achieve this, the first   
+210 ellipsoid makes use of the global information and the “radius” $\beta _ { t , \ell }$ need to contain a factor of $2 ^ { \ell }$ to   
+211 tolerate a corruption level of $2 ^ { \ell }$ , and the second ellipsoid makes use of the observed data in level $\ell$   
+212 since this level only contain a few times of corruptions in $2 ^ { \ell }$ -corrupted case.   
+213 Action selection. With the candidate confidence sets, we use line 11 to randomly decide one   
+214 confidence set and select an action based on the optimism-in-the-face-of-uncertainty (OFU) principle   
+215 in line 12. Then we update the estimators for the next round $t + 1$ .
+
+Remark 4.1. Our algorithm shares a similar strategy for partitioning the observed data with the algorithm in Lykouris et al. (2018) but note that there is a major difference in that: Lykouris et al. (2018) regard the partition scheme as a “layer structure”, i.e., their algorithm further uses different estimators in layers of parallel learners and do action elimination layer by layer in each round. In contrast, the sub-sampled estimators in our algorithm are used independently, i.e., the selected action only relies on one of the partitions. As a result, Algorithm 1 does not need to do action elimination, thus is capable of handling the cases where the number of actions is huge or even infinite.
+
+# 5 Main Results
+
+224 In this section we present our main theorem, which establishes the regret bound for Multi-level   
+225 OFUL.
+
+Theorem 5.1. Set $\lambda = 1 / B ^ { 2 }$ . Suppose that $C = \Omega ( 1 )$ , $R = \Omega ( 1 )$ , for all $t \geq 1$ and all $\mathbf { a } \in \mathcal { D } _ { t }$ , $\left. \mathbf { a } , \pmb { \mu } ^ { * } \right. \in \left[ - 1 , 1 \right]$ . Then with probability at least $1 - 3 \delta$ , the regret of Algorithm 1 is bounded as follows:
+
+$$
+\mathbf { R e g r e t } ( T ) = \widetilde { O } \left( C ^ { 2 } d \sqrt { \sum _ { t = 1 } ^ { T } \sigma _ { t } ^ { 2 } } + C ^ { 2 } \sqrt { d T } + C R \sqrt { d T } \right) .
+$$
+
+26 Remark 5.2. When $\sigma _ { t } , R = \Omega ( 1 )$ , the regret bound in Theorem 5.1 matches the regret bound of   
+27 OFUL proposed in Zhou et al. (2020) when the corruption level $C$ is a constant.
+
+Remark 5.3. Compared with the $\widetilde { O } ( d \sqrt { T } + C )$ result in Lee et al. (2021), our result has a multiplicative quadratic dependence on $C$ , which seems to be worse. However, we want to emphasize that we focus on a more challenging contextual bandits setting where the decision sets $\mathcal { D } _ { t }$ at each round are not identical, which is different from that in Lee et al. (2021). Therefore, our result and that in Lee et al. (2021) are not directly comparable.
+
+233 Remark 5.4. Note that this instance-independent regret upper bound also holds in a stronger model   
+234 than the one described in Section 3, where the adversary can even decide the decision set $\mathcal { D } _ { t }$ at each   
+235 round $t$ since our regret bound can hold without any assumption on the decision sets.
+
+Corollary 5.5. Under the same conditions as in Theorem 5.1, if $\sigma _ { t }$ given by the environment are all $R$ , the regret of Algorithm 1 is bounded by:
+
+$$
+\mathbf { R e g r e t } ( T ) = \widetilde { O } \left( C ^ { 2 } d R \sqrt { T } \right) .
+$$
+
+236 We also provide a gap-dependent regret bound.
+
+Theorem 5.6. Suppose that $C = \Omega ( 1 )$ , $R = \Omega ( 1 )$ , for all $t \geq 1$ and all $\mathbf { a } \in \mathcal { D } _ { t }$ , $\left. \mathbf { a } , \pmb { \mu } ^ { * } \right. \in \left[ - 1 , 1 \right]$ . Then with probability at least $1 - 3 \delta$ , the regret of Algorithm 1 is bounded as follows:
+
+$$
+\mathbf { R e g r e t } ( T ) = \widetilde { O } \left( \frac { 1 } { \Delta } \cdot C ^ { 2 } R ^ { 2 } d + \frac { 1 } { \Delta } \cdot d ^ { 2 } C ^ { 2 } \operatorname* { m a x } _ { t \in [ T ] } \sigma _ { t } ^ { 2 } \right) .
+$$
+
+237 Remark 5.7. Theorem 5.6 automatically suggests an ${ \widetilde O } ( R ^ { 2 } d ^ { 2 } C ^ { 2 } / \Delta )$ regret bound, by the fact   
+238 $\sigma _ { t } = O ( R )$ . Compared with previous result $\widetilde { O } ( d ^ { 5 / 2 } C / \Delta + d ^ { 6 } / \Delta ^ { 2 } )$ (Lee et al., 2021), our result   
+239 has a better dependence on the dimension $d$ but a worse dependence on the corruption level $C$ . As   
+240 Remark 5.3 suggests, we focus on a more challenging contextual bandits setting, and the worse   
+241 dependence on $C$ might be due to this.
+
+# 42 6 Proof Outline
+
+243 First we have the following lemma which is a corruption-tolerant variant of Bernstein inequality for   
+244 self-normalized vector-valued martingales introduced in Zhou et al. (2020).
+
+Lemma 6.1 (Bernstein inequality for vector-valued martingales with corruptions). Let $\{ \mathcal { G } _ { t } \} _ { t = 1 } ^ { \infty }$ be a filtration, $\{ \mathbf { x } _ { t } , \eta _ { t } \} _ { t \geq 1 }$ a stochastic process so that $\mathbf { x } _ { t } \in \mathbb { R } ^ { d }$ is $\mathcal { G } _ { t }$ -measurable and $\eta _ { t } \in \mathbb { R }$ is $\mathcal { G } _ { t + 1 }$ -measurable. Fix $R , L , \sigma , \lambda > 0$ , $\pmb { \mu } ^ { * } \in \mathbb { R } ^ { d }$ . For $t \geq 1$ let $y _ { t } ^ { \mathrm { s t o c h } } = \langle \pmb { \mu } ^ { * } , \mathbf { x } _ { t } \rangle + \eta _ { t }$ and suppose that $\eta _ { t } , \mathbf { x } _ { t }$ also satisfy
+
+$$
+| \eta _ { t } | \leq R , \mathbb { E } [ \eta _ { t } | \mathcal { G } _ { t } ] = 0 , \mathbb { E } [ \eta _ { t } ^ { 2 } | \mathcal { G } _ { t } ] \leq \sigma ^ { 2 } , \| \mathbf { x } _ { t } \| _ { 2 } \leq L .
+$$
+
+245 Suppose $\{ y _ { t } \}$ is a sequence such that $\textstyle \sum _ { i = 1 } ^ { t } | y _ { i } - y _ { i } ^ { \mathrm { s t o c h } } | = C ( t )$ for all $t \geq 1$ . Then, for any   
+246 $0 < \delta < 1$ , with probability at least $1 - \delta$ we have $\forall t > 0$ ,
+
+$$
+\| \pmb { \mu } _ { t } - \pmb { \mu } ^ { * } \| _ { \mathbf { Z } _ { t } } \leq \beta _ { t } + C ( t ) + \sqrt { \lambda } \| \pmb { \mu } ^ { * } \| _ { 2 } ,
+$$
+
+where for $t \geq 1$ , $\begin{array} { r } { { \bf \delta } = { \bf Z } _ { t } ^ { - 1 } { \bf b } _ { t } , { \bf Z } _ { t } = \lambda { \bf I } + \sum _ { i = 1 } ^ { t } { \bf x } _ { i } { \bf x } _ { i } ^ { \top } , { \bf b } _ { t } = \sum _ { i = 1 } ^ { t } y _ { i } { \bf x } _ { i } , i } \end{array}$ and
+
+$$
+\beta _ { t } = 8 \sigma \sqrt { d \log \frac { d \lambda + t L ^ { 2 } } { d \lambda } \log ( 4 t ^ { 2 } / \delta ) } + 4 R \log ( 4 t ^ { 2 } / \delta ) .
+$$
+
+247 Next, we have that with high probability, all the level $\ell \geq \ell ^ { * }$ only influenced by limited amount of   
+248 corruptions as mentioned in Section 4.
+
+Lemma 6.2. Let Corruption $^ { t , \ell }$ be defined in (4.2). Then we have with probability at least $1 - \delta$ , for all $\ell \geq \ell ^ { * }$ , $t \geq 1$ :
+
+$$
+\mathrm { C o r r u p t i o n } _ { t , \ell } \leq \overline { { C } } _ { \ell } = \log ( 2 \ell ^ { 2 } / \delta ) + 3 .
+$$
+
+249 We denote by ${ \mathcal E } _ { \mathrm { s u b } }$ the event that the above inequality holds.
+
+We define the following event to further show that our candidate confidence sets with $\ell \geq \ell ^ { * }$ are “robust” enough, i.e. $\mathcal { C } _ { t , \ell }$ contains $\mu ^ { * }$ with high probability.
+
+Definition 6.3. Let 252 $\ell ^ { * }$ be defined in (4.7). We introduce the event ${ \mathcal { E } } _ { 1 }$ as follows.
+
+$$
+\mathcal { E } _ { 1 } : = \left\{ \forall \ell \geq \ell ^ { * } \mathrm { ~ a n d ~ } t \geq 1 , \| \pmb { \mu } ^ { * } - \pmb { \mu } _ { t } \| _ { \Sigma _ { t } } \leq \beta _ { t , \ell } \mathrm { ~ a n d ~ } \| \pmb { \mu } ^ { * } - \pmb { \mu } _ { t , \ell } \| _ { \Sigma _ { t , \ell } } \leq \gamma _ { t , \ell } \right\} .
+$$
+
+253 where $\beta _ { t , \ell } , \gamma _ { t , \ell }$ are defined in (4.5) and (4.6).
+
+254 Next lemma suggests that the event $\mathcal { E } _ { 1 }$ happens with high probability.
+
+Lemma 6.4. Let $\mathcal { E } _ { 1 }$ be defined in (6.1). For any $0 < \delta < 1 / 3$ , we have $\mathbb { P } ( \mathcal { E } _ { 1 } ) \ge 1 - 3 \delta$
+
+For simplicity, we define $\mathbf { a } _ { t , \ell } = \mathop { \mathrm { a r g m a x } } _ { \mathbf { a } \in \mathcal { D } _ { t } }$ $\operatorname* { m a x } _ { \pmb { \mu } \in \mathcal { C } _ { t , \ell } } \langle \pmb { \mu } , \mathbf { a } \rangle$ for each level $\ell$ . $\mathbf { a } _ { t }$ can be seen as an action vector randomly chosen from $\mathbf { a } _ { t , \ell }$ , $\ell \in [ \ell _ { \mathrm { m a x } } ]$ . Next two lemmas suggest that under event ${ \mathcal { E } } _ { 1 }$ at each round, the gap between the optimal reward and the selected reward can be upper bounded by some bonus terms related to $\mathbf { a } _ { t , \ell }$ .
+
+Lemma 6.5. Suppose $\mathcal { E } _ { 1 }$ occurs. If $f ( t ) ~ \leq ~ \ell ^ { * }$ , we have $\left. \mathbf { a } _ { t } ^ { * } - \mathbf { a } _ { t } , \pmb { \mu } ^ { * } \right. \leq 2 \beta _ { t , \ell ^ { * } } \lVert \mathbf { a } _ { t } \rVert _ { \pmb { \Sigma } _ { t } ^ { - 1 } } +$ $2 \beta _ { t , \ell ^ { * } } \| \mathbf { a } _ { t , \ell ^ { * } } \| _ { \Sigma _ { t } ^ { - 1 } }$ .
+
+Lemma 6.6. On event ${ \mathcal { E } } _ { 1 }$ , if $f ( t ) = \ell > \ell ^ { * }$ , we have $\langle \mathbf { a } _ { t } ^ { * } - \mathbf { a } _ { t } , \pmb { \mu } ^ { * } \rangle \leq 2 \gamma _ { t , \ell } \| \mathbf { a } _ { t } \| _ { \pmb { \Sigma } _ { t , \ell } ^ { - 1 } }$
+
+Now we provide the proof sketch of Theorem 5.1.
+
+264 Proof sketch of Theorem 5.1 . Suppose $\mathcal { E } _ { 1 }$ occurs. The main idea to bound the regret is to decompose   
+265 the total rounds $[ T ]$ into two non-overlapping parts, based on which individual learner is selected at   
+266 that round. In detail, we have
+
+$$
+\begin{array} { r l } & { \mathrm { R e g r e t } ( T ) = \mathbb { E } \left[ \displaystyle \sum _ { t = 1 } ^ { T } \left( \langle \mathbf { a } _ { t } ^ { * } , \boldsymbol { \mu } ^ { * } \rangle - \langle \mathbf { a } _ { t } , \boldsymbol { \mu } ^ { * } \rangle \right) \right] } \\ & { \quad \quad \quad = \underbrace { \mathbb { E } \left[ \displaystyle \sum _ { t = 1 } ^ { T } \mathbf { 1 } ( f ( t ) \le \ell ^ { * } ) \left( \langle \mathbf { a } _ { t } ^ { * } , \boldsymbol { \mu } ^ { * } \rangle - \langle \mathbf { a } _ { t } , \boldsymbol { \mu } ^ { * } \rangle \right) \right] } _ { T _ { 1 } } } \\ & { \quad \quad \quad + \displaystyle \sum _ { \ell = \ell ^ { * } + 1 } ^ { \ell _ { \mathrm { m a x } } } \underbrace { \mathbb { E } \left[ \displaystyle \sum _ { t = 1 } ^ { T } \mathbf { 1 } ( f ( t ) = \ell ) \left( \langle \mathbf { a } _ { t } ^ { * } , \boldsymbol { \mu } ^ { * } \rangle - \langle \mathbf { a } _ { t } , \boldsymbol { \mu } ^ { * } \rangle \right) \right] } _ { I _ { 2 } ( \ell ) } . } \end{array}
+$$
+
+267 Here $I _ { 1 }$ represents the regret where the the "low-level" learner is selected, where the corruption level   
+268 is beyond the learner level.For this case, by Lemma 6.5, we can directly show that
+
+$$
+I _ { 1 } \leq \mathbb { E } \left[ \sum _ { t = 1 } ^ { T } \Im ( f ( t ) \leq \ell ^ { * } ) \operatorname* { m i n } \left\{ 2 , 2 \beta _ { t , \ell ^ { * } } \left\| \mathbf { a } _ { t , \ell ^ { * } } \right\| _ { \Sigma _ { t } ^ { - 1 } } + 2 \beta _ { t , \ell ^ { * } } \left\| \mathbf { a } _ { t } \right\| _ { \Sigma _ { t } ^ { - 1 } } \right\} \right] .
+$$
+
+269 We further bound (6.3). Let $\mathcal { F } _ { t }$ be the $\sigma$ -algebra generated by $\mathbf { a } _ { s } , r _ { s } , \sigma _ { s } , f ( s )$ for $s \leq t - 1$ .   
+270 Then by the property of our partition scheme (note that $\mathbb { P } ( f ( t ) = \ell ^ { * } ) = 2 ^ { - \ell ^ { * } } .$ ), we can show that   
+271 $\begin{array} { r } { \mathbb { E } \left[ \mathbb { 1 } ( f ( t ) \leq \ell ^ { * } ) \lVert \mathbf { a } _ { t , \ell ^ { * } } \rVert _ { \Sigma _ { t } ^ { - 1 } } \big | \mathcal { F } _ { t } \right] \leq 2 ^ { \ell ^ { * } } \mathbb { E } \left[ \left. \mathbf { a } _ { t } \right. _ { \Sigma _ { t } ^ { - 1 } } \big | \mathcal { F } _ { t } \right] . } \end{array}$ . Therefore, we can further bound $I _ { 1 }$ by
+
+$$
+I _ { 1 } \leq 4 \cdot 2 ^ { \ell ^ { * } } \mathbb { E } \underbrace { \left[ \sum _ { t = 1 } ^ { T } \operatorname* { m i n } \left\{ 2 , \beta _ { T , \ell ^ { * } } \left\| \mathbf { a } _ { t } \right\| _ { \Sigma _ { t } ^ { - 1 } } \right\} \right] } _ { I _ { 3 } } .
+$$
+
+To further bound 272 $I _ { 3 }$ , we split $[ T ]$ into 2 parts, $\mathcal { T } _ { 1 } ~ = ~ \{ t ~ \in ~ [ T ] | \| \mathbf { a } _ { t } / \overline { { \sigma } } _ { t } \| _ { \Sigma _ { t } ^ { - 1 } } ~ > ~ 1 \} , \mathcal { T } _ { 2 } ~ = ~ \{ t ~ \in ~$ 273 $[ T ] | \| \mathbf { a } _ { t } / \overline { { \sigma } } _ { t } \| _ { \Sigma _ { t } ^ { - 1 } } \leq 1 \}$ to bound $I _ { 3 }$ . The intuition here is that the cardinality of $\mathcal { T } _ { 1 }$ is bounded, and 274 the sum of terms with $t \in \mathcal { T } _ { 2 }$ can be bounded using Cauchy-Schwarz inequality.
+
+$$
+\sum _ { \in { \cal T } _ { 1 } } \operatorname* { m i n } \left\{ 2 , \beta _ { { \cal T } , \ell ^ { * } } \| { \bf a } _ { t } \| _ { { \bfSigma } _ { t } ^ { - 1 } } \right\} \leq 2 | { \cal T } _ { 1 } | \leq 2 \sum _ { t = 1 } ^ { T } \operatorname* { m i n } \left\{ 1 , \| { \bf a } _ { t } / \overline { { \sigma } } _ { t } \| _ { { \Sigma } _ { t } ^ { - 1 } } ^ { 2 } \right\} \leq 4 d \log \frac { ( R + 1 ) ^ { 2 } \lambda + T A ^ { 2 } } { ( R + 1 ) ^ { 2 } \lambda } ,
+$$
+
+where the first inequality holds since 275 $\operatorname* { m i n } \left\{ 2 , \beta _ { T , \ell ^ { * } } \| \mathbf { a } _ { t } \| _ { \Sigma _ { t } ^ { - 1 } } \right\} \leq 2$ , the second inequality follows 276 from the definition of $\mathcal { T } _ { 1 }$ , the third inequality holds by Lemma C.2.
+
+$$
+\begin{array} { r l } { \displaystyle \sum _ { t \in \mathcal { T } _ { 2 } } \operatorname* { m i n } \Big \{ 2 , \beta _ { T , \ell ^ { * } } \| \mathbf { a } _ { t } \| _ { \Sigma _ { t } ^ { - 1 } } \Big \} \leq \beta _ { T , \ell ^ { * } } \sqrt { \displaystyle \sum _ { t \in \mathcal { T } _ { 2 } } \overline { { \sigma _ { t } ^ { 2 } } } } \cdot \sqrt { \displaystyle \sum _ { t \in \mathcal { Z } _ { 2 } } \operatorname* { m i n } \Big \{ 1 , \| \mathbf { a } _ { t } / \overline { { \sigma } } _ { t } \| _ { \Sigma _ { t } ^ { - 1 } } ^ { 2 } \Big \} } } & { } \\ { \leq \beta _ { T , \ell ^ { * } } \sqrt { ( R + 1 ) ^ { 2 } T / d + \displaystyle \sum _ { t = 1 } ^ { T } \sigma _ { t } ^ { 2 } } \cdot \sqrt { 2 d \log \frac { ( R + 1 ) ^ { 2 } \lambda + T A ^ { 2 } } { ( R + 1 ) ^ { 2 } \lambda } } , } & { } \end{array}
+$$
+
+277 where the first inequality follows from Cauchy-Schwarz inequality, the second inequality follows   
+278 from the definition of $\overline { { \sigma } } _ { t }$ and Lemma C.2.
+
+279 Substituting (6.5) and (6.6) into (6.3), we have
+
+$$
+I _ { 1 } = \widetilde { O } \left( C ^ { 2 } d \sqrt { \sum _ { t = 1 } ^ { T } \sigma _ { t } ^ { 2 } } + C ^ { 2 } \sqrt { d T } + C R \sqrt { d T } \right) .
+$$
+
+280 Now it remains to bound $I _ { 2 } ( \ell )$ . By Lemma 6.6, we have
+
+$$
+I _ { 2 } ( \ell ) \le 2 \mathbb { E } \underbrace { \left[ \sum _ { t = 1 } ^ { T } \mathbb { 1 } \left( f ( t ) = \ell \right) \operatorname* { m i n } \left\{ 1 , \gamma _ { t , \ell } \lVert \mathbf { a } _ { t , \ell } \rVert _ { \Sigma _ { t , \ell } ^ { - 1 } } \right\} \right] } _ { I _ { 4 } } = \widetilde { O } \left( R \sqrt { T d } + d \sqrt { \sum _ { t = 1 } ^ { T } \sigma _ { t } ^ { 2 } } \right) ,
+$$
+
+281 where the second equality can be proved by analysis similar to that of (6.5) and (6.6). Finally,   
+282 substituting (6.7) and (6.8) into (6.2) ends our proof.
+
+# 84 7 Conclusion and Future Work
+
+In this paper, we have considered the linear contextual bandits problem in the presence of adversarial corruptions. We propose a Multi-level OFUL algorithm, which is provably robust to the adversarial attacks. We prove a gap-independent regret bound of $\cdot \widetilde { O } \left( C ^ { 2 } d \sqrt { \sum _ { t = 1 } ^ { T } \sigma _ { t } ^ { 2 } } + C ^ { 2 } \sqrt { d T } + C R \sqrt { d T } \right)$ together with a gap-dependent bound of $\begin{array} { r } { \widetilde { O } \left( \frac { 1 } { \Delta } \cdot C ^ { 2 } R ^ { 2 } d + \frac { 1 } { \Delta } \cdot d ^ { 2 } C ^ { 2 } \operatorname* { m a x } _ { t \in \left[ T \right] } \sigma _ { t } ^ { 2 } \right) } \end{array}$ .
+
+We leave it as an open question that whether the multiplicative dependence on $C ^ { 2 }$ in the regret upper bounds can be removed without making additional assumptions in our setting.
+
+# References
+
+ABBASI-YADKORI, Y., PÁL, D. and SZEPESVÁRI, C. (2011). Improved algorithms for linear stochastic bandits. In NIPS, vol. 11.   
+ABE, N., BIERMANN, A. W. and LONG, P. M. (2003). Reinforcement learning with immediate rewards and linear hypotheses. Algorithmica 37 263–293.   
+AUER, P. (2002). Using confidence bounds for exploitation-exploration trade-offs. Journal of Machine Learning Research 3 397–422.   
+AUER, P. and CHIANG, C.-K. (2016). An algorithm with nearly optimal pseudo-regret for both stochastic and adversarial bandits. In Conference on Learning Theory. PMLR.   
+BOGUNOVIC, I., LOSALKA, A., KRAUSE, A. and SCARLETT, J. (2021). Stochastic linear bandits robust to adversarial attacks. In International Conference on Artificial Intelligence and Statistics. PMLR.   
+BUBECK, S. and SLIVKINS, A. (2012). The best of both worlds: Stochastic and adversarial bandits. In Conference on Learning Theory. JMLR Workshop and Conference Proceedings.   
+05 CHU, W., LI, L., REYZIN, L. and SCHAPIRE, R. (2011). Contextual bandits with linear payoff functions. In Proceedings of the Fourteenth International Conference on Artificial Intelligence and Statistics. JMLR Workshop and Conference Proceedings.   
+08 DANI, V., HAYES, T. P. and KAKADE, S. (2008). Stochastic linear optimization under bandit feedback. In COLT.   
+DESHPANDE, Y. and MONTANARI, A. (2012). Linear bandits in high dimension and recommendation systems. In 2012 50th Annual Allerton Conference on Communication, Control, and Computing (Allerton). IEEE. GARCELON, E., ROZIERE, B., MEUNIER, L., TARBOURIECH, J., TEYTAUD, O., LAZARIC, A. and PIROTTA, M. (2020). Adversarial attacks on linear contextual bandits. arXiv preprint arXiv:2002.03839 . GUPTA, A., KOREN, T. and TALWAR, K. (2019). Better algorithms for stochastic bandits with adversarial corruptions. In Conference on Learning Theory. PMLR.   
+18 JHALANI, T., KANT, V. and DWIVEDI, P. (2016). A linear regression approach to multi-criteria recommender system. In International Conference on Data Mining and Big Data. Springer.   
+JUN, K.-S., LI, L., MA, Y. and ZHU, X. J. (2018). Adversarial attacks on stochastic bandits. In NeurIPS.   
+22 KANNAN, S., MORGENSTERN, J. H., ROTH, A., WAGGONER, B. and WU, Z. (2018). A smoothed analysis of the greedy algorithm for the linear contextual bandit problem. In NeurIPS.   
+24 KAPOOR, S., PATEL, K. K. and KAR, P. (2019). Corruption-tolerant bandit learning. Machine Learning 108 687–715.   
+26 KIRSCHNER, J. and KRAUSE, A. (2018). Information directed sampling and bandits with heteroscedastic noise. In Conference On Learning Theory. PMLR. LEE, C.-W., LUO, H., WEI, C.-Y., ZHANG, M. and ZHANG, X. (2021). Achieving near instanceoptimality and minimax-optimality in stochastic and adversarial linear bandits simultaneously. arXiv preprint arXiv:2102.05858 . LI, L., CHU, W., LANGFORD, J. and SCHAPIRE, R. E. (2010). A contextual-bandit approach to personalized news article recommendation. In Proceedings of the 19th international conference on World wide web.   
+34 LI, Y., LOU, E. Y. and SHAN, L. (2019a). Stochastic linear optimization with adversarial corruption. arXiv preprint arXiv:1909.02109 .   
+36 LI, Y., WANG, Y. and ZHOU, Y. (2019b). Nearly minimax-optimal regret for linearly parameterized bandits. In Conference on Learning Theory. PMLR.   
+LIU, F. and SHROFF, N. (2019). Data poisoning attacks on stochastic bandits. In International Conference on Machine Learning. PMLR.   
+40 LYKOURIS, T., MIRROKNI, V. and PAES LEME, R. (2018). Stochastic bandits robust to adversarial corruptions. In Proceedings of the 50th Annual ACM SIGACT Symposium on Theory of Computing.   
+42 NEU, G. and OLKHOVSKAYA, J. (2020). Efficient and robust algorithms for adversarial linear contextual bandits. In Conference on Learning Theory. PMLR.   
+44 RUSMEVICHIENTONG, P. and TSITSIKLIS, J. N. (2010). Linearly parameterized bandits. Mathematics of Operations Research 35 395–411.   
+46 SELDIN, Y. and LUGOSI, G. (2017). An improved parametrization and analysis of the $\exp 3 + +$ algorithm for stochastic and adversarial bandits. In Conference on Learning Theory. PMLR.   
+48 SELDIN, Y. and SLIVKINS, A. (2014). One practical algorithm for both stochastic and adversarial bandits. In International Conference on Machine Learning. PMLR.
+
+VILLAR, S. S., BOWDEN, J. and WASON, J. (2015). Multi-armed bandit models for the optimal design of clinical trials: benefits and challenges. Statistical science: a review journal of the Institute of Mathematical Statistics 30 199. ZHOU, D., GU, Q. and SZEPESVARI, C. (2020). Nearly minimax optimal reinforcement learning for linear mixture markov decision processes. arXiv preprint arXiv:2012.08507 . ZIMMERT, J. and SELDIN, Y. (2019). An optimal algorithm for stochastic and adversarial bandits. In The 22nd International Conference on Artificial Intelligence and Statistics. PMLR.
+
+# Checklist
+
+1. For all authors...
+
+(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   
+(b) Did you describe the limitations of your work? [Yes]   
+(c) Did you discuss any potential negative societal impacts of your work? [N/A] Our work studies the regret bounds for contextual linear bandits with corruption. That is a pure theoretical problem, thus it does not have any negative social impact.   
+(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes]
+
+2. If you are including theoretical results...
+
+(a) Did you state the full set of assumptions of all theoretical results? [Yes] (b) Did you include complete proofs of all theoretical results? [Yes]
+
+3. If you ran experiments...
+
+(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [N/A]   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [N/A]   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [N/A]   
+(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [N/A]
+
+4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...
+
+(a) If your work uses existing assets, did you cite the creators? [N/A]   
+(b) Did you mention the license of the assets? [N/A]   
+(c) Did you include any new assets either in the supplemental material or as a URL? [N/A]   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A]
+
+5. If you used crowdsourcing or conducted research with human subjects...
+
+(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   
+(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   
+(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A]

parse/train/Wz-t1oOTWa/Wz-t1oOTWa_content_list.json

@@ -0,0 +1,1505 @@
+[
+    {
+        "type": "text",
+        "text": "Linear Contextual Bandits with Adversarial Corruptions ",
+        "text_level": 1,
+        "bbox": [
+            232,
+            122,
+            767,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous Author(s)   \nAffiliation   \nAddress   \nemail ",
+        "bbox": [
+            423,
+            226,
+            580,
+            281
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            318,
+            535,
+            334
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 We study the linear contextual bandits problem in the presence of adversarial   \n2 corruption, where the interaction between the player and a possibly infinite decision   \n3 set is contaminated by an adversary that can corrupt the reward up to a corruption   \n4 level $C$ measured by the sum of the largest alteration on rewards in each round.   \n5 We present a variance-aware algorithm that is adaptive to the level of adversarial   \n6 contamination $C$ . The key algorithmic design includes (1) a multi-level partition   \n7 scheme of the observed data, (2) a cascade of confidence sets that are adaptive to   \n8 the level of the corruption, and (3) a variance-aware confidence set construction   \n9 that can take advantage of low-variance reward. We further prove that the regret   \n10 of the proposed algorithm is $\\widetilde { O } ( C ^ { 2 } d \\sqrt { \\textstyle \\sum _ { t = 1 } ^ { T } \\sigma _ { t } ^ { 2 } } + C ^ { 2 } \\sqrt { d T } + C R \\sqrt { d T } )$ , where   \n11 $d$ is the dimension of context vectors, $T$ is the number of rounds, $R$ is the range   \n12 of noise and $\\sigma _ { t } ^ { 2 } , t = 1 \\ldots , T$ are the variances of instantaneous reward. We also   \n13 prove a gap-dependent regret bound for the proposed algorithm, which is instance  \n14 dependent and thus leads to better performance on good practical instances. To the   \n15 best of our knowledge, this is the first variance-aware corruption robust algorithm   \n16 for contextual bandits. ",
+        "bbox": [
+            147,
+            349,
+            767,
+            580
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "17 1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            606,
+            312,
+            623
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "18 Multi-armed bandits algorithms are widely applied in online advertising (Li et al., 2010), clinical   \n19 trials (Villar et al., 2015), recommendation system (Deshpande and Montanari, 2012) and many other   \n20 real-world tasks. In the model of multi-armed bandits, the algorithm needs to decide which action   \n21 (or arm) to take (or pull) at each round and receive a reward for the chosen action. In the stochastic   \n22 setting, the reward is subject to a fixed but unknown distribution for each action. In reality, however,   \n23 these rewards can easily be “corrupted” by some malicious users. A typical example is click fraud   \n24 (Lykouris et al., 2018), where botnets simulate the legitimate users clicking on an ad to fool the   \n25 recommendation systems. This motivates the studies of the bandits algorithms that are robust to   \n26 adversarial corruptions.   \n27 For example, Lykouris et al. (2018) introduced a bandit model in which an adversary could corrupt   \n28 the stochastic reward generated by an arm pull. They proposed an algorithm and show that the   \n29 regret of this “middle ground” scenario degrades smoothly with the amount of corruption injected   \n30 by the adversary. Gupta et al. (2019) proposed an alternative algorithm which gives a significant   \n31 improvement in regret.   \n32 While the algorithms that are robust to the corruptions have been studied in the setting of multi-armed   \n33 bandits in a number of prior works, they are still understudied in the setting of linear contextual   \n34 bandits. The linear contextual bandits problem can be regarded as an extension of the multi-armed   \n35 bandit problem to linear optimization, in order to tackle an unfixed and possibly infinite set of feasible   \n36 actions. There is a large body of literature on efficient algorithms for linear contextual bandits with   \n37 no corruptions (Abe et al., 2003; Auer, 2002; Chu et al., 2011; Dani et al., 2008; Rusmevichientong   \n38 and Tsitsiklis, 2010; Abbasi-Yadkori et al., 2011; Li et al., 2019b), to mention a few. The significance   \n39 of this setting lies in the fact that linear regression approaches are widely used in recommendation   \n40 systems and advertising (Li et al., 2010; Jhalani et al., 2016; Deshpande and Montanari, 2012). Linear   \n41 contextual bandits with adversarial corruptions is an arguably more challenging setting since most of   \n42 the previous corruption-robust algorithms are based on the idea of action elimination (Lykouris et al.,   \n43 2018; Gupta et al., 2019; Bogunovic et al., 2021), which is not applicable to the contextual bandits   \n44 settings where the decision set is time varying and possibly infinite at each round. In Garcelon et al.   \n45 (2020), it is shown that a malicious agent can force a linear contextual bandit algorithm to take any   \n46 desired action $T - o ( T )$ times over $T$ rounds, while applying adversarial corruptions to rewards with   \n47 a cumulative cost that only grow logarithmically. This poses a big challenge for designing corruption   \n48 robust algorithms for linear contextual bandits.   \n49 In this paper, we make a first attempt to study a linear contextual bandit model where an adversary   \n50 can corrupt the rewards up to a corruption level $C$ , which is defined as the the sum of biggest   \n51 alteration the adversary made on rewards in each round. We propose a linear contextual bandits   \n52 algorithm that is robust to reward corruption, dubbed multi-level optimism-in-the-face-of-uncertainty   \n53 weighted learning (Multi-level OFUL). More specifically, our algorithm consists of the following   \n54 novel techniques: (1) We design a multi-level partition scheme and adopt the idea of sub-sampling to   \n55 do the robust estimation of the model parameters; (2) We maintain a cascade of candidate confidence   \n56 sets corresponding to different corruption level (which is unknown) and randomly select a confidence   \n57 set at each round to take the action; and (3) We design confidence sets that depend on the variances   \n58 of rewards, which lead to a potentially tighter regret bound. ",
+        "bbox": [
+            147,
+            637,
+            825,
+            762
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            768,
+            825,
+            838
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            844,
+            823,
+            900
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            90,
+            825,
+            270
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            277,
+            825,
+            416
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "59 Our contributions are summarized as follows: ",
+        "bbox": [
+            150,
+            422,
+            472,
+            436
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We propose a variance-aware algorithm which is adaptive to the amount of adversarial corruptions $C$ . To the best of our knowledge, it is the first algorithm for the setting of linear contextual bandits 2 with adversarial corruptions which does not rely on the finite number of actions and other additional 3 assumptions. ",
+        "bbox": [
+            156,
+            446,
+            825,
+            503
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We prove that the regret of our algorithm is in 64 $\\begin{array} { r } { \\widetilde { O } \\left( C ^ { 2 } d \\sqrt { \\sum _ { t = 1 } ^ { T } \\sigma _ { t } ^ { 2 } } + C ^ { 2 } \\sqrt { d T } + C R \\sqrt { d T } \\right) } \\end{array}$ , where   \n65 $d$ is the dimension of context vectors, $T$ is the number of rounds, $R$ is the range of noise and $\\sigma _ { t } ^ { 2 } , t =$   \n66 $1 \\ldots , T$ are the variances of instantaneous reward. Our regret upper bound has a multiplicative   \n67 dependence on $C ^ { 2 }$ which indicates that our algorithm achieves a sub-linear regret when the   \n68 corruption level satisfies $C = o ( T ^ { 1 / 4 } )$ . ",
+        "bbox": [
+            145,
+            507,
+            825,
+            597
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We also derive a gap-dependent regret bound $\\begin{array} { r } { \\widetilde { O } \\left( \\frac { 1 } { \\Delta } \\cdot C ^ { 2 } R ^ { 2 } d + \\frac { 1 } { \\Delta } \\cdot d ^ { 2 } C ^ { 2 } \\operatorname* { m a x } _ { t \\in \\left[ T \\right] } \\sigma _ { t } ^ { 2 } \\right) } \\end{array}$ for our proposed algorithm, which is instance-dependent and thus leads to a better performance on good practical instances. ",
+        "bbox": [
+            161,
+            601,
+            825,
+            645
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "72 Notation. We use lower case letters to denote scalars, and use lower and upper case bold face letters   \n73 to denote vectors and matrices respectively. We denote by $[ n ]$ the set $\\{ 1 , \\ldots , n \\}$ . For a vector $\\mathbf { x } \\in \\mathbb { R } ^ { d }$   \n74 and matrix $\\pmb { \\Sigma } \\in \\mathbb { R } ^ { d \\times d }$ , a positive semi-definite matrix, we denote by $\\lVert \\mathbf { x } \\rVert _ { 2 }$ the vector’s Euclidean   \n75 norm and define $\\| \\mathbf { x } \\| _ { \\Sigma } = \\sqrt { \\mathbf { x } ^ { \\top } \\Sigma \\mathbf { x } }$ . For two positive sequences $\\left\\{ a _ { n } \\right\\}$ and $\\left\\{ b _ { n } \\right\\}$ with $n = 1 , 2 , \\ldots ,$   \n76 we write $a _ { n } = O ( b _ { n } )$ if there exists an absolute constant $C > 0$ such that $a _ { n } \\leq C b _ { n }$ holds for all   \n77 $n \\geq 1$ and write $a _ { n } = \\Omega ( b _ { n } )$ if there exists an absolute constant $C > 0$ such that $a _ { n } \\geq C b _ { n }$ holds   \n78 for all $n \\geq 1$ . We use ${ \\widetilde { O } } ( \\cdot )$ to further hide the polylogarithmic factors. We use $\\Im ( \\cdot )$ to denote the   \n79 indicator function. ",
+        "bbox": [
+            147,
+            660,
+            825,
+            779
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "80 2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            796,
+            321,
+            814
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "81 Bandits with Adversarial Attacks: There is a large body of literature on the problems of multi  \n82 armed bandits with adversarial corruptions. Most research in this area aims to design algorithms that   \n83 achieve desirable regret bound in both stochastic multi-armed bandits and adversarial bandits, known   \n84 as “the best of both worlds” guarantees (Bubeck and Slivkins, 2012; Seldin and Slivkins, 2014; Auer   \n85 and Chiang, 2016; Seldin and Lugosi, 2017; Zimmert and Seldin, 2019). These works mainly focus   \n86 on achieving bounds in the worst case and the case where there is no adversary. As a result, these   \n87 algorithms are either not robust to instances that moderate amount of corruptions occur, or suffer   \n88 from restrictive assumptions on adversarial corruptions. Distinctive from the above line of research,   \n89 Lykouris et al. (2018) focus on a variant of classic multi-armed bandit model in which each pull of an   \n90 arm generates a stochastic reward that may be contaminated by an adversary before it is revealed   \n91 to the player. In their work, the corruption level $C$ is defined as $\\begin{array} { r } { C = \\sum _ { t } \\mathbf { \\dot { m } } \\mathrm { a x } _ { a } | r ^ { t } ( a ) - r _ { S } ^ { t } ( a ) | } \\end{array}$   \n92 where $\\bar { r } _ { S } ^ { t } ( a )$ is the stochastic reward of arm $a$ and $r ^ { t } ( a )$ is the corrupted reward of arm $a$ at round $t$ .   \n93 They develop algorithms adaptive to the unknown corruption level, which achieves an $O ( K ^ { 1 . 5 } C \\sqrt { T } )$   \n94 regret bound. Gupta et al. (2019) proposed an improved algorithm that can achieve a regret bound   \n95 with only additive dependence on $C$ .   \n96 On the other hand, many research efforts have also been devoted into designing adversarial attacks   \n97 that cause standard algorithms to fail (Jun et al., 2018; Liu and Shroff, 2019; Gupta et al., 2019;   \n98 Garcelon et al., 2020).   \n99 Linear Bandits with Corruptions: Li et al. (2019a) studied stochastic linear bandits with adversarial   \n100 corruptions and achieved $\\widetilde { \\cal O } ( \\textstyle { \\frac { 1 } { \\Delta } } \\cdot d ^ { 5 / 2 } C + \\textstyle { \\frac { 1 } { \\Delta ^ { 2 } } } \\cdot d ^ { 6 } )$ regret bound where $d$ is the dimension of the context   \n101 vectors, $\\Delta$ is the gap between the rewards of the best and the second best action in the decision   \n102 set $\\mathcal { D }$ . The distinction between Li et al. (2019a) and our work is that Li et al. (2019a) considers a   \n103 fixed decision set $\\mathcal { D }$ throughout all $T$ rounds, while we consider contextual bandits with changing   \n104 decision set observed before each round. Bogunovic et al. (2021) also studied linear bandits with   \n105 adversarial corruptions and considered the setting under the assumption that context vectors undergo   \n106 small random perturbations, which is previously introduced by Kannan et al. (2018). Aside from   \n107 the additional assumption, another major distinction in Bogunovic et al. (2021) is that the number   \n108 of actions $k$ is finite and the regret bound depends on $k$ in the contextual setting with unknown   \n109 corruption level $C$ . Recently, Lee et al. (2021) considered corrupted linear bandits with a finite and   \n110 fixed decision set and achieve an instance-independent regret of $\\widetilde { O } ( d \\sqrt { T } + C )$ . Though both their   \n111 work and the work by Li et al. (2019a) focus on corrupted linear stochastic bandits, Lee et al. (2021)   \n112 have a slightly different definition of regret and adopt a strong assumption on corruptions that in   \n113 each round $t$ , the corruptions on rewards are linear in the actions. Neu and Olkhovskaya (2020)   \n114 studied linear contextual bandits with a finite decision set (i.e., $K$ actions) and an adversary. Unlike   \n115 our model, they assume that the adversary can add an arbitrary noise to the loss under a limited   \n116 amount $\\epsilon$ and prove an $\\widetilde { O } ( ( K d ) ^ { \\frac { 1 } { 3 } } T ^ { \\frac { 2 } { 3 } } ) + \\epsilon \\cdot \\sqrt { d } T$ regret bound for their proposed algorithm. Kapoor   \n117 et al. (2019) considered the corrupted linear contextual bandits setting under a strong assumption on   \n118 corruptions that for any prefix, at most an $\\eta$ fraction of the rounds are corrupted. ",
+        "bbox": [
+            148,
+            828,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            92,
+            826,
+            219
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            224,
+            826,
+            267
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            272,
+            825,
+            556
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "19 3 Preliminaries ",
+        "text_level": 1,
+        "bbox": [
+            156,
+            577,
+            316,
+            594
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we study linear contextual bandits with adversarial corruptions. We will introduce our model and some basic concepts in this section. ",
+        "bbox": [
+            166,
+            609,
+            821,
+            638
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "122 Corrupted linear contextual bandits. We consider the the linear contextual bandits model studied   \n123 in Abbasi-Yadkori et al. (2011) under the same corruption studied by Lykouris et al. (2018). In detail,   \n124 distinctive from the linear contextual bandits Abbasi-Yadkori et al. (2011), the interaction between   \n125 the agent and the environment is now contaminated by an adversary. The protocol between the agent   \n126 and the adversary at each round $t \\in [ T ]$ can be described as follows: ",
+        "bbox": [
+            142,
+            643,
+            825,
+            714
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "1. At the beginning of round $t$ , the environment generates an arbitrary decision set $\\mathcal { D } _ { t } \\subseteq \\mathbb { R } ^ { d }$ where each element represents a feasible action that can be selected by the agent.   \n9 2. The environment generates stochastic reward function $r _ { t } ^ { \\prime } ( \\mathbf { a } ) = \\langle \\mathbf { a } , \\mu ^ { * } \\rangle + \\epsilon _ { t } ( \\mathbf { a } )$ together with an upper bound on the standard variance of $\\boldsymbol { \\epsilon } _ { t } ( \\mathbf { a } )$ , i.e., $\\sigma _ { t } ( \\mathbf { a } )$ for all $\\mathbf { a } \\in \\mathcal { D } _ { t }$ .   \n1 3. The adversary observes $D _ { t } , r _ { t } ^ { \\prime } ( \\mathbf { a } ) , \\sigma _ { t } ( \\mathbf { a } )$ for all $\\mathbf { a } \\in \\mathcal { D } _ { t }$ and decides a corrupted reward function   \n32 $r _ { t }$ defined over $\\mathcal { D } _ { t }$ .   \n4. The agent observes $\\mathcal { D } _ { t }$ and selects $\\mathbf { a } _ { t } \\in \\mathcal { D } _ { t }$ .   \n34 5. The adversary observes $\\mathbf { a } _ { t }$ and then returns $r _ { t } ( \\mathbf { a } _ { t } )$ and $\\sigma _ { t } ( \\mathbf { a } _ { t } )$ .   \n35 6. The agent observes $r _ { t } ( \\mathbf { a } _ { t } ) , \\sigma _ { t } ( \\mathbf { a } _ { t } )$ . $\\mathcal { F } _ { t }$ be the $\\sigma$ -algebra generated by $\\mathcal { D } _ { 1 : t } , \\mathbf { a } _ { 1 : t - 1 } , \\epsilon _ { 1 : t - 1 } , r _ { 1 : t - 1 }$ and $\\sigma _ { 1 : t - 1 }$ . ",
+        "bbox": [
+            156,
+            727,
+            826,
+            906
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "136 Let ",
+        "bbox": [
+            142,
+            897,
+            669,
+            912
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "At step 2, 137 $\\mu ^ { * }$ is a hidden vector unknown to the agent which can be observed by the adversary at the 138 beginning. We assume that for all $t \\geq 1$ and all $\\mathbf { a } \\in \\mathcal { D } _ { t }$ , $\\| \\mathbf { a } \\| _ { 2 } \\leq A$ , $| \\langle \\mathbf { a } , \\pmb { \\mu } ^ { * } \\rangle | \\overset { } { \\leq } 1$ and $\\| \\pmb { \\mu } ^ { * } \\| _ { 2 } \\leq B$ 139 almost surely. $\\epsilon _ { t } ( \\mathbf { a } )$ can be any form of random noise as long as it satisfies ",
+        "bbox": [
+            138,
+            90,
+            831,
+            133
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8a2573e946fd439c7f6a2f9d1ddc59d81d52c91be6fee1fb7325a234aaf39b97.jpg",
+        "text": "$$\n\\forall t \\geq 1 , \\forall \\mathbf { a } \\in \\mathcal { D } _ { t } , | \\epsilon _ { t } ( \\mathbf { a } ) | \\leq R , \\quad \\mathbb { E } [ \\epsilon _ { t } ( \\mathbf { a } ) | \\mathcal { F } _ { t } ] = 0 , \\quad \\mathbb { E } [ \\epsilon _ { t } ^ { 2 } ( \\mathbf { a } ) | \\mathcal { F } _ { t } ] \\leq \\sigma _ { t } ^ { 2 } ( \\mathbf { a } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            251,
+            138,
+            745,
+            156
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "140 This assumption on $\\epsilon _ { t }$ is a variant of that in Zhou et al. (2020): We now require the noise to be   \n141 generated for all $\\mathbf { a } \\in \\mathcal { D } _ { t }$ in advance before the adversary decides the corrupted reward function. Our   \n142 assumption on noises is more general than those in (Li et al., 2019a; Bogunovic et al., 2021; Kapoor   \n143 et al., 2019) where they are assumed to be 1-sub-Gaussian or Gaussian.   \n144 At step 3, we assume that the adversary has observed all the previous information and thus may   \n145 predict which policy the agent will take at the current round. However, since the agent can take a   \n146 randomized policy, the adversary may not know exactly which action the agent will take. ",
+        "bbox": [
+            142,
+            160,
+            826,
+            217
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            223,
+            826,
+            266
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "147 Corruption level. We define corruption level ",
+        "bbox": [
+            142,
+            271,
+            480,
+            286
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/174d35223150e3add1e998945327305ca5ead7791d1e156662a6bddc4e86dea0.jpg",
+        "text": "$$\nC = \\frac { 1 } { R + 1 } \\sum _ { t = 1 } ^ { T } \\operatorname* { s u p } _ { \\mathbf { a } \\in \\mathcal { D } _ { t } } | r _ { t } ^ { \\prime } ( \\mathbf { a } ) - r _ { t } ( \\mathbf { a } ) | .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            374,
+            290,
+            624,
+            333
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "148 to indicate the level of adversarial contamination. We say a model is $C$ -corrupted if the corruption   \n149 level is no larger than $C$ . ",
+        "bbox": [
+            143,
+            337,
+            828,
+            366
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our definition of corret al. (2019) where t n leveefine $C = { \\bar { \\sum } } _ { t = 1 } ^ { T } \\operatorname* { m a x } _ { \\mathbf { a } } | r _ { t } ^ { \\prime } ( \\mathbf { a } ) - { \\bar { r } } _ { t } ( \\mathbf { a } ) |$ Lykouris et al. (2018) and Guptain our notation of rewards. We $R$   \nrewards are in range $[ 0 , 1 ]$ . ",
+        "bbox": [
+            160,
+            371,
+            825,
+            435
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Regret. Since the actions selected by the agent may not be deterministic, we define the regret for this 5 model as follows: ",
+        "bbox": [
+            158,
+            440,
+            823,
+            468
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bf159a3c1606725c7e1310f080bb041167077e5a01b01d5bfb39f5853e89e7a2.jpg",
+        "text": "$$\n\\mathbf { R e g r e t } ( T ) = \\sum _ { t = 1 } ^ { T } \\langle \\mathbf { a } _ { t } ^ { * } , \\pmb { \\mu } ^ { * } \\rangle - \\mathbb { E } \\left[ \\sum _ { t = 1 } ^ { T } \\langle \\mathbf { a } _ { t } , \\pmb { \\mu } ^ { * } \\rangle \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            336,
+            470,
+            660,
+            515
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "156 Our definition follows from the definition in Gupta et al. (2019) where the standard metric in stochastic   \n157 multi-armed bandit models of pseudo-regret is adopted. But note that we need to take the expectation   \n158 on $\\textstyle \\sum _ { t = 1 } ^ { T } r _ { t } ^ { \\prime } ( \\mathbf { a } _ { t } )$ (the second term in (3.3)), since a randomized policy is applied in each round.   \n59 Gap. Let $\\Delta _ { t }$ be the gap between the rewards of the best and the second best action in the decision set   \n60 $\\mathcal { D } _ { t }$ as defined in Dani et al. (2008) which can be formally written as ",
+        "bbox": [
+            142,
+            523,
+            825,
+            570
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            150,
+            574,
+            826,
+            603
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fa35f7745cfc768eaad798b91b928e19a70e1319bb8500fac72a902d43fc4dfb.jpg",
+        "text": "$$\n\\Delta _ { t } = \\operatorname* { m i n } _ { \\mathbf { a } \\in \\mathcal { D } _ { t } , \\mathbf { a } \\notin \\mathcal { A } _ { t } ^ { * } } \\left( \\left. \\mathbf { a } _ { t } ^ { * } , \\pmb { \\mu } ^ { * } \\right. - \\left. \\mathbf { a } , \\pmb { \\mu } ^ { * } \\right. \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            369,
+            608,
+            629,
+            632
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where 161 $\\begin{array} { r } { \\mathcal { A } _ { t } ^ { * } = \\mathrm { a r g m a x } _ { \\mathbf { a } \\in \\mathcal { D } _ { t } } \\langle \\mathbf { a } , \\pmb { \\mu } ^ { * } \\rangle } \\end{array}$ and $\\mathbf { a } _ { t } ^ { * }$ is an arbitrary element in $\\boldsymbol { \\mathcal { A } } _ { t } ^ { * }$ . Let $\\Delta$ denotes the smallest 162 gap $\\mathrm { m i n } _ { t \\in [ T ] } \\Delta _ { t }$ . ",
+        "bbox": [
+            150,
+            637,
+            828,
+            669
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "163 4 The Proposed Algorithm ",
+        "text_level": 1,
+        "bbox": [
+            151,
+            685,
+            413,
+            703
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "164 In this section, we propose a variance-aware algorithm, Multi-level OFUL, in Algorithm 1, to tackle   \n165 the corrupted linear contextual bandits problem. At the core of our algorithm is an action partition   \n166 scheme to group historical selected actions and use them to select the future actions in different   \n167 groups with different probabilities. Such a scheme is introduced to deal with the unknown corruption   \n168 level. For simplicity, we denote $r _ { t } ( \\mathbf { a } _ { t } ) , \\sigma _ { t } ( \\mathbf { a } _ { t } )$ in Section 3 by $r _ { t } , \\sigma _ { t }$ in our algorithm.   \n169 Main difficulty in our setting. We begin with the main difficulty that prevents us from applying   \n170 existing algorithms to our setting. Consider a simpler setting where the agent knows the corruption   \n171 level $C$ in prior, and we have $\\sigma _ { t } = R$ for all $t$ . Then we can apply OFUL (Abbasi-Yadkori et al.,   \n172 2011) to solve our problem. In detail, in each round we estimate $\\mu ^ { * }$ by $\\pmb { \\mu } _ { t }$ , which is the minimizer of   \n173 the following ridge regression problem: ",
+        "bbox": [
+            140,
+            717,
+            825,
+            787
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            791,
+            825,
+            863
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5833dffda549744f7475d429107431522075bd6d92961d547ce4320fb7d8b8af.jpg",
+        "text": "$$\n\\pmb { \\mu } _ { t } = \\underset { \\pmb { \\mu } \\in \\mathbb { R } ^ { d } } { \\operatorname { a r g m i n } } \\lambda \\| \\pmb { \\mu } \\| _ { 2 } ^ { 2 } + \\sum _ { i = 1 } ^ { t - 1 } [ \\langle \\pmb { \\mu } , \\mathbf { a } _ { i } \\rangle - r _ { i } ] ^ { 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            357,
+            866,
+            640,
+            910
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Multi-level OFUL ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            90,
+            383,
+            106
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "1: Set the largest level of confidence sets: $\\ell _ { \\mathrm { m a x } } \\gets \\lceil \\log _ { 2 } 2 T \\rceil$ .   \n2: For $\\ell \\in [ \\ell _ { \\mathrm { m a x } } ]$ , set $\\pmb { \\Sigma } _ { 1 , \\ell }  \\lambda \\mathbf { I } , \\pmb { \\mu } _ { 1 , \\ell }  \\mathbf { 0 } , \\mathbf { c } _ { 1 , \\ell }  \\mathbf { 0 }$ .   \n3: Set $\\pmb { \\Sigma } _ { 1 }  \\lambda \\mathbf { I }$ , $\\pmb { \\mu } _ { 1 }  \\mathbf { 0 } , \\mathbf { c } _ { 1 }  \\mathbf { 0 }$ .   \n4: for $t = 1 , \\cdots , T$ do   \n5: Observe $\\mathcal { D } _ { t }$ .   \n6: for $\\ell = 1 , \\cdots , \\ell _ { \\mathrm { m a x } } { \\bf d o }$   \n7: Set $\\beta _ { t , \\ell }$ and $\\mathit { \\Omega } \\gamma _ { t , \\ell }$ as defined in (4.5) and (4.6).   \n8: $\\begin{array} { r l } & { \\mathcal { C } _ { t , \\ell } ^ { \\prime }  \\{ \\mu \\vert \\Vert \\mu - \\mu _ { t } \\Vert _ { \\Sigma _ { t } } \\leq \\beta _ { t , \\ell } \\} \\cap \\{ \\mu \\vert \\Vert \\mu - \\mu _ { t , \\ell } \\Vert _ { \\Sigma _ { t , \\ell } } \\leq \\gamma _ { t , \\ell } \\} . } \\\\ & { \\mathcal { C } _ { t , \\ell }  \\{ \\mathcal { C } _ { t , \\ell } ^ { \\prime } , \\quad \\mathcal { C } _ { t , \\ell } ^ { \\prime } \\neq \\mathcal { D }  } \\end{array}$   \n9:   \n10: end for   \n11: Set $f ( t ) = { \\left\\{ \\begin{array} { l l } { \\ell } \\\\ { 1 } \\end{array} \\right. }$ with probability 2−\\` 1 < \\` ≤ \\`max   \notherwise   \n12: Select $\\mathbf { a } _ { t } \\gets \\mathrm { a r g m a x } _ { \\mathbf { a } \\in \\mathcal { D } _ { t } } \\operatorname* { m a x } _ { \\pmb { \\mu } \\in \\mathcal { C } _ { t , f ( t ) } } \\langle \\pmb { \\mu } , \\mathbf { a } \\rangle$ and observe $r _ { t } , \\sigma _ { t }$ .   \n13: 14: $\\begin{array} { r } { \\Sigma _ { t + 1 } \\gets \\Sigma _ { t } + \\mathbf { a } _ { t } \\mathbf { a } _ { t } ^ { \\top } / \\overline { { \\sigma } } _ { t } ^ { 2 } , \\mathbf { c } _ { t + 1 } \\gets \\mathbf { c } _ { t } + r _ { t } \\mathbf { a } _ { t } / \\overline { { \\sigma } } _ { t } ^ { 2 } , \\mu _ { t + 1 } \\gets \\Sigma _ { t + 1 } ^ { - 1 } \\mathbf { c } _ { t + 1 } . } \\end{array}$ $\\overline { { \\sigma } } _ { t } = \\operatorname* { m a x } \\{ ( R + 1 ) / \\sqrt { d } , \\sigma _ { t } \\}$   \n15: for $\\ell \\neq f ( t )$ do   \n16: $\\Sigma _ { t + 1 , \\ell } \\gets \\Sigma _ { t , \\ell } , \\mathbf { c } _ { t + 1 , \\ell } \\gets \\mathbf { c } _ { t , \\ell } , \\mu _ { t + 1 , \\ell } \\gets \\mu _ { t , \\ell } .$   \n17: end for   \n18: $\\begin{array} { r } { \\sum _ { t + 1 , f ( t ) }  \\sum _ { t , f ( t ) } + \\mathbf { a } _ { t } \\mathbf { a } _ { t } ^ { \\top } / \\overline { { \\sigma } } _ { t } ^ { 2 } , \\mathbf { c } _ { t + 1 , f ( t ) }  \\mathbf { c } _ { t , f ( t ) } + r _ { t } \\mathbf { a } _ { t } / \\overline { { \\sigma } } _ { t } ^ { 2 } . } \\end{array}$   \n19: $\\pmb { \\mu } _ { t + 1 , f ( t ) }  \\pmb { \\Sigma } _ { t + 1 , f ( t ) } ^ { - 1 } \\mathbf { c } _ { t + 1 , f ( t ) }$ t.   \n20: end for   \n174 By slightly modifying the self-normalized martingale concentration inequality proposed in Abbasi  \n175 Yadkori et al. (2011), we can conclude that $\\mu ^ { * }$ belongs to the ellipsoid $\\| \\pmb { \\mu } - \\pmb { \\mu } _ { t } \\| _ { \\pmb { \\Sigma } _ { t } ^ { - 1 } } \\leq \\beta _ { t }$ with high   \n176 probability, where $\\beta _ { t } = \\widetilde { O } ( R \\sqrt { d } + C \\sqrt { d } )$ . Such a confidence bound leads to a final regret which   \n177 has a polynomial dependence on $C$ . However, such a simple approach have two limitations. First,   \n178 the agent does not know $C$ apriori in our setting, thus it is impossible to set $\\beta _ { t }$ to be dependent on   \n179 $C$ . Second, vanilla ridge regression estimator does not consider different variances $\\sigma _ { t }$ in each round,   \n180 thus it only gives a very conservative estimation.   \n181 Action partition scheme. To address the unknown $C$ issue, besides the original estimator $\\pmb { \\mu } _ { t }$ which   \n182 uses all previous data, Algorithm 1 maintains several additional learners to learn $\\mu ^ { * }$ at different   \n183 accuracy level simultaneously, and it randomly selects one of the learners with different probabilities   \n184 at each round. Such a “parallel learning” idea is inspired by Lykouris et al. (2018). In detail,   \n185 we partition the observed data into $\\ell _ { \\mathrm { m a x } }$ levels indexed by $[ \\ell _ { \\mathrm { m a x } } ]$ and maintain $\\ell _ { \\mathrm { m a x } }$ sub-sampled   \n186 estimators $\\mu _ { t , 1 } , \\cdots , \\mu _ { t , \\ell _ { \\mathrm { m a x } } }$ . According to line 11, the observed data in round $t$ goes into level $\\ell$ with   \n187 probability $2 ^ { - \\ell }$ if $1 < \\ell \\leq \\ell _ { \\mathrm { m a x } }$ and it goes to level 1 with probability $\\begin{array} { r } { 1 - \\sum _ { \\ell = 2 } ^ { \\ell _ { \\mathrm { m a x } } } 2 ^ { - \\ell } = 1 / 2 + 2 ^ { - \\ell _ { \\mathrm { m a x } } } } \\end{array}$ .   \n188 The intuition is that if $2 ^ { \\ell } \\geq C$ , then the corruption level experienced by level $\\ell$ ",
+        "bbox": [
+            176,
+            107,
+            669,
+            441
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            467,
+            826,
+            570
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            575,
+            826,
+            694
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/90948d99d61512f0e6f796768d76872175aa79f1173aa7f194a887ce82f14097.jpg",
+        "text": "$$\n\\mathrm { C o r r u p t i o n } _ { t , \\ell } = \\sum _ { i = 1 } ^ { t } \\frac { \\mathbb { 1 } ( f ( i ) = \\ell ) } { R + 1 } \\cdot \\operatorname* { s u p } _ { \\mathbf { a } \\in \\mathcal { D } _ { i } } | r _ { i } ( \\mathbf { a } ) - r _ { i } ^ { \\prime } ( \\mathbf { a } ) |\n$$",
+        "text_format": "latex",
+        "bbox": [
+            315,
+            698,
+            681,
+            741
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "189 can be bounded by some quantity that is independent of $C$ . That says, the individual learners whose   \n190 level is greater than $\\log C$ can learn $\\mu ^ { * }$ successfully, even with the corruption. For the learners whose   \n191 level is less than $\\log C$ , we can also control the error by controlling the probability for the agent to   \n192 select them.   \n193 Weighted regression estimator. After introducing the partition scheme, we still need to deal   \n194 with the varying variance (heteroscedastic) case. Similar to (Kirschner and Krause, 2018; Zhou   \n195 et al., 2020), we proposed the following weighted ridge regression estimator, which incorporates the   \n196 variance information of the rewards into estimation: ",
+        "bbox": [
+            142,
+            746,
+            825,
+            801
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            808,
+            825,
+            864
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/78df6d63e43c8478c2cf5a66981bef67835e37b7d37cb2c3b1d92b001a81efe2.jpg",
+        "text": "$$\n\\pmb { \\mu } _ { t } = \\underset { \\pmb { \\mu } \\in \\mathbb { R } ^ { d } } { \\operatorname { a r g m i n } } \\lambda \\| \\pmb { \\mu } \\| _ { 2 } ^ { 2 } + \\sum _ { i = 1 } ^ { t - 1 } [ \\langle \\pmb { \\mu } , \\mathbf { a } _ { i } \\rangle - r _ { i } ] ^ { 2 } / \\overline { { \\sigma } } _ { i } ^ { 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            344,
+            866,
+            651,
+            910
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "197 Here $\\overline { { \\sigma } } _ { t }$ is defined as the upper bound of the true variance $\\sigma _ { t }$ in line 13. The closed-form solution to   \n198 (4.3) is calculated at each round in line 14. The use of $\\overline { { \\sigma } } _ { t }$ , as we will show later, makes our estimator   \n199 more efficient in the heteroscedastic case. Meanwhile, we also apply our weighted regression   \n200 estimator to each individual learner, and their estimator $\\pmb { \\mu } _ { t , \\ell }$ can be written as follows: ",
+        "bbox": [
+            140,
+            90,
+            825,
+            147
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0f01991bd2be951374e4ee558c91f0465b2c47afcff3ee55e6e87b0272b9ef45.jpg",
+        "text": "$$\n\\pmb { \\mu } _ { t , \\ell } = \\underset { \\pmb { \\mu } \\in \\mathbb { R } ^ { d } } { \\operatorname { a r g m i n } } \\lambda \\| \\pmb { \\mu } \\| _ { 2 } ^ { 2 } + \\sum _ { i = 1 } ^ { t - 1 } \\pmb { 1 } ( f ( i ) = \\ell ) \\cdot [ \\langle \\pmb { \\mu } , \\mathbf { a } _ { i } \\rangle - r _ { i } ] ^ { 2 } / \\overline { { \\sigma } } _ { i } ^ { 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            292,
+            148,
+            705,
+            193
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "201 The closed-form solution to (4.4) is calculated at each round in lines 15–20. ",
+        "bbox": [
+            147,
+            194,
+            671,
+            209
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "202 Final Multi-Level confidence sets. With the estimators $\\pmb { \\mu } _ { t }$ , $\\mathbf { \\nabla } \\cdot \\mu _ { t , 1 } , \\cdot \\cdot \\cdot \\mathbf { \\nabla } , \\mu _ { t , \\ell _ { \\mathrm { m a x } } }$ at the beginning of   \n203 round $t$ , we define a cascade of candidate confidence sets as in lines 6–10, where ",
+        "bbox": [
+            140,
+            214,
+            825,
+            243
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/19b74b7204b650cf9d0d35c5372cca717d1010aca2d8421b6fb6e2fddefa1c70.jpg",
+        "text": "$$\n\\begin{array} { r } { \\beta _ { t , \\ell } = 8 \\sqrt { d \\log \\frac { ( R + 1 ) ^ { 2 } \\lambda + t A ^ { 2 } } { ( R + 1 ) ^ { 2 } \\lambda } \\log ( 4 t ^ { 2 } / \\delta ) } + 4 \\sqrt { d } \\log ( 4 t ^ { 2 } / \\delta ) + 2 ^ { \\ell } \\sqrt { d } + \\sqrt { \\lambda } B , } \\\\ { \\gamma _ { t , \\ell } = 8 \\sqrt { d \\log \\frac { ( R + 1 ) ^ { 2 } \\lambda + t A ^ { 2 } } { ( R + 1 ) ^ { 2 } \\lambda } \\log ( 8 t ^ { 2 } T / \\delta ) } + 4 \\sqrt { d } \\log ( 8 t ^ { 2 } T / \\delta ) + \\overline { { C } } _ { \\ell } \\sqrt { d } + \\sqrt { \\lambda } B , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            199,
+            244,
+            769,
+            330
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "with 204 $\\overline { { C } } _ { \\ell } = \\log ( 2 \\ell ^ { 2 } / \\delta ) + 3$ . For simplicity, we define ",
+        "bbox": [
+            142,
+            333,
+            522,
+            348
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/39b4e2406c211f5b2e7e9640c439aac6a78301a3da0b08899a0e4fb793071cf5.jpg",
+        "text": "$$\n\\ell ^ { * } = \\operatorname* { m a x } \\{ 2 , \\lceil \\log _ { 2 } C \\rceil \\}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            416,
+            349,
+            578,
+            367
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "05 as an important threshold in our later proof for regret bound analysis. Later we will prove that $\\mathcal { C } _ { t , \\ell }$ contains 06 $\\mu ^ { * }$ for all $\\ell \\geq \\ell ^ { * }$ , $t \\geq 1$ with high probability. ",
+        "bbox": [
+            156,
+            369,
+            825,
+            398
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "207 Note that each candidate confidence set can be written as the intersection of two ellipsoids. The   \n208 intuition behind our construction of candidate confidence sets is that we hope that $\\mathcal { C } _ { t , \\ell }$ is robust   \n209 enough to handle the $2 ^ { \\ell }$ -corrupted case, i.e., $\\mu ^ { * } \\in \\mathcal { C } _ { t , \\ell }$ with high probability. To achieve this, the first   \n210 ellipsoid makes use of the global information and the “radius” $\\beta _ { t , \\ell }$ need to contain a factor of $2 ^ { \\ell }$ to   \n211 tolerate a corruption level of $2 ^ { \\ell }$ , and the second ellipsoid makes use of the observed data in level $\\ell$   \n212 since this level only contain a few times of corruptions in $2 ^ { \\ell }$ -corrupted case.   \n213 Action selection. With the candidate confidence sets, we use line 11 to randomly decide one   \n214 confidence set and select an action based on the optimism-in-the-face-of-uncertainty (OFU) principle   \n215 in line 12. Then we update the estimators for the next round $t + 1$ . ",
+        "bbox": [
+            140,
+            402,
+            825,
+            493
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            497,
+            825,
+            540
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Remark 4.1. Our algorithm shares a similar strategy for partitioning the observed data with the algorithm in Lykouris et al. (2018) but note that there is a major difference in that: Lykouris et al. (2018) regard the partition scheme as a “layer structure”, i.e., their algorithm further uses different estimators in layers of parallel learners and do action elimination layer by layer in each round. In contrast, the sub-sampled estimators in our algorithm are used independently, i.e., the selected action only relies on one of the partitions. As a result, Algorithm 1 does not need to do action elimination, thus is capable of handling the cases where the number of actions is huge or even infinite. ",
+        "bbox": [
+            171,
+            542,
+            825,
+            641
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 Main Results ",
+        "text_level": 1,
+        "bbox": [
+            165,
+            659,
+            316,
+            675
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "224 In this section we present our main theorem, which establishes the regret bound for Multi-level   \n225 OFUL. ",
+        "bbox": [
+            150,
+            688,
+            825,
+            717
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Theorem 5.1. Set $\\lambda = 1 / B ^ { 2 }$ . Suppose that $C = \\Omega ( 1 )$ , $R = \\Omega ( 1 )$ , for all $t \\geq 1$ and all $\\mathbf { a } \\in \\mathcal { D } _ { t }$ , $\\left. \\mathbf { a } , \\pmb { \\mu } ^ { * } \\right. \\in \\left[ - 1 , 1 \\right]$ . Then with probability at least $1 - 3 \\delta$ , the regret of Algorithm 1 is bounded as follows: ",
+        "bbox": [
+            173,
+            718,
+            825,
+            760
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bddaf3ffec7a429aac8a2df3f0847f3ec35c544e5da74acafb315197aa176234.jpg",
+        "text": "$$\n\\mathbf { R e g r e t } ( T ) = \\widetilde { O } \\left( C ^ { 2 } d \\sqrt { \\sum _ { t = 1 } ^ { T } \\sigma _ { t } ^ { 2 } } + C ^ { 2 } \\sqrt { d T } + C R \\sqrt { d T } \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            297,
+            757,
+            699,
+            809
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "26 Remark 5.2. When $\\sigma _ { t } , R = \\Omega ( 1 )$ , the regret bound in Theorem 5.1 matches the regret bound of   \n27 OFUL proposed in Zhou et al. (2020) when the corruption level $C$ is a constant. ",
+        "bbox": [
+            155,
+            809,
+            821,
+            837
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Remark 5.3. Compared with the $\\widetilde { O } ( d \\sqrt { T } + C )$ result in Lee et al. (2021), our result has a multiplicative quadratic dependence on $C$ , which seems to be worse. However, we want to emphasize that we focus on a more challenging contextual bandits setting where the decision sets $\\mathcal { D } _ { t }$ at each round are not identical, which is different from that in Lee et al. (2021). Therefore, our result and that in Lee et al. (2021) are not directly comparable. ",
+        "bbox": [
+            168,
+            840,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "233 Remark 5.4. Note that this instance-independent regret upper bound also holds in a stronger model   \n234 than the one described in Section 3, where the adversary can even decide the decision set $\\mathcal { D } _ { t }$ at each   \n235 round $t$ since our regret bound can hold without any assumption on the decision sets. ",
+        "bbox": [
+            145,
+            90,
+            826,
+            133
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Corollary 5.5. Under the same conditions as in Theorem 5.1, if $\\sigma _ { t }$ given by the environment are all $R$ , the regret of Algorithm 1 is bounded by: ",
+        "bbox": [
+            171,
+            137,
+            823,
+            166
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5b5256b29962575ec0c1686029bc059e23206e97dcbeb20c50e30b75c50768e6.jpg",
+        "text": "$$\n\\mathbf { R e g r e t } ( T ) = \\widetilde { O } \\left( C ^ { 2 } d R \\sqrt { T } \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            390,
+            170,
+            606,
+            198
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "236 We also provide a gap-dependent regret bound. ",
+        "bbox": [
+            140,
+            209,
+            483,
+            224
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Theorem 5.6. Suppose that $C = \\Omega ( 1 )$ , $R = \\Omega ( 1 )$ , for all $t \\geq 1$ and all $\\mathbf { a } \\in \\mathcal { D } _ { t }$ , $\\left. \\mathbf { a } , \\pmb { \\mu } ^ { * } \\right. \\in \\left[ - 1 , 1 \\right]$ . Then with probability at least $1 - 3 \\delta$ , the regret of Algorithm 1 is bounded as follows: ",
+        "bbox": [
+            165,
+            228,
+            826,
+            257
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0cbd187ed54acc348c079c241b1b4bed6330f5fc27f45067bc46a658a0ffcb44.jpg",
+        "text": "$$\n\\mathbf { R e g r e t } ( T ) = \\widetilde { O } \\left( \\frac { 1 } { \\Delta } \\cdot C ^ { 2 } R ^ { 2 } d + \\frac { 1 } { \\Delta } \\cdot d ^ { 2 } C ^ { 2 } \\operatorname* { m a x } _ { t \\in [ T ] } \\sigma _ { t } ^ { 2 } \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            313,
+            262,
+            681,
+            297
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "237 Remark 5.7. Theorem 5.6 automatically suggests an ${ \\widetilde O } ( R ^ { 2 } d ^ { 2 } C ^ { 2 } / \\Delta )$ regret bound, by the fact   \n238 $\\sigma _ { t } = O ( R )$ . Compared with previous result $\\widetilde { O } ( d ^ { 5 / 2 } C / \\Delta + d ^ { 6 } / \\Delta ^ { 2 } )$ (Lee et al., 2021), our result   \n239 has a better dependence on the dimension $d$ but a worse dependence on the corruption level $C$ . As   \n240 Remark 5.3 suggests, we focus on a more challenging contextual bandits setting, and the worse   \n241 dependence on $C$ might be due to this. ",
+        "bbox": [
+            140,
+            304,
+            826,
+            380
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "42 6 Proof Outline ",
+        "text_level": 1,
+        "bbox": [
+            156,
+            397,
+            320,
+            415
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "243 First we have the following lemma which is a corruption-tolerant variant of Bernstein inequality for   \n244 self-normalized vector-valued martingales introduced in Zhou et al. (2020). ",
+        "bbox": [
+            151,
+            428,
+            825,
+            457
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Lemma 6.1 (Bernstein inequality for vector-valued martingales with corruptions). Let $\\{ \\mathcal { G } _ { t } \\} _ { t = 1 } ^ { \\infty }$ be a filtration, $\\{ \\mathbf { x } _ { t } , \\eta _ { t } \\} _ { t \\geq 1 }$ a stochastic process so that $\\mathbf { x } _ { t } \\in \\mathbb { R } ^ { d }$ is $\\mathcal { G } _ { t }$ -measurable and $\\eta _ { t } \\in \\mathbb { R }$ is $\\mathcal { G } _ { t + 1 }$ -measurable. Fix $R , L , \\sigma , \\lambda > 0$ , $\\pmb { \\mu } ^ { * } \\in \\mathbb { R } ^ { d }$ . For $t \\geq 1$ let $y _ { t } ^ { \\mathrm { s t o c h } } = \\langle \\pmb { \\mu } ^ { * } , \\mathbf { x } _ { t } \\rangle + \\eta _ { t }$ and suppose that $\\eta _ { t } , \\mathbf { x } _ { t }$ also satisfy ",
+        "bbox": [
+            171,
+            460,
+            825,
+            520
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cc75352bbedb20d0aad7ad12c2ae31f9d839aca3f3cced688c264c31db6cea1d.jpg",
+        "text": "$$\n| \\eta _ { t } | \\leq R , \\mathbb { E } [ \\eta _ { t } | \\mathcal { G } _ { t } ] = 0 , \\mathbb { E } [ \\eta _ { t } ^ { 2 } | \\mathcal { G } _ { t } ] \\leq \\sigma ^ { 2 } , \\| \\mathbf { x } _ { t } \\| _ { 2 } \\leq L .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            328,
+            523,
+            668,
+            544
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "245 Suppose $\\{ y _ { t } \\}$ is a sequence such that $\\textstyle \\sum _ { i = 1 } ^ { t } | y _ { i } - y _ { i } ^ { \\mathrm { s t o c h } } | = C ( t )$ for all $t \\geq 1$ . Then, for any   \n246 $0 < \\delta < 1$ , with probability at least $1 - \\delta$ we have $\\forall t > 0$ , ",
+        "bbox": [
+            137,
+            555,
+            823,
+            587
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2d1c52c084236c8443bdb47960ad863c7ab2a683d0e32130fa8899ad0d0f24d2.jpg",
+        "text": "$$\n\\| \\pmb { \\mu } _ { t } - \\pmb { \\mu } ^ { * } \\| _ { \\mathbf { Z } _ { t } } \\leq \\beta _ { t } + C ( t ) + \\sqrt { \\lambda } \\| \\pmb { \\mu } ^ { * } \\| _ { 2 } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            362,
+            592,
+            632,
+            612
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where for $t \\geq 1$ , $\\begin{array} { r } { { \\bf \\delta } = { \\bf Z } _ { t } ^ { - 1 } { \\bf b } _ { t } , { \\bf Z } _ { t } = \\lambda { \\bf I } + \\sum _ { i = 1 } ^ { t } { \\bf x } _ { i } { \\bf x } _ { i } ^ { \\top } , { \\bf b } _ { t } = \\sum _ { i = 1 } ^ { t } y _ { i } { \\bf x } _ { i } , i } \\end{array}$ and ",
+        "bbox": [
+            173,
+            618,
+            681,
+            637
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/211c8d53c6fed7076a904f1ea7e271b9ea8f317d34b546fa58e41b47790ac961.jpg",
+        "text": "$$\n\\beta _ { t } = 8 \\sigma \\sqrt { d \\log \\frac { d \\lambda + t L ^ { 2 } } { d \\lambda } \\log ( 4 t ^ { 2 } / \\delta ) } + 4 R \\log ( 4 t ^ { 2 } / \\delta ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            313,
+            642,
+            684,
+            678
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "247 Next, we have that with high probability, all the level $\\ell \\geq \\ell ^ { * }$ only influenced by limited amount of   \n248 corruptions as mentioned in Section 4. ",
+        "bbox": [
+            137,
+            688,
+            825,
+            717
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Lemma 6.2. Let Corruption $^ { t , \\ell }$ be defined in (4.2). Then we have with probability at least $1 - \\delta$ , for all $\\ell \\geq \\ell ^ { * }$ , $t \\geq 1$ : ",
+        "bbox": [
+            169,
+            720,
+            823,
+            750
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/91b10d408aadfb07e701353591c3e826d357c45396f42c1484ff5de30e568379.jpg",
+        "text": "$$\n\\mathrm { C o r r u p t i o n } _ { t , \\ell } \\leq \\overline { { C } } _ { \\ell } = \\log ( 2 \\ell ^ { 2 } / \\delta ) + 3 .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            369,
+            747,
+            627,
+            768
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "249 We denote by ${ \\mathcal E } _ { \\mathrm { s u b } }$ the event that the above inequality holds. ",
+        "bbox": [
+            140,
+            775,
+            565,
+            791
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We define the following event to further show that our candidate confidence sets with $\\ell \\geq \\ell ^ { * }$ are “robust” enough, i.e. $\\mathcal { C } _ { t , \\ell }$ contains $\\mu ^ { * }$ with high probability. ",
+        "bbox": [
+            160,
+            799,
+            825,
+            830
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Definition 6.3. Let 252 $\\ell ^ { * }$ be defined in (4.7). We introduce the event ${ \\mathcal { E } } _ { 1 }$ as follows. ",
+        "bbox": [
+            145,
+            832,
+            700,
+            848
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/378140251f952cc4ebfe4cbf97e6e91ffc32a03992eb887b7e5ae136a190080b.jpg",
+        "text": "$$\n\\mathcal { E } _ { 1 } : = \\left\\{ \\forall \\ell \\geq \\ell ^ { * } \\mathrm { ~ a n d ~ } t \\geq 1 , \\| \\pmb { \\mu } ^ { * } - \\pmb { \\mu } _ { t } \\| _ { \\Sigma _ { t } } \\leq \\beta _ { t , \\ell } \\mathrm { ~ a n d ~ } \\| \\pmb { \\mu } ^ { * } - \\pmb { \\mu } _ { t , \\ell } \\| _ { \\Sigma _ { t , \\ell } } \\leq \\gamma _ { t , \\ell } \\right\\} .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            233,
+            872,
+            758,
+            892
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "253 where $\\beta _ { t , \\ell } , \\gamma _ { t , \\ell }$ are defined in (4.5) and (4.6). ",
+        "bbox": [
+            140,
+            896,
+            470,
+            912
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "254 Next lemma suggests that the event $\\mathcal { E } _ { 1 }$ happens with high probability. ",
+        "bbox": [
+            147,
+            90,
+            629,
+            106
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Lemma 6.4. Let $\\mathcal { E } _ { 1 }$ be defined in (6.1). For any $0 < \\delta < 1 / 3$ , we have $\\mathbb { P } ( \\mathcal { E } _ { 1 } ) \\ge 1 - 3 \\delta$ ",
+        "bbox": [
+            161,
+            109,
+            750,
+            126
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For simplicity, we define $\\mathbf { a } _ { t , \\ell } = \\mathop { \\mathrm { a r g m a x } } _ { \\mathbf { a } \\in \\mathcal { D } _ { t } }$ $\\operatorname* { m a x } _ { \\pmb { \\mu } \\in \\mathcal { C } _ { t , \\ell } } \\langle \\pmb { \\mu } , \\mathbf { a } \\rangle$ for each level $\\ell$ . $\\mathbf { a } _ { t }$ can be seen as an action vector randomly chosen from $\\mathbf { a } _ { t , \\ell }$ , $\\ell \\in [ \\ell _ { \\mathrm { m a x } } ]$ . Next two lemmas suggest that under event ${ \\mathcal { E } } _ { 1 }$ at each round, the gap between the optimal reward and the selected reward can be upper bounded by some bonus terms related to $\\mathbf { a } _ { t , \\ell }$ . ",
+        "bbox": [
+            169,
+            135,
+            823,
+            193
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Lemma 6.5. Suppose $\\mathcal { E } _ { 1 }$ occurs. If $f ( t ) ~ \\leq ~ \\ell ^ { * }$ , we have $\\left. \\mathbf { a } _ { t } ^ { * } - \\mathbf { a } _ { t } , \\pmb { \\mu } ^ { * } \\right. \\leq 2 \\beta _ { t , \\ell ^ { * } } \\lVert \\mathbf { a } _ { t } \\rVert _ { \\pmb { \\Sigma } _ { t } ^ { - 1 } } +$ $2 \\beta _ { t , \\ell ^ { * } } \\| \\mathbf { a } _ { t , \\ell ^ { * } } \\| _ { \\Sigma _ { t } ^ { - 1 } }$ . ",
+        "bbox": [
+            169,
+            195,
+            826,
+            232
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Lemma 6.6. On event ${ \\mathcal { E } } _ { 1 }$ , if $f ( t ) = \\ell > \\ell ^ { * }$ , we have $\\langle \\mathbf { a } _ { t } ^ { * } - \\mathbf { a } _ { t } , \\pmb { \\mu } ^ { * } \\rangle \\leq 2 \\gamma _ { t , \\ell } \\| \\mathbf { a } _ { t } \\| _ { \\pmb { \\Sigma } _ { t , \\ell } ^ { - 1 } }$ ",
+        "bbox": [
+            176,
+            234,
+            730,
+            255
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Now we provide the proof sketch of Theorem 5.1. ",
+        "bbox": [
+            161,
+            265,
+            501,
+            281
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "264 Proof sketch of Theorem 5.1 . Suppose $\\mathcal { E } _ { 1 }$ occurs. The main idea to bound the regret is to decompose   \n265 the total rounds $[ T ]$ into two non-overlapping parts, based on which individual learner is selected at   \n266 that round. In detail, we have ",
+        "bbox": [
+            142,
+            295,
+            825,
+            337
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/935cb907b8e4e0c8091ffc2b459aad24853f231bb25d1f18f5d796042597fb6d.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathrm { R e g r e t } ( T ) = \\mathbb { E } \\left[ \\displaystyle \\sum _ { t = 1 } ^ { T } \\left( \\langle \\mathbf { a } _ { t } ^ { * } , \\boldsymbol { \\mu } ^ { * } \\rangle - \\langle \\mathbf { a } _ { t } , \\boldsymbol { \\mu } ^ { * } \\rangle \\right) \\right] } \\\\ & { \\quad \\quad \\quad = \\underbrace { \\mathbb { E } \\left[ \\displaystyle \\sum _ { t = 1 } ^ { T } \\mathbf { 1 } ( f ( t ) \\le \\ell ^ { * } ) \\left( \\langle \\mathbf { a } _ { t } ^ { * } , \\boldsymbol { \\mu } ^ { * } \\rangle - \\langle \\mathbf { a } _ { t } , \\boldsymbol { \\mu } ^ { * } \\rangle \\right) \\right] } _ { T _ { 1 } } } \\\\ & { \\quad \\quad \\quad + \\displaystyle \\sum _ { \\ell = \\ell ^ { * } + 1 } ^ { \\ell _ { \\mathrm { m a x } } } \\underbrace { \\mathbb { E } \\left[ \\displaystyle \\sum _ { t = 1 } ^ { T } \\mathbf { 1 } ( f ( t ) = \\ell ) \\left( \\langle \\mathbf { a } _ { t } ^ { * } , \\boldsymbol { \\mu } ^ { * } \\rangle - \\langle \\mathbf { a } _ { t } , \\boldsymbol { \\mu } ^ { * } \\rangle \\right) \\right] } _ { I _ { 2 } ( \\ell ) } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            269,
+            343,
+            730,
+            517
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "267 Here $I _ { 1 }$ represents the regret where the the \"low-level\" learner is selected, where the corruption level   \n268 is beyond the learner level.For this case, by Lemma 6.5, we can directly show that ",
+        "bbox": [
+            137,
+            520,
+            825,
+            550
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/29b2ff6739d9e8df804b2e4dac23ca0617d887d430ef907fb7d6d58fe6d99eba.jpg",
+        "text": "$$\nI _ { 1 } \\leq \\mathbb { E } \\left[ \\sum _ { t = 1 } ^ { T } \\Im ( f ( t ) \\leq \\ell ^ { * } ) \\operatorname* { m i n } \\left\\{ 2 , 2 \\beta _ { t , \\ell ^ { * } } \\left\\| \\mathbf { a } _ { t , \\ell ^ { * } } \\right\\| _ { \\Sigma _ { t } ^ { - 1 } } + 2 \\beta _ { t , \\ell ^ { * } } \\left\\| \\mathbf { a } _ { t } \\right\\| _ { \\Sigma _ { t } ^ { - 1 } } \\right\\} \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            251,
+            555,
+            745,
+            598
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "269 We further bound (6.3). Let $\\mathcal { F } _ { t }$ be the $\\sigma$ -algebra generated by $\\mathbf { a } _ { s } , r _ { s } , \\sigma _ { s } , f ( s )$ for $s \\leq t - 1$ .   \n270 Then by the property of our partition scheme (note that $\\mathbb { P } ( f ( t ) = \\ell ^ { * } ) = 2 ^ { - \\ell ^ { * } } .$ ), we can show that   \n271 $\\begin{array} { r } { \\mathbb { E } \\left[ \\mathbb { 1 } ( f ( t ) \\leq \\ell ^ { * } ) \\lVert \\mathbf { a } _ { t , \\ell ^ { * } } \\rVert _ { \\Sigma _ { t } ^ { - 1 } } \\big | \\mathcal { F } _ { t } \\right] \\leq 2 ^ { \\ell ^ { * } } \\mathbb { E } \\left[ \\left. \\mathbf { a } _ { t } \\right. _ { \\Sigma _ { t } ^ { - 1 } } \\big | \\mathcal { F } _ { t } \\right] . } \\end{array}$ . Therefore, we can further bound $I _ { 1 }$ by ",
+        "bbox": [
+            138,
+            604,
+            826,
+            660
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a8d29d0b8f01eae0c2584cdf81af83217e3ddd3ffe5a708372d26c41d6212dd2.jpg",
+        "text": "$$\nI _ { 1 } \\leq 4 \\cdot 2 ^ { \\ell ^ { * } } \\mathbb { E } \\underbrace { \\left[ \\sum _ { t = 1 } ^ { T } \\operatorname* { m i n } \\left\\{ 2 , \\beta _ { T , \\ell ^ { * } } \\left\\| \\mathbf { a } _ { t } \\right\\| _ { \\Sigma _ { t } ^ { - 1 } } \\right\\} \\right] } _ { I _ { 3 } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            344,
+            665,
+            651,
+            729
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To further bound 272 $I _ { 3 }$ , we split $[ T ]$ into 2 parts, $\\mathcal { T } _ { 1 } ~ = ~ \\{ t ~ \\in ~ [ T ] | \\| \\mathbf { a } _ { t } / \\overline { { \\sigma } } _ { t } \\| _ { \\Sigma _ { t } ^ { - 1 } } ~ > ~ 1 \\} , \\mathcal { T } _ { 2 } ~ = ~ \\{ t ~ \\in ~$ 273 $[ T ] | \\| \\mathbf { a } _ { t } / \\overline { { \\sigma } } _ { t } \\| _ { \\Sigma _ { t } ^ { - 1 } } \\leq 1 \\}$ to bound $I _ { 3 }$ . The intuition here is that the cardinality of $\\mathcal { T } _ { 1 }$ is bounded, and 274 the sum of terms with $t \\in \\mathcal { T } _ { 2 }$ can be bounded using Cauchy-Schwarz inequality. ",
+        "bbox": [
+            138,
+            733,
+            825,
+            785
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2893eafc7d5f89e147147dc580c018537afd7b21c78be0479b4742711a251c07.jpg",
+        "text": "$$\n\\sum _ { \\in { \\cal T } _ { 1 } } \\operatorname* { m i n } \\left\\{ 2 , \\beta _ { { \\cal T } , \\ell ^ { * } } \\| { \\bf a } _ { t } \\| _ { { \\bfSigma } _ { t } ^ { - 1 } } \\right\\} \\leq 2 | { \\cal T } _ { 1 } | \\leq 2 \\sum _ { t = 1 } ^ { T } \\operatorname* { m i n } \\left\\{ 1 , \\| { \\bf a } _ { t } / \\overline { { \\sigma } } _ { t } \\| _ { { \\Sigma } _ { t } ^ { - 1 } } ^ { 2 } \\right\\} \\leq 4 d \\log \\frac { ( R + 1 ) ^ { 2 } \\lambda + T A ^ { 2 } } { ( R + 1 ) ^ { 2 } \\lambda } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            808,
+            825,
+            851
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "where the first inequality holds since 275 $\\operatorname* { m i n } \\left\\{ 2 , \\beta _ { T , \\ell ^ { * } } \\| \\mathbf { a } _ { t } \\| _ { \\Sigma _ { t } ^ { - 1 } } \\right\\} \\leq 2$ , the second inequality follows 276 from the definition of $\\mathcal { T } _ { 1 }$ , the third inequality holds by Lemma C.2. ",
+        "bbox": [
+            142,
+            875,
+            826,
+            912
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c278c307fcd8d0c565e7350e08c4fc2e02228e1c494552029e16932c8785c7d3.jpg",
+        "text": "$$\n\\begin{array} { r l } { \\displaystyle \\sum _ { t \\in \\mathcal { T } _ { 2 } } \\operatorname* { m i n } \\Big \\{ 2 , \\beta _ { T , \\ell ^ { * } } \\| \\mathbf { a } _ { t } \\| _ { \\Sigma _ { t } ^ { - 1 } } \\Big \\} \\leq \\beta _ { T , \\ell ^ { * } } \\sqrt { \\displaystyle \\sum _ { t \\in \\mathcal { T } _ { 2 } } \\overline { { \\sigma _ { t } ^ { 2 } } } } \\cdot \\sqrt { \\displaystyle \\sum _ { t \\in \\mathcal { Z } _ { 2 } } \\operatorname* { m i n } \\Big \\{ 1 , \\| \\mathbf { a } _ { t } / \\overline { { \\sigma } } _ { t } \\| _ { \\Sigma _ { t } ^ { - 1 } } ^ { 2 } \\Big \\} } } & { } \\\\ { \\leq \\beta _ { T , \\ell ^ { * } } \\sqrt { ( R + 1 ) ^ { 2 } T / d + \\displaystyle \\sum _ { t = 1 } ^ { T } \\sigma _ { t } ^ { 2 } } \\cdot \\sqrt { 2 d \\log \\frac { ( R + 1 ) ^ { 2 } \\lambda + T A ^ { 2 } } { ( R + 1 ) ^ { 2 } \\lambda } } , } & { } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            186,
+            109,
+            810,
+            204
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "277 where the first inequality follows from Cauchy-Schwarz inequality, the second inequality follows   \n278 from the definition of $\\overline { { \\sigma } } _ { t }$ and Lemma C.2. ",
+        "bbox": [
+            140,
+            222,
+            830,
+            251
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "279 Substituting (6.5) and (6.6) into (6.3), we have ",
+        "bbox": [
+            140,
+            257,
+            482,
+            272
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/afb37e7809ddd21911ed7107662fe3463841d0f25ef775d2aab7929ae6a871d9.jpg",
+        "text": "$$\nI _ { 1 } = \\widetilde { O } \\left( C ^ { 2 } d \\sqrt { \\sum _ { t = 1 } ^ { T } \\sigma _ { t } ^ { 2 } } + C ^ { 2 } \\sqrt { d T } + C R \\sqrt { d T } \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            331,
+            277,
+            666,
+            329
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "280 Now it remains to bound $I _ { 2 } ( \\ell )$ . By Lemma 6.6, we have ",
+        "bbox": [
+            140,
+            334,
+            545,
+            351
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b90baa1c0db40d969bc0f76b5d6b597b0960695d7842d557356df57fd2306735.jpg",
+        "text": "$$\nI _ { 2 } ( \\ell ) \\le 2 \\mathbb { E } \\underbrace { \\left[ \\sum _ { t = 1 } ^ { T } \\mathbb { 1 } \\left( f ( t ) = \\ell \\right) \\operatorname* { m i n } \\left\\{ 1 , \\gamma _ { t , \\ell } \\lVert \\mathbf { a } _ { t , \\ell } \\rVert _ { \\Sigma _ { t , \\ell } ^ { - 1 } } \\right\\} \\right] } _ { I _ { 4 } } = \\widetilde { O } \\left( R \\sqrt { T d } + d \\sqrt { \\sum _ { t = 1 } ^ { T } \\sigma _ { t } ^ { 2 } } \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            194,
+            356,
+            769,
+            424
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "281 where the second equality can be proved by analysis similar to that of (6.5) and (6.6). Finally,   \n282 substituting (6.7) and (6.8) into (6.2) ends our proof. ",
+        "bbox": [
+            148,
+            428,
+            828,
+            458
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "84 7 Conclusion and Future Work ",
+        "text_level": 1,
+        "bbox": [
+            156,
+            496,
+            450,
+            513
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we have considered the linear contextual bandits problem in the presence of adversarial corruptions. We propose a Multi-level OFUL algorithm, which is provably robust to the adversarial attacks. We prove a gap-independent regret bound of $\\cdot \\widetilde { O } \\left( C ^ { 2 } d \\sqrt { \\sum _ { t = 1 } ^ { T } \\sigma _ { t } ^ { 2 } } + C ^ { 2 } \\sqrt { d T } + C R \\sqrt { d T } \\right)$ together with a gap-dependent bound of $\\begin{array} { r } { \\widetilde { O } \\left( \\frac { 1 } { \\Delta } \\cdot C ^ { 2 } R ^ { 2 } d + \\frac { 1 } { \\Delta } \\cdot d ^ { 2 } C ^ { 2 } \\operatorname* { m a x } _ { t \\in \\left[ T \\right] } \\sigma _ { t } ^ { 2 } \\right) } \\end{array}$ . ",
+        "bbox": [
+            173,
+            526,
+            825,
+            606
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We leave it as an open question that whether the multiplicative dependence on $C ^ { 2 }$ in the regret upper bounds can be removed without making additional assumptions in our setting. ",
+        "bbox": [
+            173,
+            611,
+            825,
+            641
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            659,
+            267,
+            675
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ABBASI-YADKORI, Y., PÁL, D. and SZEPESVÁRI, C. (2011). Improved algorithms for linear stochastic bandits. In NIPS, vol. 11.   \nABE, N., BIERMANN, A. W. and LONG, P. M. (2003). Reinforcement learning with immediate rewards and linear hypotheses. Algorithmica 37 263–293.   \nAUER, P. (2002). Using confidence bounds for exploitation-exploration trade-offs. Journal of Machine Learning Research 3 397–422.   \nAUER, P. and CHIANG, C.-K. (2016). An algorithm with nearly optimal pseudo-regret for both stochastic and adversarial bandits. In Conference on Learning Theory. PMLR.   \nBOGUNOVIC, I., LOSALKA, A., KRAUSE, A. and SCARLETT, J. (2021). Stochastic linear bandits robust to adversarial attacks. In International Conference on Artificial Intelligence and Statistics. PMLR.   \nBUBECK, S. and SLIVKINS, A. (2012). The best of both worlds: Stochastic and adversarial bandits. In Conference on Learning Theory. JMLR Workshop and Conference Proceedings.   \n05 CHU, W., LI, L., REYZIN, L. and SCHAPIRE, R. (2011). Contextual bandits with linear payoff functions. In Proceedings of the Fourteenth International Conference on Artificial Intelligence and Statistics. JMLR Workshop and Conference Proceedings.   \n08 DANI, V., HAYES, T. P. and KAKADE, S. (2008). Stochastic linear optimization under bandit feedback. In COLT.   \nDESHPANDE, Y. and MONTANARI, A. (2012). Linear bandits in high dimension and recommendation systems. In 2012 50th Annual Allerton Conference on Communication, Control, and Computing (Allerton). IEEE. GARCELON, E., ROZIERE, B., MEUNIER, L., TARBOURIECH, J., TEYTAUD, O., LAZARIC, A. and PIROTTA, M. (2020). Adversarial attacks on linear contextual bandits. arXiv preprint arXiv:2002.03839 . GUPTA, A., KOREN, T. and TALWAR, K. (2019). Better algorithms for stochastic bandits with adversarial corruptions. In Conference on Learning Theory. PMLR.   \n18 JHALANI, T., KANT, V. and DWIVEDI, P. (2016). A linear regression approach to multi-criteria recommender system. In International Conference on Data Mining and Big Data. Springer.   \nJUN, K.-S., LI, L., MA, Y. and ZHU, X. J. (2018). Adversarial attacks on stochastic bandits. In NeurIPS.   \n22 KANNAN, S., MORGENSTERN, J. H., ROTH, A., WAGGONER, B. and WU, Z. (2018). A smoothed analysis of the greedy algorithm for the linear contextual bandit problem. In NeurIPS.   \n24 KAPOOR, S., PATEL, K. K. and KAR, P. (2019). Corruption-tolerant bandit learning. Machine Learning 108 687–715.   \n26 KIRSCHNER, J. and KRAUSE, A. (2018). Information directed sampling and bandits with heteroscedastic noise. In Conference On Learning Theory. PMLR. LEE, C.-W., LUO, H., WEI, C.-Y., ZHANG, M. and ZHANG, X. (2021). Achieving near instanceoptimality and minimax-optimality in stochastic and adversarial linear bandits simultaneously. arXiv preprint arXiv:2102.05858 . LI, L., CHU, W., LANGFORD, J. and SCHAPIRE, R. E. (2010). A contextual-bandit approach to personalized news article recommendation. In Proceedings of the 19th international conference on World wide web.   \n34 LI, Y., LOU, E. Y. and SHAN, L. (2019a). Stochastic linear optimization with adversarial corruption. arXiv preprint arXiv:1909.02109 .   \n36 LI, Y., WANG, Y. and ZHOU, Y. (2019b). Nearly minimax-optimal regret for linearly parameterized bandits. In Conference on Learning Theory. PMLR.   \nLIU, F. and SHROFF, N. (2019). Data poisoning attacks on stochastic bandits. In International Conference on Machine Learning. PMLR.   \n40 LYKOURIS, T., MIRROKNI, V. and PAES LEME, R. (2018). Stochastic bandits robust to adversarial corruptions. In Proceedings of the 50th Annual ACM SIGACT Symposium on Theory of Computing.   \n42 NEU, G. and OLKHOVSKAYA, J. (2020). Efficient and robust algorithms for adversarial linear contextual bandits. In Conference on Learning Theory. PMLR.   \n44 RUSMEVICHIENTONG, P. and TSITSIKLIS, J. N. (2010). Linearly parameterized bandits. Mathematics of Operations Research 35 395–411.   \n46 SELDIN, Y. and LUGOSI, G. (2017). An improved parametrization and analysis of the $\\exp 3 + +$ algorithm for stochastic and adversarial bandits. In Conference on Learning Theory. PMLR.   \n48 SELDIN, Y. and SLIVKINS, A. (2014). One practical algorithm for both stochastic and adversarial bandits. In International Conference on Machine Learning. PMLR. ",
+        "bbox": [
+            147,
+            683,
+            828,
+            912
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            153,
+            83,
+            828,
+            919
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "VILLAR, S. S., BOWDEN, J. and WASON, J. (2015). Multi-armed bandit models for the optimal design of clinical trials: benefits and challenges. Statistical science: a review journal of the Institute of Mathematical Statistics 30 199. ZHOU, D., GU, Q. and SZEPESVARI, C. (2020). Nearly minimax optimal reinforcement learning for linear mixture markov decision processes. arXiv preprint arXiv:2012.08507 . ZIMMERT, J. and SELDIN, Y. (2019). An optimal algorithm for stochastic and adversarial bandits. In The 22nd International Conference on Artificial Intelligence and Statistics. PMLR. ",
+        "bbox": [
+            150,
+            90,
+            826,
+            210
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Checklist ",
+        "text_level": 1,
+        "bbox": [
+            166,
+            234,
+            254,
+            251
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            261,
+            339,
+            275
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   \n(b) Did you describe the limitations of your work? [Yes]   \n(c) Did you discuss any potential negative societal impacts of your work? [N/A] Our work studies the regret bounds for contextual linear bandits with corruption. That is a pure theoretical problem, thus it does not have any negative social impact.   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            238,
+            280,
+            825,
+            398
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            402,
+            493,
+            417
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [Yes] (b) Did you include complete proofs of all theoretical results? [Yes] ",
+        "bbox": [
+            238,
+            421,
+            735,
+            453
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            212,
+            457,
+            393,
+            472
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [N/A]   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [N/A]   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [N/A]   \n(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [N/A] ",
+        "bbox": [
+            238,
+            474,
+            825,
+            594
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            214,
+            598,
+            823,
+            613
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [N/A]   \n(b) Did you mention the license of the assets? [N/A]   \n(c) Did you include any new assets either in the supplemental material or as a URL? [N/A]   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] ",
+        "bbox": [
+            238,
+            617,
+            825,
+            738
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            214,
+            742,
+            704,
+            757
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   \n(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   \n(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] ",
+        "bbox": [
+            238,
+            761,
+            825,
+            849
+        ],
+        "page_idx": 10
+    }
+]

parse/train/dwJyEMPZ04I/dwJyEMPZ04I.md

@@ -0,0 +1,241 @@
+# CRYPTEN: Secure Multi-Party Computation Meets Machine Learning
+
+# Brian Knott Shubho Sengupta
+
+Shobha Venkataraman Mark Ibrahim Facebook AI Research
+
+Awni Hannun Laurens van der Maaten
+
+{brianknott,shobha,awni,ssengupta,marksibrahim,lvdmaaten}@fb.com
+
+# Abstract
+
+Secure multi-party computation (MPC) allows parties to perform computations on data while keeping that data private. This capability has great potential for machine-learning applications: it facilitates training of machine-learning models on private data sets owned by different parties, evaluation of one party’s private model using another party’s private data, etc. Although a range of studies implement machine-learning models via secure MPC, such implementations are not yet mainstream. Adoption of secure MPC is hampered by the absence of flexible software frameworks that “speak the language” of machine-learning researchers and engineers. To foster adoption of secure MPC in machine learning, we present CRYPTEN: a software framework that exposes popular secure MPC primitives via abstractions that are common in modern machine-learning frameworks, such as tensor computations, automatic differentiation, and modular neural networks. This paper describes the design of CRYPTEN and measure its performance on state-ofthe-art models for text classification, speech recognition, and image classification. Our benchmarks show that CRYPTEN’s GPU support and high-performance communication between (an arbitrary number of) parties allows it to perform efficient private evaluation of modern machine-learning models under a semi-honest threat model. For example, two parties using CRYPTEN can securely predict phonemes in speech recordings using Wav2Letter [17] faster than real-time. We hope that CRYPTEN will spur adoption of secure MPC in the machine-learning community.
+
+# 1 Introduction
+
+Secure multi-party computation (MPC; [30, 69]) allows parties to collaboratively perform computations on their combined data sets without revealing the data they possess to each other. This capability of secure MPC has the potential to unlock a variety of machine-learning applications that are currently infeasible because of data privacy concerns. For example, secure MPC can allow medical research institutions to jointly train better diagnostic models without having to share their sensitive patient data [27] or allow social scientists to analyze gender wage gap statistics without companies having to share sensitive salary data [42]. The prospect of such applications of machine learning with rigorous privacy and security guarantees has spurred a number of studies on machine learning via secure MPC [38, 41, 48, 58, 63, 66, 67]. However, at present, adoption of secure MPC in machine learning is still relatively limited considering its wide-ranging potential. One of the main obstacles to widespread adoption is that the complexity of secure MPC techniques puts them out of reach for most machine-learning researchers, who frequently lack in-depth knowledge of cryptographic techniques.
+
+To foster the adoption of secure MPC techniques in machine learning, we present CRYPTEN: a flexible software framework that aims to make modern secure MPC techniques accessible to machinelearning researchers and developers without a background in cryptography. Specifically, CRYPTEN provides a comprehensive tensor-computation library in which all computations are performed via secure MPC. CRYPTEN’s API closely follows the API of the popular PyTorch framework for machine learning [54, 55], which makes it easy to use for machine-learning practitioners. For example, it provides automatic differentiation and a modular neural-network package. CRYPTEN assumes an semi-honest threat model [30, $\ S 2 . 3 . 2 ]$ and works for an arbitrary number of parties. To make private training and inference efficient, CRYPTEN off-loads computations to the GPU and uses high-performance communication libraries to implement interactions between parties.
+
+The paper presents: (1) an overview of CRYPTEN’s design principles; (2) a description of the design of CRYPTEN and of the secure MPC protocols implemented; (3) a collection of benchmark experiments using CRYPTEN to run private versions of state-of-the-art models for text classification, speech recognition, and image classification; and (4) a discussion of open problems and a roadmap for the further development of CRYPTEN. Altogether, the paper demonstrates that CRYPTEN’s flexible, PyTorch-like API makes private inference and training of modern machine-learning models easy to implement and efficient. For example, CRYPTEN allows two parties to privately classify an image [26, 35] in 2-3 seconds, or to securely make phoneme predictions for 16kHz speech recordings [17] faster than real-time. We hope that CRYPTEN’s promising performance and ease-ofuse will foster the adoption of secure MPC by the machine-learning community, and pave the way for a new generation of secure and private machine-learning systems.
+
+# 2 Related Work
+
+CRYPTEN is part of a large body of work that develops secure MPC protocols for machine learning; see Appendix ??. Most closely related to our work is CryptGPU [63], which implements an 2-out-of-3 replicated secret sharing protocol [4, 37] on top of CRYPTEN. Like CRYPTEN, CryptGPU provides security against semi-honest corruption, but it is limited to the three-party setting. CryptGPU is one of several protocols optimized for the three-party setting. For example, Falcon [67] implements a maliciously secure three-party MPC protocol, combining techniques from SecureNN [66] and ABY3 [48]. Falcon allows evaluation and training of convolutional networks such as AlexNet [40] and VGG [62]. Other systems that work in this setting include Astra [16], Blaze [56], and CrypTFlow [41].
+
+There also exists a family of two-party systems that, like CRYPTEN, assume a semi-honest threat model. These systems include Gazelle [38], Chameleon [58], EzPC [15], MiniONN [45], SecureML [49], PySyft [60], and Delphi [47]. XONN [59] also works in the two-party setting but provides malicious security. Compared to these systems, CRYPTEN provides a more flexible machinelearning focused $\mathsf { A P I } ^ { 1 }$ that supports reverse-mode automatic differentiation, implements a rich set of functions, and natively runs on GPUs. Moreover, CRYPTEN supports a wider range of use cases by working with an arbitrary number of parties, and make communication between parties efficient via communication primitives that were optimized for high-performance distributed computing.
+
+# 3 Design Principles
+
+In the development of CRYPTEN, we adopted the following two main design principles:
+
+Machine-learning first API. CRYPTEN has a general purpose, machine-learning first API design. Most other secure MPC frameworks [34] adopt an API that stays close to the underlying MPC protocols. This hampers adoption of these frameworks in machine learning, for example, because they do not natively support tensor operations (but only scalar operations) and because they lack features that machine-learning researchers have come to expect, such as automatic differentiation. Instead, CRYPTEN implements the tensor-computation API of the popular PyTorch machine-learning framework [54], implements reverse-mode automatic differentiation, provides a modular neuralnetwork package with corresponding learning routines, and supports GPU computations. We aim to allow developers to transition code from PyTorch to CRYPTEN by changing a single Python import.
+
+Eager execution. CRYPTEN adopts an imperative programming model. This is different from existing MPC frameworks, which generally implement compilers for their own domain-specific languages [34]. While compiler approaches have potential performance benefits, they slow down the development cycle, make debugging harder, and prevent users from using arbitrary host-language constructs [3]. Instead, CRYPTEN follows the recent trend in machine learning away from graph compilers [1] to frameworks that eagerly execute computations [3, 55], providing a better developer experience. Yet, CRYPTEN is performant because it implements state-of-the-art secure MPC protocols (for settings with arbitrary number of parties), because it uses PyTorch’s highly optimized tensor library for most computations, because computations can be off-loaded to the GPU, and because it uses communication libraries that were optimized for high-performance distributed computing.
+
+![](images/811459a65803d2cf6672a49fc171d393271b4ddb88fc57f3a215684834958580.jpg)  
+Figure 1: High-level overview of the design of CRYPTEN. See text in Section 4 for details.
+
+# 4 Design Overview
+
+Figure 1 gives an overview of CRYPTEN’s design. Parties perform computations using efficient PyTorch tensor operations. Because secure MPC computations are integer computations that are not natively supported on GPUs, CRYPTEN maps between integer and floatingpoint computations on GPUs; see Section 5.3. The multi-party computations are implemented on arithmetic and binary secret shares [22, 32]; see Section 5.1. Whereas many computations can be performed directly on arithmetic secret shares, others require conversion between arithmetic and binary secret shares (A2B) and back (B2A); see Section 5.2. Some multiparty computations require interaction between parties via a communicator that employs the high-performance communication primitives in Gloo [31] and NCCL [51]. Some multi-party computations require Beaver triples [7], which are supplied by a trusted third party (TTP).2
+
+![](images/133623b93e7fb43d5744e1894a0fac18a5c926f237f36c8cbe7096f166b2b680.jpg)  
+Figure 2: Example of secret-sharing tensors, revealing tensors, and private addition in CRYPTEN.
+
+All secure computations are wrapped in a CrypTensor object that implements the PyTorch tensor API and that provides reverse-mode automatic differentiation (autograd) to enable gradient-based training of arbitrary (deep) learning models. Figure 2 illustrates CrypTensor creation, i.e., how tensors are secret-shared and revealed, as well as a simple computation (addition). Note that each party involved in the multi-party computation executes the same code. Whenever communication between the parties is required (e.g., as part of private multiplications), the communication acts as a synchronization point between the parties. The crypten.init() call is required once to establish the communication channel. In the example, the input tensor for the creation of the arithmetic secret share is provided party $\mathtt { s r c = 0 }$ , which indicates the rank3 of the party that supplies the data to be secret-shared (the other parties executing this code may provide None as input).
+
+To enable deep-learning use cases, CRYPTEN allows implementing neural networks following PyTorch’s API. Figure 3 shows how to create and encrypt neural networks and how to use automatic differentiation in CRYPTEN. The example assumes that some training sample and the associated target label are provided by the party with rank 0 (note the value of src). As illustrated by the example, CRYPTEN’s API closely follows that of PyTorch. Indeed, it is possible to write a single training loop that can be used to train models using CRYPTEN or PyTorch without code changes. This makes it easy to adapt PyTorch code to use secure MPC for its computations, and it also makes debugging easier. The appendix presents a table listing all tensor functions that CrypTensor implements.
+
+To enable interoperability with existing machinelearning platforms, neural networks can be imported into CRYPTEN via ONNX. Figure 4 shows how a PyTorch model is imported into CRYPTEN. The example illustrates how CRYPTEN makes private inference with a ResNet-18 easy. The example in the figure also demonstrates CRYPTEN’s GPU support. One caveat is that all parties must use the same type of device (i.e., CPU or GPU) for computations.
+
+# 5 Secure Computations
+
+To facilitate secure computations, CRYPTEN implements arithmetic secret sharing [22, 23] and binary secret sharing [32], as well as conversions between these two types of sharing [24]. Arithmetic secret sharing is particularly wellsuited for operations that are common in modern machine-learning models, such as matrix multiplications and convolutions. Binary secret sharing is required for evaluating certain other common functions, such as rectified linear units. We provide a high-level overview of CRYPTEN’s secure computation protocol here; a detailed description is presented in the appendix.
+
+Figure 3: Example using neural networks and automatic differentiation in CRYPTEN.   
+
+<table><tr><td>import</td><td>crypten.nn as nn</td><td>import crypten.optimizer as optimizer</td></tr><tr><td>#</td><td></td><td>create model，criterion，and optimizer:</td></tr><tr><td></td><td></td><td>model_enc = nn.Sequential(</td></tr><tr><td></td><td></td><td>nn.Linear(sample_dim，hidden_dim),</td></tr><tr><td></td><td>nn.ReLU()，</td><td></td></tr><tr><td></td><td></td><td>nn.Linear(hidden_dim，num_classes),</td></tr><tr><td>).encrypt()</td><td></td><td></td></tr><tr><td></td><td></td><td>criterion = nn.CrossEntropyLoss()</td></tr><tr><td></td><td>optimizer = optimizer.SGD(</td><td></td></tr><tr><td></td><td></td><td>model_enc.parameters()，lr=@.1，momentum=0.9,</td></tr><tr><td>）</td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td>perform prediction on sample:</td></tr><tr><td></td><td></td><td>target_enc = crypten.cryptensor(target，src=0)</td></tr><tr><td></td><td></td><td>sample_enc = crypten.cryptensor(sample，src=0)</td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td>output_enc = model_enc(sample_enc)</td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td>#</td><td></td><td>：perform backward pass and update parameters:</td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td>model_enc.zero_grad()</td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td>loss_enc = criterion(output_enc，target_enc)</td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td>loss_enc.backward()</td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td>optimizer.step()</td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr></table>
+
+![](images/ccc61810e5fc4638489507058d70992b7846aeb8aa555d87d1a38254d20420e4.jpg)  
+Figure 4: Private inference on secret-shared images using a secret-shared ResNet-18 model on GPU.
+
+# 5.1 Secret Sharing
+
+Arithmetic secret sharing shares a scalar value $x \in \mathbb { Z } / Q \mathbb { Z }$ , where $\mathbb { Z } / Q \mathbb { Z }$ denotes a ring with $Q$ elements, across parties $p \in \mathcal P$ . We denote the sharing of $x$ by $[ x ] = \{ [ x ] _ { p } \} _ { p \in \mathcal { P } }$ , where $[ x ] _ { p } \in \mathbb { Z } / Q \mathbb { Z }$ indicates party $p$ ’s share of $x$ . The shares are constructed such that their sum reconstructs the original value $x$ , that is, $\begin{array} { r } { x = \sum _ { p \in \mathcal { P } } [ x ] _ { p } } \end{array}$ mod $Q$ . To share a value $x$ , the parties generate a pseudorandom zero-share [18] with $| \mathcal { P } |$ random numbers that sum to 0. The party that possesses the value $x$ adds $x$ to their share and discards $x$ . We use a fixed-point encoding to obtain $x$ from a floating-point value, $x _ { R }$ . To do so, we multiply $x _ { R }$ with a large scaling factor $B$ and round to the nearest integer: $x = \lfloor B x _ { R } \rceil$ , where $B = 2 ^ { L }$ for some precision of $L$ bits. To decode a value, $x$ , we compute $x _ { R } \approx x / _ { B }$ .
+
+Binary secret sharing is a special case of arithmetic secret sharing that operates within the binary field $\mathbb { Z } / 2 \mathbb { Z }$ . A binary secret share, $\langle x \rangle$ , of a value $x$ is formed by arithmetic secret shares of the bits of $x$ , setting $Q = 2$ . Each party $p \in \mathcal P$ holds a share, $\langle x \rangle _ { p }$ , such that $\begin{array} { r } { x = \bigoplus _ { p \in \mathcal { P } } \langle x \rangle _ { p } } \end{array}$ is satisfied.
+
+Conversion from $[ x ]$ to $\langle x \rangle$ is implemented by having the parties create a binary secret share of their $[ x ] _ { p }$ shares, and summing the resulting binary shares. Specifically, the parties create a binary secret share, $\langle [ x ] _ { p } \rangle$ , of all the bits in $[ x ] _ { p }$ . Subsequently, the parties compute $\begin{array} { r } { \langle x \rangle = \sum _ { p \in \mathcal { P } } \langle [ x ] _ { p } \rangle } \end{array}$ using a carry-lookahead adder in $\log _ { 2 } ( | \mathcal { P } | ) \log _ { 2 } ( L )$ communication rounds [14, 21].
+
+Conversion from $\langle x \rangle$ to $[ x ]$ is achieved by computing $\begin{array} { r } { [ x ] = \sum _ { b = 1 } ^ { B } 2 ^ { b } \left[ \langle x \rangle ^ { ( b ) } \right] } \end{array}$ , where $\langle x \rangle ^ { ( b ) }$ denotes the $b$ -th bit of the binary share $\langle x \rangle$ and $B$ is the total number of bits in the shared secret, $\langle x \rangle$ . To create an arithmetic share of a bit, the parties use secret shares, $\left( [ r ^ { ( b ) } ] , \langle r ^ { ( b ) } \rangle \right)$ , of random bits $r ^ { ( b ) }$ . The random bits are provided by the TTP, but we plan to add an implementation that generates them off-line via oblivious transfer [39]. The parties use $\langle r ^ { ( b ) } \rangle$ to mask $\langle x \rangle ^ { ( b ) }$ and reveal the resulting masked bit $z ^ { ( b ) }$ . Subsequently, they compute $\left[ \langle x \rangle ^ { ( b ) } \right] = \left[ \dot { r } ^ { ( b ) } \right] + z ^ { ( b ) } - 2 \left[ r ^ { ( b ) } \right] z ^ { ( b ) }$ .
+
+# 5.2 Secure Computation
+
+Arithmetic and binary secret shares have homomorphic properties that can be used to implement secure computations. All computations in CRYPTEN are based on private addition and multiplication.
+
+Private addition of two arithmetically secret shared values, $[ z ] = [ x ] + [ y ]$ , is implemented by having each party $p$ sum their shares of $[ x ]$ and $[ y ]$ : each party $p \in \mathcal P$ computes $[ z ] _ { p } = [ x ] _ { p } + [ y ] _ { p }$ .
+
+Private multiplication is implemented using random Beaver triples [7], $( [ a ] , [ b ] , [ c ] )$ with $c { = } a b$ , that are provided by the TTP. The parties compute $[ \epsilon ] = [ x ] - [ a ]$ and $[ \delta ] = [ y ] - [ b ]$ , and decrypt $\epsilon$ and $\delta$ without information leakage due to the masking. They compute the result $[ x ] [ y ] = [ c ] + \epsilon [ b ] + [ a ] \delta + \epsilon \delta$ , using trivial implementations of addition and multiplication of secret shares with public values.
+
+Linear functions are trivially implemented as combinations of private addition and multiplication.   
+This allows CRYPTEN to compute dot products, outer products, matrix products, and convolutions.
+
+Non-linear functions are implemented using standard approximations that only require private addition and multiplication. Specifically, CRYPTEN evaluates exponentials using a limit approximation, logarithms using Householder iterations [36], and reciprocals using Newton-Rhapson iterations. This allows CRYPTEN to implement functions that are commonly used in machine-learning models, including the sigmoid, softmax, and logistic-loss functions, as well as their gradients.
+
+Comparators are implemented using a function that evaluates $[ z < 0 ]$ by: (1) converting $[ z ]$ to a binary secret-share $\langle z \rangle$ ; (2) computing its sign bit, $\langle b \rangle = \langle z \rangle > > ( L - 1 )$ ; and (3) converting the resulting bit to an arithmetic sharing $[ b ]$ . This function allows CRYPTEN to implement arbitrary comparators. For example, it evaluates $[ { \bar { x } } < y ]$ by computing $[ z ] = [ x ] - [ y ]$ and evaluating $[ z < 0 ]$ . Similarly, CRYPTEN can evaluate: (1) the sign function via $\mathrm { s i g n } ( [ x ] ) = 2 [ x > 0 ] - 1$ ; (2) the absolute value function via $| [ x ] | = [ x ] \operatorname { s i g n } ( [ x ] )$ ; and (3) rectified linear units via $\mathrm { R e L \bar { U } } ( [ x ] ) = [ x ] [ x > 0 ]$ . CRYPTEN also supports multiplexing; to do so, it evaluates $[ c ? x : y ] = [ c ] [ x ] + { \bar { ( } } 1 - [ c ] { \bar { ) } } [ y ]$ .
+
+Lemma 1. The CRYPTEN secure-computation protocol is secure against information leakage against any static passive adversary corrupting up to $| \mathcal { P } | - 1$ of the $| \mathcal { P } |$ parties involved in the computation.
+
+The proof of this lemma follows trivially from [9, 11, 21, 24], and is given in the appendix. We adopt a protocol that provides security under a semi-honest threat model because it enables a wide range of use cases of secure machine learning, whilst being more efficient than maliciously secure protocols.
+
+# 5.3 Off-loading Computations to the GPU
+
+Hardware acceleration via GPUs is a critical component for training and inference in modern machinelearning models. Akin to frameworks such as PyTorch [55] and TensorFlow [1], CRYPTEN can off-load computations to the GPU. On the GPU, it uses highly-optimized implementations for a range of functions that are provided by CUDA libraries such as cuBLAS [19] and cuDNN [20].
+
+Unfortunately, these libraries are designed for computations on floating-point numbers and do not support the integer types required to perform computations on $L$ -bit fixed-point numbers. Akin to [63], we circumvent this problem by observing that for all integers $a , b \in \mathbb { Z } \cap [ - 2 ^ { 2 6 } , 2 ^ { 2 6 } ]$ , we can compute the product $a b$ using 64-bit floating-point representations and still recover the correct value over the integers. Specifically, CRYPTEN splits each 64-bit variable into four components, $a = a _ { 0 } + 2 ^ { 1 6 } a _ { 1 } \stackrel {  } { + } 2 ^ { 3 2 } a _ { 2 } ^ { \cdot } + 2 ^ { 4 8 } a _ { 3 }$ , where each $a _ { i }$ represents a 16-bit integer component. We compute a product $a b$ of 64-bit integers by summing 10 pairwise products of their 16-bit components.
+
+![](images/efcd5190480a11854e31bc38c593f3c32d108f3abbcbb69c3ec1924167a8a4c2.jpg)  
+Figure 5: Benchmarks for inference with text-sentiment classification model on GPUs in CRYPTEN and PyTorch. Left: Average wall-clock time per sample (in seconds). Middle: Number of bytes communicated per sample, per party (in GB). Right: Number of communication rounds per sample.
+
+The pairwise products of the 16-bit components are computed in parallel using highly optimized floating-point CUDA kernels. The same approach is used for matrix multiplications and convolutions. CRYPTEN further optimizes this approach by splitting into only 3 components of 22-bits each when possible, which reduces the number of pairwise products required to 6 (see [63, Remark II.1]).
+
+# 6 Benchmarks
+
+To measure the performance of CRYPTEN, we performed experiments on three tasks: (1) text classification using a linear model that learns word embeddings; (2) speech recognition using the Wav2Letter model [17]; and (3) image classification using residual networks [35] and vision transformers [26]. Because of space constraints, we focus on private inference using a secret-shared model on secret-shared data here, but our benchmark results with private training are very similar.
+
+We performed benchmark experiments on a proprietary cluster, testing inference on both CPUs (Intel Skylake 18-core 1.6GHz) and GPUs (nVidia P100). We set the number of OpenMP threads to 1 in all benchmarks. All experiments were performed with the parties running in separate processes on a single machine. For GPU experiments, each party was assigned its own GPU. Although this setup is faster than a scenario in which each party operates its own machine,4 we believe our benchmark results provide a good sense of CRYPTEN’s performance. We average computation times over 30 batches, excluding the computation on the first batch as that computation may include CuDNN benchmarking. Code reproducing the results of our experiments is available on https://crypten.ai.
+
+In our benchmarks, we focus on comparing (ciphertext) CRYPTEN computation with (plaintext) PyTorch computation. We refer the reader to [33, 63] for benchmarks that compare CRYPTEN to other secure MPC frameworks. Specifically, [33] finds CRYPTEN is $1 1 - 1 8 \times$ faster than PySyft [60] and approximately $3 \times$ faster than TF-Trusted [13] in MNIST classification [43] on CPU.
+
+# 6.1 Text Classification
+
+We performed text-sentiment classification experiments on the Yelp review dataset [70] using a model that consists of a linear layer operating on word embeddings. The embedding layer contains 32- dimensional embeddings of 519, 820 words, and the linear layer produces a binary output indicating the sentiment of the review. We evaluated the model on GPUs, varying the batch size and the number of parties participating. The normalized mean squared error $( | | \mathbf x - \mathbf { \dot { y } } | | ^ { 2 } / | | \mathbf x | | ^ { 2 } )$ between the output of the CRYPTEN model and that of its PyTorch counterpart was smaller than $4 \cdot 1 0 ^ { - 4 } $ in all experiments.
+
+Figure 5 presents the results of our experiments. The figure shows inference time per sample (in seconds) as a function of the number of parties involved in the computation for varying batch sizes (left); the amount of communication required per sample, per party (in GB); and the number of communication rounds required per sample. We include results in which the number of parties is 1: herein, we run the CRYPTEN protocol but involve no other parties, which implies that the single party is running the protocol on unencrypted data. One-party results allow us to bisect different sources of computational overhead: specifically, they separate overhead due to communication from overhead due to fixed-point encoding, function approximations, and (lack of) sparse-matrix operations.
+
+![](images/b0658af9330fe3f0b0cd6dd97fe40648a1dc6375b17948b5be253afa14a028a5.jpg)  
+Figure 6: Benchmarks for inference with Wav2Letter model on GPUs in CRYPTEN and PyTorch. Left: Average wall-clock time per sample (in seconds). Middle: Number of bytes communicated per sample, per party (in GB). Right: Number of communication rounds per sample.
+
+![](images/85dd11331cac96bf90ef7dac7b3fe6359546bbd37b78ebb5b01cbabc22b4d4e0.jpg)  
+Figure 7: Wall-clock time per sample (in sec.) for Wav2Letter inference on CPUs and GPUs.
+
+![](images/419fd550afcb26e94285cc85b4c5517df824e8a0fad306a23d47f29810826738.jpg)  
+Figure 8: Average wall-clock time per sample (in seconds) for communication and computation during inference with Wav2Letter model on CPU (left) and GPU (right).
+
+The results in Figure 5 show that CRYPTEN is about 2.5–3 orders of magnitude slower than PyTorch in text-sentiment classification, depending on the number of parties involved. Most computational overhead is the word embedding layer: whereas PyTorch can evaluate this layer efficiently via a sparse matrix multiplication, CRYPTEN cannot do sparse lookups as they would reveal information on the encrypted input. Instead, CRYPTEN performs a full matrix multiplication between the wordcount vector and the embedding matrix. Yet, text sentiment predictions are quite fast in CRYPTEN: inference takes only 0.03 seconds per sample in the two-party setting with a batch size of 32.
+
+The results also show that increasing the batch size is an effective way to reduce inference time and communication per sample. The number of communication rounds is independent of the batch size, which means communication rounds can be amortized by using larger batch sizes. The number of bytes communicated is partly amortized as well because the size of weight tensors (e.g., in linear layers) does not depend on batch size. The results also show that whereas the number of communication rounds increases when moving from two-party to three-party computation, it remains constant afterwards. The larger number of communication rounds for three-party computation stems from the public division protocol, which requires additional communication rounds when more than two parties are involved to prevent wrap-around errors (see the appendix for details).
+
+# 6.2 Speech Recognition
+
+We performed speech-recognition experiments using Wav2Letter [17] on the LibriSpeech dataset [53]. The LibriSpeech dataset contains $1 6 \mathrm { k H z }$ audio clips represented as a waveform (16, 000 samples per second). Because the audio clips vary in length, we clip all of them to 1 second for the benchmark. Wav2Letter is a network with 13 convolutional layers using rectified linear unit (ReLU; [50]) activations.5 The network operates directly on the waveform input, predicting one of 29 labels (26 letters plus 3 special characters). The first two layers use a filter size of 250 (with stride 160) and 48 (stride 2). The next seven layers use filter size 7, followed by two layers with filter size 32 and 1 (all with stride 1). All layers except the last two have 250 channels. The last two layers have 2, 000 channels.
+
+The results in Figure 6 show that CRYPTEN is about 2.5–3 orders of magnitude slower than PyTorch depending on the number of parties involved. For Wav2Letter, the overhead is largely due to the ReLU layers in the network: evaluating a ReLU function requires a comparison, which involves a conversion between arithmetic and binary secret sharing and back (see the appendix). The number of communication rounds increases when the number of parties grows beyond 4: CRYPTEN uses a tree reduction for the summation in the comparator protocol, which implies that the number of communication rounds grows whenever the number of parties increases from 2k to 2k+1.
+
+![](images/575335d99447214996c3aa9f3fc17c794e696a3513c6149dee7f62038b7cf7da.jpg)  
+Figure 9: Benchmarks for inference with image-classification models on GPUs in CRYPTEN and PyTorch. Top: Results for ResNet-18 model. Bottom: Results for ViT-B/16 vision transformer. Left: Average wall-clock time per sample (in seconds). Middle: Number of bytes communicated per sample, per party (in GB). Right: Number of communication rounds per sample.
+
+Figure 7 also presents results comparing Wav2Letter inference time between CPUs and GPUs. The results in the figure show that CRYPTEN is 1-2 orders of magnitude faster on GPUs than on CPUs. In real-world settings, this speedup can make the difference between a secure MPC use case being practical or not. Figure 8 shows how much wall-clock time is spent on communication and computation, respectively, when performing inference with Wav2Letter (using batch size 32). The results suggest that, whereas multi-party evaluation is compute-bound on CPU, it is communicationbound on GPU. On GPUs, $6 3 \%$ of the time is spent on communication in eight-party computation.
+
+# 6.3 Image Classification
+
+We performed image-classification experiments on the ImageNet dataset using residual networks (ResNets; [35]) and vision transformers (ViT; [26]).6 We experimented with a ResNet-18 with 18 convolutional layers and with a ViT-B/16 model that has 12 multi-head self-attention layers with 12 heads each, operating on image patches of $1 6 \times 1 6$ pixels. Following common practice [35], we preprocess images by rescaling them to size $2 5 6 \times 2 5 6$ and taking a center crop of size $2 2 4 \times 2 2 4$ .
+
+Figure 9 presents the results of our image-classification benchmarks, which show that two parties can securely evaluate a ResNet-18 model in 2.49 seconds and a ViT-B/16 model in 8.47 seconds. A notable difference compared to the prior results is that the number of bytes communicated per sample is no longer reduced by increasing the batch size. The reason for this is that the vast majority of communication involves tensors that have the same size as intermediate activation functions: activation tensors are much larger than weight tensors in image-classification models. The amount of communication required to evaluate the ViT-B/16 model is particularly high due to the repeated evaluation of the softmax function in the attention layer of Transformers [65]. We also observe that in ResNet-18, the number of communication rounds grows faster than expected for larger batch sizes. The reason for this is that the carry-lookahead adder [21] used in the conversion from $[ x ]$ to $\langle x \rangle$ is very memory-intensive. When CRYPTEN runs out of GPU memory, it replaces the adder by an implementation that requires $O ( | \mathcal { P } | )$ communication rounds (compared to $( \log _ { 2 } | \mathcal { P } | )$ for the carry-lookahead adder) but that requires less memory.
+
+# 7 Conclusion and Future Work
+
+In this paper, we have introduced and benchmarked CRYPTEN. We hope that CRYPTEN’s flexible, machine-learning first API design and performance can help foster adoption of secure MPC in machine learning. We see the following directions for future research and development of CRYPTEN.
+
+Numerical issues are substantially more common in CRYPTEN implementations of machine-learning algorithms than in their PyTorch counterparts. In particular, the fixed-point representation with $L$ bits of precision $L { = } 1 6$ by default) is more prone to numerical overflow or underflow than floating-point representations. Moreover, arithmetic secret shares are prone to wrap-around errors in which the sum of the shares $[ x ] _ { p }$ exceeds the size of the ring, $Q = 2 ^ { 6 4 }$ . Wrap-around errors can be difficult to debug because they may only arise in the multi-party setting, in which no individual party can detect them. We plan to implement tools in CRYPTEN that assist users in debugging such numerical issues.
+
+End-to-end privacy requires seamless integration between data-processing frameworks, such as secure SQL implementations [5], and data-modeling frameworks like CRYPTEN. In “plaintext” software, such frameworks are developed independently and combined via “glue code” or platforms that facilitate the construction of processing and modeling pipelines. Real-world use cases of machine learning via secure MPC require the development of a platform that makes the integration of private data processing and modeling seamless, both from an implementation and a security point-of-view.
+
+Differential privacy mechanisms may be required in real-world applications of CRYPTEN in order to provide rigorous guarantees on the information leakage that inevitably occurs when the results of a private computation are publicly revealed [28]. CRYPTEN implements sampling algorithms for the Bernoulli, Laplace, and Gaussian distributions (see appendix), which allows for the implementation of randomized response [68], the Laplace mechanism [29], and the Gaussian mechanism [6, 28] (although care must be taken when implementing these mechanisms [12, 46]). In future work, we aim to use these mechanisms, for example, to do a secure MPC implementation of DP-SGD [2].
+
+Threat models may vary per use case. Specifically, some use cases may require malicious security or may not provide a TTP. Possible extensions may include support for malicious security via message authentication codes [22], as well as support for Beaver triple generation via additive homomorphic encryption [52], oblivious transfer [39], or more recent methods [10] to eliminate the need for a TTP.
+
+Model architecture design for secure MPC is another important direction for future research. Following prior work in this research area, this study has focused on implementing existing machinelearning models in a secure MPC framework. However, these models were designed based on computational considerations in “plaintext” implementations of the models on modern GPU or TPU hardware. The results of our benchmarks suggest that this may be suboptimal because those considerations are very different in a secure MPC environment. For example, the evaluation of softmax functions over large numbers of values requires a lot of communication in secure MPC, which makes attention layers very slow. This implies that multilayer perceptron models [64] are likely much more efficient than vision transformers [26, 65] for image classification. We hope that CRYPTEN’s machine-learning API and ease of use will spur studies that design model architectures specifically optimized for a secure MPC environment, for example, via neural architecture search [44, 47, 71].
+
+# 8 Broader Impact
+
+Although we believe that the adoption of secure MPC in machine learning can lead to the development of AI systems that are substantially more private and secure, we note that there are also potential downsides to such adoption. In particular, because the computations in secure MPC are performed on encrypted data, it can be harder to do quality control of AI systems implemented in CRYPTEN. For example, it is impossible to inspect the values of intermediate activations (or even model outputs) unless all parties agree to reveal those values. This may make it harder to explain why a model makes a certain decision [25] or to detect data-poisoning attacks [8]. Indeed, there exist fundamental trade-offs between privacy and utility [57] and those trade-offs apply to CRYPTEN users, too.
+
+It is also worth noting that, although the protocols implemented in CRYPTEN come with rigorous cryptographic guarantees, practical implementations of these protocols may be broken by other means. For example, we have no reason to assume that CRYPTEN would not be susceptible to side-channel attacks [61]. Hence, good data stewardship remains essential even when using secure computation.
+
+Acknowledgments. We thank Joe Spisak, Sijun Tan, Gregory Chanan, Igor Fedan, and the PyTorch team for their support. We thank Mark Tygert, Anderson Nascimento, Amrita Roy Chowdhury, and anonymous reviewers for helpful discussions and feedback on early versions of this paper.
+
+References   
+[1] M. Abadi, A. Agarwal, P. Barham, E. Brevdo, Z. Chen, C. Citro, G. S. Corrado, A. Davis, J. Dean, M. Devin, S. Ghemawat, I. Goodfellow, A. Harp, G. Irving, M. Isard, Y. Jia, R. Jozefowicz, L. Kaiser, M. Kudlur, J. Levenberg, D. Mané, R. Monga, S. Moore, D. Murray, C. Olah, M. Schuster, J. Shlens, B. Steiner, I. Sutskever, K. Talwar, P. Tucker, V. Vanhoucke, V. Vasudevan, F. Viégas, O. Vinyals, P. Warden, M. Wattenberg, M. Wicke, Y. Yu, and X. Zheng. TensorFlow: Large-scale machine learning on heterogeneous systems, 2015.   
+[2] M. Abadi, A. Chu, I. Goodfellow, H. McMahan, I. Mironov, K. Talwar, and L. Zhang. Deep learning with differential privacy. In Proceedings of the CCS, pages 308–318, 2016.   
+[3] A. Agrawal, A. N. Modi, A. Passos, A. Lavoie, A. Agarwal, A. Shankar, I. Ganichev, J. Levenberg, M. Hong, R. Monga, and S. Cai. TensorFlow Eager: A multi-stage, python-embedded dsl for machine learning. In arXiv:1903.01855, 2019.   
+[4] T. Araki, J. Furukawa, Y. Lindell, A. Nof, and K. Ohara. High throughput semi-honest secure three-party computation with an honest majority. In ACM CCS, pages 805–817, 2016.   
+[5] D. W. Archer, D. Bogdanov, L. Kamm, Y. Lindell, K. Nielsen, J. I. Pagter, N. P. Smart, and R. N. Wright. From keys to databases – real-world applications of secure multi-party computation. Computer Journal, 61(12):1749–1771, 2018.   
+[6] B. Balle and Y.-X. Wang. Improving the Gaussian mechanism for differential privacy. In Proceedings of International Conference on Machine Learning, 2018.   
+[7] D. Beaver. Efficient multiparty protocols using circuit randomization. In Annual International Cryptology Conference, pages 420–432. Springer, 1991.   
+[8] B. Biggio, B. Nelson, and P. Laskov. Poisoning attacks against support vector machines. In International Conference on Machine Learning (ICML), pages 1467–1474, 2012.   
+[9] D. Bogdanov, S. Laur, and J. Willemson. Sharemind: A framework for fast privacy-preserving computations. In S. Jajodia and J. Lopez, editors, Computer Security - ESORICS 2008, pages 192–206. Springer Berlin Heidelberg, 2008.   
+[10] E. Boyle, G. Couteau, N. Gilboa, Y. Ishai, L. Kohl, and P. Scholl. Correlated pseudorandom functions from variable-density LPN. In Cryptology ePrint Archive: Report 2020/1417, 2020.   
+[11] R. Canetti. Universally composable security: A new paradigm for cryptographic protocols. In Proceedings of the Annual Symposium on Foundations of Computer Science, pages 136–145, 2001.   
+[12] C. Canonne, G. Kamath, and T. Steinke. The discrete Gaussian for differential privacy. In arXiv 2004.00010, 2020.   
+[13] Cape Privacy. TF-Trusted. URL https://github.com/capeprivacy/tf-trusted.   
+[14] O. Catrina and S. De Hoogh. Improved primitives for secure multiparty integer computation. In International Conference on Security and Cryptography for Networks, pages 182–199. Springer, 2010.   
+[15] N. Chandran, D. Gupta, A. Rastogi, R. Sharma, and S. Tripathi. EzPC: Programmable, efficient, and scalable secure two-party computation for machine learning. In IEEE European Symposium on Security and Privacy, 2019.   
+[16] H. Chaudhari, A. Choudhury, A. Patra, and A. Suresh. Astra: High throughput 3pc over rings with application to secure prediction. In ACM SIGSAC Conference on Cloud Computing Security Workshop, 2019.   
+[17] R. Collobert, C. Puhrsch, and G. Synnaeve. Wav2letter: An end-to-end convnet-based speech recognition system. In arXiv:1609.03193, 2016.   
+[18] R. Cramer, I. Damgård, and Y. Ishai. Share conversion, pseudorandom secret-sharing and applications to secure computation. In Lecture Notes in Computer Science, volume 3378, pages 342–362, 2005.   
+[19] cuBLAS. https://developer.nvidia.com/cublas.   
+[20] cuDNN. https://developer.nvidia.com/cudnn.   
+[21] I. Damgård, M. Fitzi, E. Kiltz, J. B. Nielsen, and T. Toft. Unconditionally secure constant-rounds multi-party computation for equality, comparison, bits and exponentiation. In TCC, 2005.   
+[22] I. Damgård, V. Pastro, N. Smart, and S. Zakarias. Multiparty computation from somewhat homomorphic encryption. Cryptology ePrint Archive, Report 2011/535, 2011. https:// eprint.iacr.org/2011/535.   
+[23] I. Damgård, D. Escudero, T. Frederiksen, M. Keller, P. Scholl, and N. Volgushev. New primitives for actively-secure mpc over rings with applications to private machine learning. In Proceedings of the IEEE Symposium on Security and Privacy, 2019.   
+[24] D. Demmler, T. Schneider, and M. Zohner. ABY – A framework for efficient mixed-protocol secure two-party computation. In NDSS, 2015.   
+[25] F. Doshi-Velez and B. Kim. Towards a rigorous science of interpretable machine learning. In arXiv:1702.08608, 2017.   
+[26] A. Dosovitskiy, L. Beyer, A. Kolesnikov, D. Weissenborn, X. Zhai, T. Unterthiner, M. Dehghani, M. Minderer, G. Heigold, S. Gelly, J. Uszkoreit, and N. Houlsby. An image is worth 16x16 words: Transformers for image recognition at scale. In ICLR, 2021.   
+[27] T. Dugan and X. Zou. A survey of secure multiparty computation protocols for privacy preserving genetic tests. In Proceedings of the International Symposium on Biomedical Imaging, 2016.   
+[28] C. Dwork and A. Roth. The algorithmic foundations of differential privacy. Foundations and Trends in Theoretical Computer Science, 9(3–4):211–407, 2014.   
+[29] C. Dwork, F. McSherry, K. Nissim, and A. Smith. Calibrating noise to sensitivity in private data analysis. In Theory of cryptography conference, pages 265–284. Springer, 2006.   
+[30] D. Evans, V. Kolesnikov, and M. Rosulek. A Pragmatic Introduction to Secure Multi-Party Computation. NOW Publishers, 2018.   
+[31] Gloo. https://github.com/facebookincubator/gloo.   
+[32] O. Goldreich, S. Micali, and A. Wigderson. How to play any mental game or a completeness theorem for protocols with honest majority. In STOC, pages 218–229, 1987.   
+[33] V. Haralampieva, D. Rueckert, and J. Passerat-Palmbach. A systematic comparison of encrypted machine learning solutions for image classification. In Proceedings of the Workshop on PrivacyPreserving Machine Learning in Practice, pages 55–59, 2020.   
+[34] M. Hastings, B. Hemenway, D. Noble, and S. Zdancewic. SoK: general-purpose compilers for secure multi-party computation. In 2019 IEEE Symposium on Security and Privacy $( S P )$ , 2019.   
+[35] K. He, X. Zhang, S. Ren, and J. Sun. Deep residual learning for image recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2016.   
+[36] A. S. Householder. The Numerical Treatment of a Single Nonlinear Equation. 1970.   
+[37] M. Ito, A. Saito, and T. Nishizeki. Secret sharing scheme realizing general access structure. Electronics and Communications in Japan (Part III: Fundamental Electronic Science), 72: 56–64, 1989.   
+[38] C. Juvekar, V. Vaikuntanathan, and A. Chandrakasan. Gazelle: A low latency framework for secure neural network inference. In arXiv 1801.05507, 2018.   
+[39] M. Keller, E. Orsini, and P. Scholl. MASCOT: Faster malicious arithmetic secure computation with oblivious transfer. In Proceedings of the ACM SIGSAC Conference on Computer and Communications Security, pages 830–842, 2016.   
+[40] A. Krizhevsky, I. Sutskever, and G. E. Hinton. Imagenet classification with deep convolutional neural networks. Communications of the ACM, 60(6):84–90, 2017.   
+[41] N. Kumar, M. Rathee, N. Chandran, D. Gupta, A. Rastogi, and R. Sharma. CrypTFlow: Secure TensorFlow inference. In IEEE Symposium on Security and Privacy, pages 336–353, 2020.   
+[42] A. Lapets, N. Volgushev, A. Bestavros, F. Jansen, and M. Varia. Secure multi-party computation for analytics deployed as a lightweight web application. Technical Report BU-CS-TR 2016-008, Boston University, 2016.   
+[43] Y. LeCun, L. Bottou, Y. Bengio, and P. Haffner. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.   
+[44] H. Liu, K. Simonyan, and Y. Yang. DARTS: Differentiable architecture search. In arXiv:1806.09055, 2018.   
+[45] J. Liu, M. J. Y. Lu, and N. Asokan. Oblivious neural network predictions via MiniONN transformations. In ACM Conference on Computer and Communications Security (CCS), 2017.   
+[46] I. Mironov. On significance of the least significant bits for differential privacy. In Proceedings ACM Conference on Computer and Communications Security (CCS), pages 650–661, 2012.   
+[47] P. Mishra, R. Lehmkuhl, A. Srinivasan, W. Zheng, and R. Popa. Delphi: A cryptographic inference service for neural networks. In USENIX Security Symposium, 2020.   
+[48] P. Mohassel and P. Rindal. ABY3: A mixed protocol framework for machine learning. In ACM Conference on Computer and Communications Security (CCS), 2018.   
+[49] P. Mohassel and Y. Zhang. SecureML: A system for scalable privacy-preserving machine learning. In IEEE Symposium on Security and Privacy, 2017.   
+[50] V. Nair and G. E. Hinton. Rectified linear units improve restricted boltzmann machines. In Proceedings of the International Conference on Machine Learning (ICML), 2010.   
+[51] NCCL. https://developer.nvidia.com/nccl.   
+[52] P. Paillier. Public-key cryptosystems based on composite degree residuosity classes. In EUROCRYPT, pages 223–238, 1999.   
+[53] V. Panayotov, G. Chen, D. Povey, and S. Khudanpur. LibriSpeech: An ASR corpus based on public domain audio books. In Proceedings of the International Conference on Acoustics, Speech, and Signal Processing (ICASSP), 2015.   
+[54] A. Paszke, S. Gross, S. Chintala, and G. Chanan. PyTorch: Tensors and dynamic neural networks in Python with strong GPU acceleration, 2017.   
+[55] A. Paszke, S. Gross, F. Massa, A. Lerer, J. Bradbury, G. Chanan, T. Killeen, Z. Lin, N. Gimelshein, L. Antiga, A. Desmaison, A. Köpf, E. Yang, Z. DeVito, M. Raison, A. Tejani, S. Chilamkurthy, B. Steiner, L. Fang, J. Bai, and S. Chintala. PyTorch: An imperative style, high-performance deep learning library. In Advances in Neural Information Processing Systems (NeurIPS), 2019.   
+[56] A. Patra and A. Suresh. Blaze: Blazing fast privacy preserving machine learning. In Symposium on Network and Distributed System Security (NDSS), 2020.   
+[57] I. S. Reed. Information theory and privacy in data banks. In Proceedings of the June 4-8, 1973, National Computer Conference and Exposition, 1973.   
+[58] M. S. Riazi, C. Weinert, O. Tkachenko, E. M. Songhori, T. Schneider, and F. Koushanfar. Chameleon: A hybrid secure computation framework for machine learning applications. In Cryptology ePrint Archive, volume 2017/1164, 2017.   
+[59] M. S. Riazi, M. Samragh, H. Chen, K. Laine, K. Lauter, and F. Koushanfar. Xonn: Xnor-based oblivious deep neural network inference. In USENIX Security, 2019.   
+[60] T. Ryffel, A. Trask, M. Dahl, B. Wagner, J. Mancuso, D. Rueckert, and J. Passerat-Palmbach. A generic framework for privacy preserving deep learning. In arXiv:1811.04017, 2018.   
+[61] O. Seker, S. Berndt, L. Wilke, and T. Eisenbarth. SNI-in-the-head: Protecting MPC-in-the-head protocols against side-channel analysis. In Cryptology ePrint Archive: Report 2020/544, 2020.   
+[62] K. Simonyan and A. Zisserman. Very deep convolutional networks for large-scale image recognition. In ICLR, 2015.   
+[63] S. Tan, B. Knott, Y. Tian, and D. J. Wu. CryptGPU: Fast privacy-preserving machine learning on the GPU. In arXiv 2104.10949, 2021.   
+[64] I. Tolstikhin, N. Houlsby, A. Kolesnikov, L. Beyer, X. Zhai, T. Unterthiner, J. Yung, A. Steiner, D. Keysers, J. Uszkoreit, M. Lucic, and A. Dosovitskiy. MLP-Mixer: An all-MLP architecture for vision. In arXiv:2105.01601, 2021.   
+[65] A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, L. Kaiser, and I. Polosukhin. Attention is all you need. In Advances in Neural Information Processing Systems (NeurIPS), 2017.   
+[66] S. Wagh, D. Gupta, and N. Chandran. SecureNN: Efficient and private neural network training. In Cryptology ePrint Archive, volume 2018/442, 2018.   
+[67] S. Wagh, S. Tople, F. Benhamouda, E. Kushilevitz, P. Mittal, and T. Rabin. FALCON: Honestmajority maliciously secure framework for private deep learning. In Proc. Priv. Enhancing Technol., 2021.   
+[68] S. L. Warner. Randomized response: A survey technique for eliminating evasive answer bias. Journal of the American Statistical Association, 60(309):63–69, 1965.   
+[69] A. C.-C. Yao. How to generate and exchange secrets. In FOCS, pages 162–167, 1986.   
+[70] Yelp. Yelp Review Dataset. URL https://www.yelp.com/dataset.   
+[71] B. Zoph and Q. V. Le. Neural architecture search with reinforcement learning. In arXiv:1611.01578, 2016.

parse/train/dwJyEMPZ04I/dwJyEMPZ04I_content_list.json

@@ -0,0 +1,1002 @@
+[
+    {
+        "type": "text",
+        "text": "CRYPTEN: Secure Multi-Party Computation Meets Machine Learning ",
+        "text_level": 1,
+        "bbox": [
+            228,
+            122,
+            772,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Brian Knott Shubho Sengupta ",
+        "text_level": 1,
+        "bbox": [
+            267,
+            226,
+            390,
+            255
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Shobha Venkataraman Mark Ibrahim Facebook AI Research ",
+        "bbox": [
+            413,
+            226,
+            576,
+            266
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Awni Hannun Laurens van der Maaten ",
+        "bbox": [
+            612,
+            226,
+            787,
+            253
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "{brianknott,shobha,awni,ssengupta,marksibrahim,lvdmaaten}@fb.com ",
+        "bbox": [
+            225,
+            268,
+            772,
+            281
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            318,
+            535,
+            334
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Secure multi-party computation (MPC) allows parties to perform computations on data while keeping that data private. This capability has great potential for machine-learning applications: it facilitates training of machine-learning models on private data sets owned by different parties, evaluation of one party’s private model using another party’s private data, etc. Although a range of studies implement machine-learning models via secure MPC, such implementations are not yet mainstream. Adoption of secure MPC is hampered by the absence of flexible software frameworks that “speak the language” of machine-learning researchers and engineers. To foster adoption of secure MPC in machine learning, we present CRYPTEN: a software framework that exposes popular secure MPC primitives via abstractions that are common in modern machine-learning frameworks, such as tensor computations, automatic differentiation, and modular neural networks. This paper describes the design of CRYPTEN and measure its performance on state-ofthe-art models for text classification, speech recognition, and image classification. Our benchmarks show that CRYPTEN’s GPU support and high-performance communication between (an arbitrary number of) parties allows it to perform efficient private evaluation of modern machine-learning models under a semi-honest threat model. For example, two parties using CRYPTEN can securely predict phonemes in speech recordings using Wav2Letter [17] faster than real-time. We hope that CRYPTEN will spur adoption of secure MPC in the machine-learning community. ",
+        "bbox": [
+            232,
+            349,
+            766,
+            626
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            654,
+            310,
+            670
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Secure multi-party computation (MPC; [30, 69]) allows parties to collaboratively perform computations on their combined data sets without revealing the data they possess to each other. This capability of secure MPC has the potential to unlock a variety of machine-learning applications that are currently infeasible because of data privacy concerns. For example, secure MPC can allow medical research institutions to jointly train better diagnostic models without having to share their sensitive patient data [27] or allow social scientists to analyze gender wage gap statistics without companies having to share sensitive salary data [42]. The prospect of such applications of machine learning with rigorous privacy and security guarantees has spurred a number of studies on machine learning via secure MPC [38, 41, 48, 58, 63, 66, 67]. However, at present, adoption of secure MPC in machine learning is still relatively limited considering its wide-ranging potential. One of the main obstacles to widespread adoption is that the complexity of secure MPC techniques puts them out of reach for most machine-learning researchers, who frequently lack in-depth knowledge of cryptographic techniques. ",
+        "bbox": [
+            174,
+            685,
+            825,
+            852
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To foster the adoption of secure MPC techniques in machine learning, we present CRYPTEN: a flexible software framework that aims to make modern secure MPC techniques accessible to machinelearning researchers and developers without a background in cryptography. Specifically, CRYPTEN provides a comprehensive tensor-computation library in which all computations are performed via secure MPC. CRYPTEN’s API closely follows the API of the popular PyTorch framework for machine learning [54, 55], which makes it easy to use for machine-learning practitioners. For example, it provides automatic differentiation and a modular neural-network package. CRYPTEN assumes an semi-honest threat model [30, $\\ S 2 . 3 . 2 ]$ and works for an arbitrary number of parties. To make private training and inference efficient, CRYPTEN off-loads computations to the GPU and uses high-performance communication libraries to implement interactions between parties. ",
+        "bbox": [
+            176,
+            858,
+            825,
+            900
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            92,
+            825,
+            188
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The paper presents: (1) an overview of CRYPTEN’s design principles; (2) a description of the design of CRYPTEN and of the secure MPC protocols implemented; (3) a collection of benchmark experiments using CRYPTEN to run private versions of state-of-the-art models for text classification, speech recognition, and image classification; and (4) a discussion of open problems and a roadmap for the further development of CRYPTEN. Altogether, the paper demonstrates that CRYPTEN’s flexible, PyTorch-like API makes private inference and training of modern machine-learning models easy to implement and efficient. For example, CRYPTEN allows two parties to privately classify an image [26, 35] in 2-3 seconds, or to securely make phoneme predictions for 16kHz speech recordings [17] faster than real-time. We hope that CRYPTEN’s promising performance and ease-ofuse will foster the adoption of secure MPC by the machine-learning community, and pave the way for a new generation of secure and private machine-learning systems. ",
+        "bbox": [
+            174,
+            194,
+            825,
+            347
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            367,
+            321,
+            383
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "CRYPTEN is part of a large body of work that develops secure MPC protocols for machine learning; see Appendix ??. Most closely related to our work is CryptGPU [63], which implements an 2-out-of-3 replicated secret sharing protocol [4, 37] on top of CRYPTEN. Like CRYPTEN, CryptGPU provides security against semi-honest corruption, but it is limited to the three-party setting. CryptGPU is one of several protocols optimized for the three-party setting. For example, Falcon [67] implements a maliciously secure three-party MPC protocol, combining techniques from SecureNN [66] and ABY3 [48]. Falcon allows evaluation and training of convolutional networks such as AlexNet [40] and VGG [62]. Other systems that work in this setting include Astra [16], Blaze [56], and CrypTFlow [41]. ",
+        "bbox": [
+            174,
+            398,
+            825,
+            510
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "There also exists a family of two-party systems that, like CRYPTEN, assume a semi-honest threat model. These systems include Gazelle [38], Chameleon [58], EzPC [15], MiniONN [45], SecureML [49], PySyft [60], and Delphi [47]. XONN [59] also works in the two-party setting but provides malicious security. Compared to these systems, CRYPTEN provides a more flexible machinelearning focused $\\mathsf { A P I } ^ { 1 }$ that supports reverse-mode automatic differentiation, implements a rich set of functions, and natively runs on GPUs. Moreover, CRYPTEN supports a wider range of use cases by working with an arbitrary number of parties, and make communication between parties efficient via communication primitives that were optimized for high-performance distributed computing. ",
+        "bbox": [
+            174,
+            516,
+            825,
+            627
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 Design Principles ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            647,
+            349,
+            665
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In the development of CRYPTEN, we adopted the following two main design principles: ",
+        "bbox": [
+            174,
+            679,
+            748,
+            694
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Machine-learning first API. CRYPTEN has a general purpose, machine-learning first API design. Most other secure MPC frameworks [34] adopt an API that stays close to the underlying MPC protocols. This hampers adoption of these frameworks in machine learning, for example, because they do not natively support tensor operations (but only scalar operations) and because they lack features that machine-learning researchers have come to expect, such as automatic differentiation. Instead, CRYPTEN implements the tensor-computation API of the popular PyTorch machine-learning framework [54], implements reverse-mode automatic differentiation, provides a modular neuralnetwork package with corresponding learning routines, and supports GPU computations. We aim to allow developers to transition code from PyTorch to CRYPTEN by changing a single Python import. ",
+        "bbox": [
+            174,
+            699,
+            825,
+            824
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Eager execution. CRYPTEN adopts an imperative programming model. This is different from existing MPC frameworks, which generally implement compilers for their own domain-specific languages [34]. While compiler approaches have potential performance benefits, they slow down the development cycle, make debugging harder, and prevent users from using arbitrary host-language constructs [3]. Instead, CRYPTEN follows the recent trend in machine learning away from graph compilers [1] to frameworks that eagerly execute computations [3, 55], providing a better developer experience. Yet, CRYPTEN is performant because it implements state-of-the-art secure MPC protocols (for settings with arbitrary number of parties), because it uses PyTorch’s highly optimized tensor library for most computations, because computations can be off-loaded to the GPU, and because it uses communication libraries that were optimized for high-performance distributed computing. ",
+        "bbox": [
+            174,
+            830,
+            825,
+            873
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/811459a65803d2cf6672a49fc171d393271b4ddb88fc57f3a215684834958580.jpg",
+        "image_caption": [
+            "Figure 1: High-level overview of the design of CRYPTEN. See text in Section 4 for details. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            230,
+            87,
+            767,
+            244
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            292,
+            825,
+            390
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4 Design Overview ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            410,
+            346,
+            426
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Figure 1 gives an overview of CRYPTEN’s design. Parties perform computations using efficient PyTorch tensor operations. Because secure MPC computations are integer computations that are not natively supported on GPUs, CRYPTEN maps between integer and floatingpoint computations on GPUs; see Section 5.3. The multi-party computations are implemented on arithmetic and binary secret shares [22, 32]; see Section 5.1. Whereas many computations can be performed directly on arithmetic secret shares, others require conversion between arithmetic and binary secret shares (A2B) and back (B2A); see Section 5.2. Some multiparty computations require interaction between parties via a communicator that employs the high-performance communication primitives in Gloo [31] and NCCL [51]. Some multi-party computations require Beaver triples [7], which are supplied by a trusted third party (TTP).2 ",
+        "bbox": [
+            174,
+            439,
+            485,
+            717
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/133623b93e7fb43d5744e1894a0fac18a5c926f237f36c8cbe7096f166b2b680.jpg",
+        "image_caption": [
+            "Figure 2: Example of secret-sharing tensors, revealing tensors, and private addition in CRYPTEN. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            496,
+            448,
+            810,
+            662
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "All secure computations are wrapped in a CrypTensor object that implements the PyTorch tensor API and that provides reverse-mode automatic differentiation (autograd) to enable gradient-based training of arbitrary (deep) learning models. Figure 2 illustrates CrypTensor creation, i.e., how tensors are secret-shared and revealed, as well as a simple computation (addition). Note that each party involved in the multi-party computation executes the same code. Whenever communication between the parties is required (e.g., as part of private multiplications), the communication acts as a synchronization point between the parties. The crypten.init() call is required once to establish the communication channel. In the example, the input tensor for the creation of the arithmetic secret share is provided party $\\mathtt { s r c = 0 }$ , which indicates the rank3 of the party that supplies the data to be secret-shared (the other parties executing this code may provide None as input). ",
+        "bbox": [
+            174,
+            723,
+            825,
+            861
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To enable deep-learning use cases, CRYPTEN allows implementing neural networks following PyTorch’s API. Figure 3 shows how to create and encrypt neural networks and how to use automatic differentiation in CRYPTEN. The example assumes that some training sample and the associated target label are provided by the party with rank 0 (note the value of src). As illustrated by the example, CRYPTEN’s API closely follows that of PyTorch. Indeed, it is possible to write a single training loop that can be used to train models using CRYPTEN or PyTorch without code changes. This makes it easy to adapt PyTorch code to use secure MPC for its computations, and it also makes debugging easier. The appendix presents a table listing all tensor functions that CrypTensor implements. ",
+        "bbox": [
+            174,
+            92,
+            485,
+            327
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To enable interoperability with existing machinelearning platforms, neural networks can be imported into CRYPTEN via ONNX. Figure 4 shows how a PyTorch model is imported into CRYPTEN. The example illustrates how CRYPTEN makes private inference with a ResNet-18 easy. The example in the figure also demonstrates CRYPTEN’s GPU support. One caveat is that all parties must use the same type of device (i.e., CPU or GPU) for computations. ",
+        "bbox": [
+            174,
+            333,
+            483,
+            470
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "5 Secure Computations ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            492,
+            385,
+            510
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To facilitate secure computations, CRYPTEN implements arithmetic secret sharing [22, 23] and binary secret sharing [32], as well as conversions between these two types of sharing [24]. Arithmetic secret sharing is particularly wellsuited for operations that are common in modern machine-learning models, such as matrix multiplications and convolutions. Binary secret sharing is required for evaluating certain other common functions, such as rectified linear units. We provide a high-level overview of CRYPTEN’s secure computation protocol here; a detailed description is presented in the appendix. ",
+        "bbox": [
+            174,
+            525,
+            485,
+            704
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/be5501ad3d1a315129389a61c357996a1c1144ca326dbdeea6e2e024a08a5266.jpg",
+        "table_caption": [
+            "Figure 3: Example using neural networks and automatic differentiation in CRYPTEN. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>import</td><td>crypten.nn as nn</td><td>import crypten.optimizer as optimizer</td></tr><tr><td>#</td><td></td><td>create model，criterion，and optimizer:</td></tr><tr><td></td><td></td><td>model_enc = nn.Sequential(</td></tr><tr><td></td><td></td><td>nn.Linear(sample_dim，hidden_dim),</td></tr><tr><td></td><td>nn.ReLU()，</td><td></td></tr><tr><td></td><td></td><td>nn.Linear(hidden_dim，num_classes),</td></tr><tr><td>).encrypt()</td><td></td><td></td></tr><tr><td></td><td></td><td>criterion = nn.CrossEntropyLoss()</td></tr><tr><td></td><td>optimizer = optimizer.SGD(</td><td></td></tr><tr><td></td><td></td><td>model_enc.parameters()，lr=@.1，momentum=0.9,</td></tr><tr><td>）</td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td>perform prediction on sample:</td></tr><tr><td></td><td></td><td>target_enc = crypten.cryptensor(target，src=0)</td></tr><tr><td></td><td></td><td>sample_enc = crypten.cryptensor(sample，src=0)</td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td>output_enc = model_enc(sample_enc)</td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td>#</td><td></td><td>：perform backward pass and update parameters:</td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td>model_enc.zero_grad()</td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td>loss_enc = criterion(output_enc，target_enc)</td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td>loss_enc.backward()</td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td>optimizer.step()</td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr></table>",
+        "bbox": [
+            496,
+            98,
+            833,
+            369
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/ccc61810e5fc4638489507058d70992b7846aeb8aa555d87d1a38254d20420e4.jpg",
+        "image_caption": [
+            "Figure 4: Private inference on secret-shared images using a secret-shared ResNet-18 model on GPU. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            496,
+            433,
+            825,
+            674
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "5.1 Secret Sharing ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            723,
+            315,
+            738
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Arithmetic secret sharing shares a scalar value $x \\in \\mathbb { Z } / Q \\mathbb { Z }$ , where $\\mathbb { Z } / Q \\mathbb { Z }$ denotes a ring with $Q$ elements, across parties $p \\in \\mathcal P$ . We denote the sharing of $x$ by $[ x ] = \\{ [ x ] _ { p } \\} _ { p \\in \\mathcal { P } }$ , where $[ x ] _ { p } \\in \\mathbb { Z } / Q \\mathbb { Z }$ indicates party $p$ ’s share of $x$ . The shares are constructed such that their sum reconstructs the original value $x$ , that is, $\\begin{array} { r } { x = \\sum _ { p \\in \\mathcal { P } } [ x ] _ { p } } \\end{array}$ mod $Q$ . To share a value $x$ , the parties generate a pseudorandom zero-share [18] with $| \\mathcal { P } |$ random numbers that sum to 0. The party that possesses the value $x$ adds $x$ to their share and discards $x$ . We use a fixed-point encoding to obtain $x$ from a floating-point value, $x _ { R }$ . To do so, we multiply $x _ { R }$ with a large scaling factor $B$ and round to the nearest integer: $x = \\lfloor B x _ { R } \\rceil$ , where $B = 2 ^ { L }$ for some precision of $L$ bits. To decode a value, $x$ , we compute $x _ { R } \\approx x / _ { B }$ . ",
+        "bbox": [
+            173,
+            750,
+            826,
+            863
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Binary secret sharing is a special case of arithmetic secret sharing that operates within the binary field $\\mathbb { Z } / 2 \\mathbb { Z }$ . A binary secret share, $\\langle x \\rangle$ , of a value $x$ is formed by arithmetic secret shares of the bits of $x$ , setting $Q = 2$ . Each party $p \\in \\mathcal P$ holds a share, $\\langle x \\rangle _ { p }$ , such that $\\begin{array} { r } { x = \\bigoplus _ { p \\in \\mathcal { P } } \\langle x \\rangle _ { p } } \\end{array}$ is satisfied. ",
+        "bbox": [
+            174,
+            869,
+            825,
+            912
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Conversion from $[ x ]$ to $\\langle x \\rangle$ is implemented by having the parties create a binary secret share of their $[ x ] _ { p }$ shares, and summing the resulting binary shares. Specifically, the parties create a binary secret share, $\\langle [ x ] _ { p } \\rangle$ , of all the bits in $[ x ] _ { p }$ . Subsequently, the parties compute $\\begin{array} { r } { \\langle x \\rangle = \\sum _ { p \\in \\mathcal { P } } \\langle [ x ] _ { p } \\rangle } \\end{array}$ using a carry-lookahead adder in $\\log _ { 2 } ( | \\mathcal { P } | ) \\log _ { 2 } ( L )$ communication rounds [14, 21]. ",
+        "bbox": [
+            174,
+            90,
+            825,
+            150
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Conversion from $\\langle x \\rangle$ to $[ x ]$ is achieved by computing $\\begin{array} { r } { [ x ] = \\sum _ { b = 1 } ^ { B } 2 ^ { b } \\left[ \\langle x \\rangle ^ { ( b ) } \\right] } \\end{array}$ , where $\\langle x \\rangle ^ { ( b ) }$ denotes the $b$ -th bit of the binary share $\\langle x \\rangle$ and $B$ is the total number of bits in the shared secret, $\\langle x \\rangle$ . To create an arithmetic share of a bit, the parties use secret shares, $\\left( [ r ^ { ( b ) } ] , \\langle r ^ { ( b ) } \\rangle \\right)$ , of random bits $r ^ { ( b ) }$ . The random bits are provided by the TTP, but we plan to add an implementation that generates them off-line via oblivious transfer [39]. The parties use $\\langle r ^ { ( b ) } \\rangle$ to mask $\\langle x \\rangle ^ { ( b ) }$ and reveal the resulting masked bit $z ^ { ( b ) }$ . Subsequently, they compute $\\left[ \\langle x \\rangle ^ { ( b ) } \\right] = \\left[ \\dot { r } ^ { ( b ) } \\right] + z ^ { ( b ) } - 2 \\left[ r ^ { ( b ) } \\right] z ^ { ( b ) }$ . ",
+        "bbox": [
+            173,
+            156,
+            825,
+            250
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5.2 Secure Computation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            263,
+            356,
+            279
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Arithmetic and binary secret shares have homomorphic properties that can be used to implement secure computations. All computations in CRYPTEN are based on private addition and multiplication. ",
+        "bbox": [
+            174,
+            290,
+            825,
+            318
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Private addition of two arithmetically secret shared values, $[ z ] = [ x ] + [ y ]$ , is implemented by having each party $p$ sum their shares of $[ x ]$ and $[ y ]$ : each party $p \\in \\mathcal P$ computes $[ z ] _ { p } = [ x ] _ { p } + [ y ] _ { p }$ . ",
+        "bbox": [
+            173,
+            323,
+            823,
+            353
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Private multiplication is implemented using random Beaver triples [7], $( [ a ] , [ b ] , [ c ] )$ with $c { = } a b$ , that are provided by the TTP. The parties compute $[ \\epsilon ] = [ x ] - [ a ]$ and $[ \\delta ] = [ y ] - [ b ]$ , and decrypt $\\epsilon$ and $\\delta$ without information leakage due to the masking. They compute the result $[ x ] [ y ] = [ c ] + \\epsilon [ b ] + [ a ] \\delta + \\epsilon \\delta$ , using trivial implementations of addition and multiplication of secret shares with public values. ",
+        "bbox": [
+            174,
+            358,
+            825,
+            414
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Linear functions are trivially implemented as combinations of private addition and multiplication.   \nThis allows CRYPTEN to compute dot products, outer products, matrix products, and convolutions. ",
+        "bbox": [
+            174,
+            420,
+            823,
+            449
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Non-linear functions are implemented using standard approximations that only require private addition and multiplication. Specifically, CRYPTEN evaluates exponentials using a limit approximation, logarithms using Householder iterations [36], and reciprocals using Newton-Rhapson iterations. This allows CRYPTEN to implement functions that are commonly used in machine-learning models, including the sigmoid, softmax, and logistic-loss functions, as well as their gradients. ",
+        "bbox": [
+            173,
+            454,
+            826,
+            525
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Comparators are implemented using a function that evaluates $[ z < 0 ]$ by: (1) converting $[ z ]$ to a binary secret-share $\\langle z \\rangle$ ; (2) computing its sign bit, $\\langle b \\rangle = \\langle z \\rangle > > ( L - 1 )$ ; and (3) converting the resulting bit to an arithmetic sharing $[ b ]$ . This function allows CRYPTEN to implement arbitrary comparators. For example, it evaluates $[ { \\bar { x } } < y ]$ by computing $[ z ] = [ x ] - [ y ]$ and evaluating $[ z < 0 ]$ . Similarly, CRYPTEN can evaluate: (1) the sign function via $\\mathrm { s i g n } ( [ x ] ) = 2 [ x > 0 ] - 1$ ; (2) the absolute value function via $| [ x ] | = [ x ] \\operatorname { s i g n } ( [ x ] )$ ; and (3) rectified linear units via $\\mathrm { R e L \\bar { U } } ( [ x ] ) = [ x ] [ x > 0 ]$ . CRYPTEN also supports multiplexing; to do so, it evaluates $[ c ? x : y ] = [ c ] [ x ] + { \\bar { ( } } 1 - [ c ] { \\bar { ) } } [ y ]$ . ",
+        "bbox": [
+            173,
+            530,
+            826,
+            628
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Lemma 1. The CRYPTEN secure-computation protocol is secure against information leakage against any static passive adversary corrupting up to $| \\mathcal { P } | - 1$ of the $| \\mathcal { P } |$ parties involved in the computation. ",
+        "bbox": [
+            171,
+            631,
+            823,
+            660
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The proof of this lemma follows trivially from [9, 11, 21, 24], and is given in the appendix. We adopt a protocol that provides security under a semi-honest threat model because it enables a wide range of use cases of secure machine learning, whilst being more efficient than maliciously secure protocols. ",
+        "bbox": [
+            174,
+            669,
+            826,
+            712
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5.3 Off-loading Computations to the GPU ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            727,
+            477,
+            742
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Hardware acceleration via GPUs is a critical component for training and inference in modern machinelearning models. Akin to frameworks such as PyTorch [55] and TensorFlow [1], CRYPTEN can off-load computations to the GPU. On the GPU, it uses highly-optimized implementations for a range of functions that are provided by CUDA libraries such as cuBLAS [19] and cuDNN [20]. ",
+        "bbox": [
+            174,
+            752,
+            825,
+            808
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Unfortunately, these libraries are designed for computations on floating-point numbers and do not support the integer types required to perform computations on $L$ -bit fixed-point numbers. Akin to [63], we circumvent this problem by observing that for all integers $a , b \\in \\mathbb { Z } \\cap [ - 2 ^ { 2 6 } , 2 ^ { 2 6 } ]$ , we can compute the product $a b$ using 64-bit floating-point representations and still recover the correct value over the integers. Specifically, CRYPTEN splits each 64-bit variable into four components, $a = a _ { 0 } + 2 ^ { 1 6 } a _ { 1 } \\stackrel {  } { + } 2 ^ { 3 2 } a _ { 2 } ^ { \\cdot } + 2 ^ { 4 8 } a _ { 3 }$ , where each $a _ { i }$ represents a 16-bit integer component. We compute a product $a b$ of 64-bit integers by summing 10 pairwise products of their 16-bit components. ",
+        "bbox": [
+            174,
+            814,
+            825,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/efcd5190480a11854e31bc38c593f3c32d108f3abbcbb69c3ec1924167a8a4c2.jpg",
+        "image_caption": [
+            "Figure 5: Benchmarks for inference with text-sentiment classification model on GPUs in CRYPTEN and PyTorch. Left: Average wall-clock time per sample (in seconds). Middle: Number of bytes communicated per sample, per party (in GB). Right: Number of communication rounds per sample. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            90,
+            812,
+            199
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The pairwise products of the 16-bit components are computed in parallel using highly optimized floating-point CUDA kernels. The same approach is used for matrix multiplications and convolutions. CRYPTEN further optimizes this approach by splitting into only 3 components of 22-bits each when possible, which reduces the number of pairwise products required to 6 (see [63, Remark II.1]). ",
+        "bbox": [
+            174,
+            276,
+            825,
+            333
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "6 Benchmarks ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            352,
+            310,
+            368
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To measure the performance of CRYPTEN, we performed experiments on three tasks: (1) text classification using a linear model that learns word embeddings; (2) speech recognition using the Wav2Letter model [17]; and (3) image classification using residual networks [35] and vision transformers [26]. Because of space constraints, we focus on private inference using a secret-shared model on secret-shared data here, but our benchmark results with private training are very similar. ",
+        "bbox": [
+            174,
+            383,
+            825,
+            453
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We performed benchmark experiments on a proprietary cluster, testing inference on both CPUs (Intel Skylake 18-core 1.6GHz) and GPUs (nVidia P100). We set the number of OpenMP threads to 1 in all benchmarks. All experiments were performed with the parties running in separate processes on a single machine. For GPU experiments, each party was assigned its own GPU. Although this setup is faster than a scenario in which each party operates its own machine,4 we believe our benchmark results provide a good sense of CRYPTEN’s performance. We average computation times over 30 batches, excluding the computation on the first batch as that computation may include CuDNN benchmarking. Code reproducing the results of our experiments is available on https://crypten.ai. ",
+        "bbox": [
+            174,
+            459,
+            825,
+            570
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In our benchmarks, we focus on comparing (ciphertext) CRYPTEN computation with (plaintext) PyTorch computation. We refer the reader to [33, 63] for benchmarks that compare CRYPTEN to other secure MPC frameworks. Specifically, [33] finds CRYPTEN is $1 1 - 1 8 \\times$ faster than PySyft [60] and approximately $3 \\times$ faster than TF-Trusted [13] in MNIST classification [43] on CPU. ",
+        "bbox": [
+            174,
+            577,
+            825,
+            632
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "6.1 Text Classification ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            648,
+            339,
+            662
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We performed text-sentiment classification experiments on the Yelp review dataset [70] using a model that consists of a linear layer operating on word embeddings. The embedding layer contains 32- dimensional embeddings of 519, 820 words, and the linear layer produces a binary output indicating the sentiment of the review. We evaluated the model on GPUs, varying the batch size and the number of parties participating. The normalized mean squared error $( | | \\mathbf x - \\mathbf { \\dot { y } } | | ^ { 2 } / | | \\mathbf x | | ^ { 2 } )$ between the output of the CRYPTEN model and that of its PyTorch counterpart was smaller than $4 \\cdot 1 0 ^ { - 4 } $ in all experiments. ",
+        "bbox": [
+            174,
+            674,
+            825,
+            757
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Figure 5 presents the results of our experiments. The figure shows inference time per sample (in seconds) as a function of the number of parties involved in the computation for varying batch sizes (left); the amount of communication required per sample, per party (in GB); and the number of communication rounds required per sample. We include results in which the number of parties is 1: herein, we run the CRYPTEN protocol but involve no other parties, which implies that the single party is running the protocol on unencrypted data. One-party results allow us to bisect different sources of computational overhead: specifically, they separate overhead due to communication from overhead due to fixed-point encoding, function approximations, and (lack of) sparse-matrix operations. ",
+        "bbox": [
+            173,
+            763,
+            825,
+            875
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/b0658af9330fe3f0b0cd6dd97fe40648a1dc6375b17948b5be253afa14a028a5.jpg",
+        "image_caption": [
+            "Figure 6: Benchmarks for inference with Wav2Letter model on GPUs in CRYPTEN and PyTorch. Left: Average wall-clock time per sample (in seconds). Middle: Number of bytes communicated per sample, per party (in GB). Right: Number of communication rounds per sample. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            90,
+            813,
+            199
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/85dd11331cac96bf90ef7dac7b3fe6359546bbd37b78ebb5b01cbabc22b4d4e0.jpg",
+        "image_caption": [
+            "Figure 7: Wall-clock time per sample (in sec.) for Wav2Letter inference on CPUs and GPUs. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            267,
+            382,
+            372
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/419fd550afcb26e94285cc85b4c5517df824e8a0fad306a23d47f29810826738.jpg",
+        "image_caption": [
+            "Figure 8: Average wall-clock time per sample (in seconds) for communication and computation during inference with Wav2Letter model on CPU (left) and GPU (right). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            406,
+            268,
+            805,
+            371
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The results in Figure 5 show that CRYPTEN is about 2.5–3 orders of magnitude slower than PyTorch in text-sentiment classification, depending on the number of parties involved. Most computational overhead is the word embedding layer: whereas PyTorch can evaluate this layer efficiently via a sparse matrix multiplication, CRYPTEN cannot do sparse lookups as they would reveal information on the encrypted input. Instead, CRYPTEN performs a full matrix multiplication between the wordcount vector and the embedding matrix. Yet, text sentiment predictions are quite fast in CRYPTEN: inference takes only 0.03 seconds per sample in the two-party setting with a batch size of 32. ",
+        "bbox": [
+            174,
+            452,
+            825,
+            549
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The results also show that increasing the batch size is an effective way to reduce inference time and communication per sample. The number of communication rounds is independent of the batch size, which means communication rounds can be amortized by using larger batch sizes. The number of bytes communicated is partly amortized as well because the size of weight tensors (e.g., in linear layers) does not depend on batch size. The results also show that whereas the number of communication rounds increases when moving from two-party to three-party computation, it remains constant afterwards. The larger number of communication rounds for three-party computation stems from the public division protocol, which requires additional communication rounds when more than two parties are involved to prevent wrap-around errors (see the appendix for details). ",
+        "bbox": [
+            174,
+            556,
+            825,
+            680
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "6.2 Speech Recognition ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            699,
+            349,
+            713
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We performed speech-recognition experiments using Wav2Letter [17] on the LibriSpeech dataset [53]. The LibriSpeech dataset contains $1 6 \\mathrm { k H z }$ audio clips represented as a waveform (16, 000 samples per second). Because the audio clips vary in length, we clip all of them to 1 second for the benchmark. Wav2Letter is a network with 13 convolutional layers using rectified linear unit (ReLU; [50]) activations.5 The network operates directly on the waveform input, predicting one of 29 labels (26 letters plus 3 special characters). The first two layers use a filter size of 250 (with stride 160) and 48 (stride 2). The next seven layers use filter size 7, followed by two layers with filter size 32 and 1 (all with stride 1). All layers except the last two have 250 channels. The last two layers have 2, 000 channels. ",
+        "bbox": [
+            173,
+            724,
+            826,
+            835
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The results in Figure 6 show that CRYPTEN is about 2.5–3 orders of magnitude slower than PyTorch depending on the number of parties involved. For Wav2Letter, the overhead is largely due to the ReLU layers in the network: evaluating a ReLU function requires a comparison, which involves a conversion between arithmetic and binary secret sharing and back (see the appendix). The number of communication rounds increases when the number of parties grows beyond 4: CRYPTEN uses a tree reduction for the summation in the comparator protocol, which implies that the number of communication rounds grows whenever the number of parties increases from 2k to 2k+1. ",
+        "bbox": [
+            178,
+            842,
+            823,
+            883
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/575335d99447214996c3aa9f3fc17c794e696a3513c6149dee7f62038b7cf7da.jpg",
+        "image_caption": [
+            "Figure 9: Benchmarks for inference with image-classification models on GPUs in CRYPTEN and PyTorch. Top: Results for ResNet-18 model. Bottom: Results for ViT-B/16 vision transformer. Left: Average wall-clock time per sample (in seconds). Middle: Number of bytes communicated per sample, per party (in GB). Right: Number of communication rounds per sample. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            90,
+            812,
+            304
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            398,
+            825,
+            454
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Figure 7 also presents results comparing Wav2Letter inference time between CPUs and GPUs. The results in the figure show that CRYPTEN is 1-2 orders of magnitude faster on GPUs than on CPUs. In real-world settings, this speedup can make the difference between a secure MPC use case being practical or not. Figure 8 shows how much wall-clock time is spent on communication and computation, respectively, when performing inference with Wav2Letter (using batch size 32). The results suggest that, whereas multi-party evaluation is compute-bound on CPU, it is communicationbound on GPU. On GPUs, $6 3 \\%$ of the time is spent on communication in eight-party computation. ",
+        "bbox": [
+            174,
+            460,
+            825,
+            558
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6.3 Image Classification ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            575,
+            352,
+            590
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We performed image-classification experiments on the ImageNet dataset using residual networks (ResNets; [35]) and vision transformers (ViT; [26]).6 We experimented with a ResNet-18 with 18 convolutional layers and with a ViT-B/16 model that has 12 multi-head self-attention layers with 12 heads each, operating on image patches of $1 6 \\times 1 6$ pixels. Following common practice [35], we preprocess images by rescaling them to size $2 5 6 \\times 2 5 6$ and taking a center crop of size $2 2 4 \\times 2 2 4$ . ",
+        "bbox": [
+            173,
+            603,
+            825,
+            671
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Figure 9 presents the results of our image-classification benchmarks, which show that two parties can securely evaluate a ResNet-18 model in 2.49 seconds and a ViT-B/16 model in 8.47 seconds. A notable difference compared to the prior results is that the number of bytes communicated per sample is no longer reduced by increasing the batch size. The reason for this is that the vast majority of communication involves tensors that have the same size as intermediate activation functions: activation tensors are much larger than weight tensors in image-classification models. The amount of communication required to evaluate the ViT-B/16 model is particularly high due to the repeated evaluation of the softmax function in the attention layer of Transformers [65]. We also observe that in ResNet-18, the number of communication rounds grows faster than expected for larger batch sizes. The reason for this is that the carry-lookahead adder [21] used in the conversion from $[ x ]$ to $\\langle x \\rangle$ is very memory-intensive. When CRYPTEN runs out of GPU memory, it replaces the adder by an implementation that requires $O ( | \\mathcal { P } | )$ communication rounds (compared to $( \\log _ { 2 } | \\mathcal { P } | )$ for the carry-lookahead adder) but that requires less memory. ",
+        "bbox": [
+            174,
+            679,
+            825,
+            858
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "7 Conclusion and Future Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            449,
+            106
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we have introduced and benchmarked CRYPTEN. We hope that CRYPTEN’s flexible, machine-learning first API design and performance can help foster adoption of secure MPC in machine learning. We see the following directions for future research and development of CRYPTEN. ",
+        "bbox": [
+            174,
+            122,
+            825,
+            165
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Numerical issues are substantially more common in CRYPTEN implementations of machine-learning algorithms than in their PyTorch counterparts. In particular, the fixed-point representation with $L$ bits of precision $L { = } 1 6$ by default) is more prone to numerical overflow or underflow than floating-point representations. Moreover, arithmetic secret shares are prone to wrap-around errors in which the sum of the shares $[ x ] _ { p }$ exceeds the size of the ring, $Q = 2 ^ { 6 4 }$ . Wrap-around errors can be difficult to debug because they may only arise in the multi-party setting, in which no individual party can detect them. We plan to implement tools in CRYPTEN that assist users in debugging such numerical issues. ",
+        "bbox": [
+            174,
+            170,
+            825,
+            268
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "End-to-end privacy requires seamless integration between data-processing frameworks, such as secure SQL implementations [5], and data-modeling frameworks like CRYPTEN. In “plaintext” software, such frameworks are developed independently and combined via “glue code” or platforms that facilitate the construction of processing and modeling pipelines. Real-world use cases of machine learning via secure MPC require the development of a platform that makes the integration of private data processing and modeling seamless, both from an implementation and a security point-of-view. ",
+        "bbox": [
+            174,
+            275,
+            825,
+            358
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Differential privacy mechanisms may be required in real-world applications of CRYPTEN in order to provide rigorous guarantees on the information leakage that inevitably occurs when the results of a private computation are publicly revealed [28]. CRYPTEN implements sampling algorithms for the Bernoulli, Laplace, and Gaussian distributions (see appendix), which allows for the implementation of randomized response [68], the Laplace mechanism [29], and the Gaussian mechanism [6, 28] (although care must be taken when implementing these mechanisms [12, 46]). In future work, we aim to use these mechanisms, for example, to do a secure MPC implementation of DP-SGD [2]. ",
+        "bbox": [
+            174,
+            364,
+            825,
+            460
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Threat models may vary per use case. Specifically, some use cases may require malicious security or may not provide a TTP. Possible extensions may include support for malicious security via message authentication codes [22], as well as support for Beaver triple generation via additive homomorphic encryption [52], oblivious transfer [39], or more recent methods [10] to eliminate the need for a TTP. ",
+        "bbox": [
+            174,
+            467,
+            825,
+            523
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Model architecture design for secure MPC is another important direction for future research. Following prior work in this research area, this study has focused on implementing existing machinelearning models in a secure MPC framework. However, these models were designed based on computational considerations in “plaintext” implementations of the models on modern GPU or TPU hardware. The results of our benchmarks suggest that this may be suboptimal because those considerations are very different in a secure MPC environment. For example, the evaluation of softmax functions over large numbers of values requires a lot of communication in secure MPC, which makes attention layers very slow. This implies that multilayer perceptron models [64] are likely much more efficient than vision transformers [26, 65] for image classification. We hope that CRYPTEN’s machine-learning API and ease of use will spur studies that design model architectures specifically optimized for a secure MPC environment, for example, via neural architecture search [44, 47, 71]. ",
+        "bbox": [
+            174,
+            529,
+            825,
+            681
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "8 Broader Impact ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            704,
+            338,
+            722
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Although we believe that the adoption of secure MPC in machine learning can lead to the development of AI systems that are substantially more private and secure, we note that there are also potential downsides to such adoption. In particular, because the computations in secure MPC are performed on encrypted data, it can be harder to do quality control of AI systems implemented in CRYPTEN. For example, it is impossible to inspect the values of intermediate activations (or even model outputs) unless all parties agree to reveal those values. This may make it harder to explain why a model makes a certain decision [25] or to detect data-poisoning attacks [8]. Indeed, there exist fundamental trade-offs between privacy and utility [57] and those trade-offs apply to CRYPTEN users, too. ",
+        "bbox": [
+            174,
+            738,
+            825,
+            849
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "It is also worth noting that, although the protocols implemented in CRYPTEN come with rigorous cryptographic guarantees, practical implementations of these protocols may be broken by other means. For example, we have no reason to assume that CRYPTEN would not be susceptible to side-channel attacks [61]. Hence, good data stewardship remains essential even when using secure computation. ",
+        "bbox": [
+            176,
+            856,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments. We thank Joe Spisak, Sijun Tan, Gregory Chanan, Igor Fedan, and the PyTorch team for their support. We thank Mark Tygert, Anderson Nascimento, Amrita Roy Chowdhury, and anonymous reviewers for helpful discussions and feedback on early versions of this paper. ",
+        "bbox": [
+            174,
+            92,
+            823,
+            133
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References   \n[1] M. Abadi, A. Agarwal, P. Barham, E. Brevdo, Z. Chen, C. Citro, G. S. Corrado, A. Davis, J. Dean, M. Devin, S. Ghemawat, I. Goodfellow, A. Harp, G. Irving, M. Isard, Y. Jia, R. Jozefowicz, L. Kaiser, M. Kudlur, J. Levenberg, D. Mané, R. Monga, S. Moore, D. Murray, C. Olah, M. Schuster, J. Shlens, B. Steiner, I. Sutskever, K. Talwar, P. Tucker, V. Vanhoucke, V. Vasudevan, F. Viégas, O. Vinyals, P. Warden, M. Wattenberg, M. Wicke, Y. Yu, and X. Zheng. TensorFlow: Large-scale machine learning on heterogeneous systems, 2015.   \n[2] M. Abadi, A. Chu, I. Goodfellow, H. McMahan, I. Mironov, K. Talwar, and L. Zhang. Deep learning with differential privacy. In Proceedings of the CCS, pages 308–318, 2016.   \n[3] A. Agrawal, A. N. Modi, A. Passos, A. Lavoie, A. Agarwal, A. Shankar, I. Ganichev, J. Levenberg, M. Hong, R. Monga, and S. Cai. TensorFlow Eager: A multi-stage, python-embedded dsl for machine learning. In arXiv:1903.01855, 2019.   \n[4] T. Araki, J. Furukawa, Y. Lindell, A. Nof, and K. Ohara. High throughput semi-honest secure three-party computation with an honest majority. In ACM CCS, pages 805–817, 2016.   \n[5] D. W. Archer, D. Bogdanov, L. Kamm, Y. Lindell, K. Nielsen, J. I. Pagter, N. P. Smart, and R. N. Wright. From keys to databases – real-world applications of secure multi-party computation. Computer Journal, 61(12):1749–1771, 2018.   \n[6] B. Balle and Y.-X. Wang. Improving the Gaussian mechanism for differential privacy. In Proceedings of International Conference on Machine Learning, 2018.   \n[7] D. Beaver. Efficient multiparty protocols using circuit randomization. In Annual International Cryptology Conference, pages 420–432. Springer, 1991.   \n[8] B. Biggio, B. Nelson, and P. Laskov. Poisoning attacks against support vector machines. In International Conference on Machine Learning (ICML), pages 1467–1474, 2012.   \n[9] D. Bogdanov, S. Laur, and J. Willemson. Sharemind: A framework for fast privacy-preserving computations. In S. Jajodia and J. Lopez, editors, Computer Security - ESORICS 2008, pages 192–206. Springer Berlin Heidelberg, 2008.   \n[10] E. Boyle, G. Couteau, N. Gilboa, Y. Ishai, L. Kohl, and P. Scholl. Correlated pseudorandom functions from variable-density LPN. In Cryptology ePrint Archive: Report 2020/1417, 2020.   \n[11] R. Canetti. Universally composable security: A new paradigm for cryptographic protocols. In Proceedings of the Annual Symposium on Foundations of Computer Science, pages 136–145, 2001.   \n[12] C. Canonne, G. Kamath, and T. Steinke. The discrete Gaussian for differential privacy. In arXiv 2004.00010, 2020.   \n[13] Cape Privacy. TF-Trusted. URL https://github.com/capeprivacy/tf-trusted.   \n[14] O. Catrina and S. De Hoogh. Improved primitives for secure multiparty integer computation. In International Conference on Security and Cryptography for Networks, pages 182–199. Springer, 2010.   \n[15] N. Chandran, D. Gupta, A. Rastogi, R. Sharma, and S. Tripathi. EzPC: Programmable, efficient, and scalable secure two-party computation for machine learning. In IEEE European Symposium on Security and Privacy, 2019.   \n[16] H. Chaudhari, A. Choudhury, A. Patra, and A. Suresh. Astra: High throughput 3pc over rings with application to secure prediction. In ACM SIGSAC Conference on Cloud Computing Security Workshop, 2019.   \n[17] R. Collobert, C. Puhrsch, and G. Synnaeve. Wav2letter: An end-to-end convnet-based speech recognition system. In arXiv:1609.03193, 2016.   \n[18] R. Cramer, I. Damgård, and Y. Ishai. Share conversion, pseudorandom secret-sharing and applications to secure computation. In Lecture Notes in Computer Science, volume 3378, pages 342–362, 2005.   \n[19] cuBLAS. https://developer.nvidia.com/cublas.   \n[20] cuDNN. https://developer.nvidia.com/cudnn.   \n[21] I. Damgård, M. Fitzi, E. Kiltz, J. B. Nielsen, and T. Toft. Unconditionally secure constant-rounds multi-party computation for equality, comparison, bits and exponentiation. In TCC, 2005.   \n[22] I. Damgård, V. Pastro, N. Smart, and S. Zakarias. Multiparty computation from somewhat homomorphic encryption. Cryptology ePrint Archive, Report 2011/535, 2011. https:// eprint.iacr.org/2011/535.   \n[23] I. Damgård, D. Escudero, T. Frederiksen, M. Keller, P. Scholl, and N. Volgushev. New primitives for actively-secure mpc over rings with applications to private machine learning. In Proceedings of the IEEE Symposium on Security and Privacy, 2019.   \n[24] D. Demmler, T. Schneider, and M. Zohner. ABY – A framework for efficient mixed-protocol secure two-party computation. In NDSS, 2015.   \n[25] F. Doshi-Velez and B. Kim. Towards a rigorous science of interpretable machine learning. In arXiv:1702.08608, 2017.   \n[26] A. Dosovitskiy, L. Beyer, A. Kolesnikov, D. Weissenborn, X. Zhai, T. Unterthiner, M. Dehghani, M. Minderer, G. Heigold, S. Gelly, J. Uszkoreit, and N. Houlsby. An image is worth 16x16 words: Transformers for image recognition at scale. In ICLR, 2021.   \n[27] T. Dugan and X. Zou. A survey of secure multiparty computation protocols for privacy preserving genetic tests. In Proceedings of the International Symposium on Biomedical Imaging, 2016.   \n[28] C. Dwork and A. Roth. The algorithmic foundations of differential privacy. Foundations and Trends in Theoretical Computer Science, 9(3–4):211–407, 2014.   \n[29] C. Dwork, F. McSherry, K. Nissim, and A. Smith. Calibrating noise to sensitivity in private data analysis. In Theory of cryptography conference, pages 265–284. Springer, 2006.   \n[30] D. Evans, V. Kolesnikov, and M. Rosulek. A Pragmatic Introduction to Secure Multi-Party Computation. NOW Publishers, 2018.   \n[31] Gloo. https://github.com/facebookincubator/gloo.   \n[32] O. Goldreich, S. Micali, and A. Wigderson. How to play any mental game or a completeness theorem for protocols with honest majority. In STOC, pages 218–229, 1987.   \n[33] V. Haralampieva, D. Rueckert, and J. Passerat-Palmbach. A systematic comparison of encrypted machine learning solutions for image classification. In Proceedings of the Workshop on PrivacyPreserving Machine Learning in Practice, pages 55–59, 2020.   \n[34] M. Hastings, B. Hemenway, D. Noble, and S. Zdancewic. SoK: general-purpose compilers for secure multi-party computation. In 2019 IEEE Symposium on Security and Privacy $( S P )$ , 2019.   \n[35] K. He, X. Zhang, S. Ren, and J. Sun. Deep residual learning for image recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2016.   \n[36] A. S. Householder. The Numerical Treatment of a Single Nonlinear Equation. 1970.   \n[37] M. Ito, A. Saito, and T. Nishizeki. Secret sharing scheme realizing general access structure. Electronics and Communications in Japan (Part III: Fundamental Electronic Science), 72: 56–64, 1989.   \n[38] C. Juvekar, V. Vaikuntanathan, and A. Chandrakasan. Gazelle: A low latency framework for secure neural network inference. In arXiv 1801.05507, 2018.   \n[39] M. Keller, E. Orsini, and P. Scholl. MASCOT: Faster malicious arithmetic secure computation with oblivious transfer. In Proceedings of the ACM SIGSAC Conference on Computer and Communications Security, pages 830–842, 2016.   \n[40] A. Krizhevsky, I. Sutskever, and G. E. Hinton. Imagenet classification with deep convolutional neural networks. Communications of the ACM, 60(6):84–90, 2017.   \n[41] N. Kumar, M. Rathee, N. Chandran, D. Gupta, A. Rastogi, and R. Sharma. CrypTFlow: Secure TensorFlow inference. In IEEE Symposium on Security and Privacy, pages 336–353, 2020.   \n[42] A. Lapets, N. Volgushev, A. Bestavros, F. Jansen, and M. Varia. Secure multi-party computation for analytics deployed as a lightweight web application. Technical Report BU-CS-TR 2016-008, Boston University, 2016.   \n[43] Y. LeCun, L. Bottou, Y. Bengio, and P. Haffner. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.   \n[44] H. Liu, K. Simonyan, and Y. Yang. DARTS: Differentiable architecture search. In arXiv:1806.09055, 2018.   \n[45] J. Liu, M. J. Y. Lu, and N. Asokan. Oblivious neural network predictions via MiniONN transformations. In ACM Conference on Computer and Communications Security (CCS), 2017.   \n[46] I. Mironov. On significance of the least significant bits for differential privacy. In Proceedings ACM Conference on Computer and Communications Security (CCS), pages 650–661, 2012.   \n[47] P. Mishra, R. Lehmkuhl, A. Srinivasan, W. Zheng, and R. Popa. Delphi: A cryptographic inference service for neural networks. In USENIX Security Symposium, 2020.   \n[48] P. Mohassel and P. Rindal. ABY3: A mixed protocol framework for machine learning. In ACM Conference on Computer and Communications Security (CCS), 2018.   \n[49] P. Mohassel and Y. Zhang. SecureML: A system for scalable privacy-preserving machine learning. In IEEE Symposium on Security and Privacy, 2017.   \n[50] V. Nair and G. E. Hinton. Rectified linear units improve restricted boltzmann machines. In Proceedings of the International Conference on Machine Learning (ICML), 2010.   \n[51] NCCL. https://developer.nvidia.com/nccl.   \n[52] P. Paillier. Public-key cryptosystems based on composite degree residuosity classes. In EUROCRYPT, pages 223–238, 1999.   \n[53] V. Panayotov, G. Chen, D. Povey, and S. Khudanpur. LibriSpeech: An ASR corpus based on public domain audio books. In Proceedings of the International Conference on Acoustics, Speech, and Signal Processing (ICASSP), 2015.   \n[54] A. Paszke, S. Gross, S. Chintala, and G. Chanan. PyTorch: Tensors and dynamic neural networks in Python with strong GPU acceleration, 2017.   \n[55] A. Paszke, S. Gross, F. Massa, A. Lerer, J. Bradbury, G. Chanan, T. Killeen, Z. Lin, N. Gimelshein, L. Antiga, A. Desmaison, A. Köpf, E. Yang, Z. DeVito, M. Raison, A. Tejani, S. Chilamkurthy, B. Steiner, L. Fang, J. Bai, and S. Chintala. PyTorch: An imperative style, high-performance deep learning library. In Advances in Neural Information Processing Systems (NeurIPS), 2019.   \n[56] A. Patra and A. Suresh. Blaze: Blazing fast privacy preserving machine learning. In Symposium on Network and Distributed System Security (NDSS), 2020.   \n[57] I. S. Reed. Information theory and privacy in data banks. In Proceedings of the June 4-8, 1973, National Computer Conference and Exposition, 1973.   \n[58] M. S. Riazi, C. Weinert, O. Tkachenko, E. M. Songhori, T. Schneider, and F. Koushanfar. Chameleon: A hybrid secure computation framework for machine learning applications. In Cryptology ePrint Archive, volume 2017/1164, 2017.   \n[59] M. S. Riazi, M. Samragh, H. Chen, K. Laine, K. Lauter, and F. Koushanfar. Xonn: Xnor-based oblivious deep neural network inference. In USENIX Security, 2019.   \n[60] T. Ryffel, A. Trask, M. Dahl, B. Wagner, J. Mancuso, D. Rueckert, and J. Passerat-Palmbach. A generic framework for privacy preserving deep learning. In arXiv:1811.04017, 2018.   \n[61] O. Seker, S. Berndt, L. Wilke, and T. Eisenbarth. SNI-in-the-head: Protecting MPC-in-the-head protocols against side-channel analysis. In Cryptology ePrint Archive: Report 2020/544, 2020.   \n[62] K. Simonyan and A. Zisserman. Very deep convolutional networks for large-scale image recognition. In ICLR, 2015.   \n[63] S. Tan, B. Knott, Y. Tian, and D. J. Wu. CryptGPU: Fast privacy-preserving machine learning on the GPU. In arXiv 2104.10949, 2021.   \n[64] I. Tolstikhin, N. Houlsby, A. Kolesnikov, L. Beyer, X. Zhai, T. Unterthiner, J. Yung, A. Steiner, D. Keysers, J. Uszkoreit, M. Lucic, and A. Dosovitskiy. MLP-Mixer: An all-MLP architecture for vision. In arXiv:2105.01601, 2021.   \n[65] A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, L. Kaiser, and I. Polosukhin. Attention is all you need. In Advances in Neural Information Processing Systems (NeurIPS), 2017.   \n[66] S. Wagh, D. Gupta, and N. Chandran. SecureNN: Efficient and private neural network training. In Cryptology ePrint Archive, volume 2018/442, 2018.   \n[67] S. Wagh, S. Tople, F. Benhamouda, E. Kushilevitz, P. Mittal, and T. Rabin. FALCON: Honestmajority maliciously secure framework for private deep learning. In Proc. Priv. Enhancing Technol., 2021.   \n[68] S. L. Warner. Randomized response: A survey technique for eliminating evasive answer bias. Journal of the American Statistical Association, 60(309):63–69, 1965.   \n[69] A. C.-C. Yao. How to generate and exchange secrets. In FOCS, pages 162–167, 1986.   \n[70] Yelp. Yelp Review Dataset. URL https://www.yelp.com/dataset.   \n[71] B. Zoph and Q. V. Le. Neural architecture search with reinforcement learning. In arXiv:1611.01578, 2016. ",
+        "bbox": [
+            173,
+            117,
+            826,
+            916
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            58,
+            828,
+            919
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            47,
+            828,
+            917
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            90,
+            828,
+            643
+        ],
+        "page_idx": 12
+    }
+]

parse/train/l-PrrQrK0QR/l-PrrQrK0QR.md

@@ -0,0 +1,529 @@
+# DATASET META-LEARNING FROM KERNEL RIDGEREGRESSION
+
+Timothy Nguyen Zhourong Chen Jaehoon Lee
+
+Google Research {timothycnguyen, zrchen, jaehlee}@google.com
+
+# ABSTRACT
+
+One of the most fundamental aspects of any machine learning algorithm is the training data used by the algorithm. We introduce the novel concept of $\epsilon$ - approximation of datasets, obtaining datasets which are much smaller than or are significant corruptions of the original training data while maintaining similar model performance. We introduce a meta-learning algorithm called Kernel Inducing Points (KIP ) for obtaining such remarkable datasets, inspired by the recent developments in the correspondence between infinitely-wide neural networks and kernel ridge-regression (KRR). For KRR tasks, we demonstrate that KIP can compress datasets by one or two orders of magnitude, significantly improving previous dataset distillation and subset selection methods while obtaining state of the art results for MNIST and CIFAR-10 classification. Furthermore, our KIP -learned datasets are transferable to the training of finite-width neural networks even beyond the lazy-training regime, which leads to state of the art results for neural network dataset distillation with potential applications to privacy-preservation.
+
+# 1 INTRODUCTION
+
+Datasets are a pivotal component in any machine learning task. Typically, a machine learning problem regards a dataset as given and uses it to train a model according to some specific objective. In this work, we depart from the traditional paradigm by instead optimizing a dataset with respect to a learning objective, from which the resulting dataset can be used in a range of downstream learning tasks.
+
+Our work is directly motivated by several challenges in existing learning methods. Kernel methods or instance-based learning (Vinyals et al., 2016; Snell et al., 2017; Kaya & Bilge, 2019) in general require a support dataset to be deployed at inference time. Achieving good prediction accuracy typically requires having a large support set, which inevitably increases both memory footprint and latency at inference time—the scalability issue. It can also raise privacy concerns when deploying a support set of original examples, e.g., distributing raw images to user devices. Additional challenges to scalability include, for instance, the desire for rapid hyper-parameter search (Shleifer & Prokop, 2019) and minimizing the resources consumed when replaying data for continual learning (Borsos et al., 2020). A valuable contribution to all these problems would be to find surrogate datasets that can mitigate the challenges which occur for naturally occurring datasets without a significant sacrifice in performance.
+
+This suggests the following
+
+Question: What is the space of datasets, possibly with constraints in regards to size or signal preserved, whose trained models are all (approximately) equivalent to some specific model?
+
+In attempting to answer this question, in the setting of supervised learning on image data, we discover a rich variety of datasets, diverse in size and human interpretability while also robust to model architectures, which yield high performance or state of the art (SOTA) results when used as training data. We obtain such datasets through the introduction of a novel meta-learning algorithm called Kernel Inducing Points (KIP ). Figure 1 shows some example images from our learned datasets.
+
+![](images/ad5c7ce154402c7e4833bb707dc6a060cf2a4947d17f809d1ed36a871659c384.jpg)  
+Figure 1: (a) Learned samples of CIFAR-10 using KIP and its variant $\mathrm { K I P } _ { \rho }$ , for which $\rho$ fraction of the pixels are uniform noise. Using 1000 such images to train a 1 hidden layer fully connected network results in $4 9 . 2 \%$ and $4 5 . 0 \%$ CIFAR-10 test accuracy, respectively, whereas using 1000 original CIFAR-10 images results in $3 5 . 4 \%$ test accuracy. (b) Example of labels obtained by label solving (LS ) (left two) and the covariance matrix between original labels and learned labels (right). Here, 500 labels were distilled from the CIFAR-10 train dataset using the the Myrtle 10-layer convolutional network. A test accuracy of $6 9 . 7 \%$ is achieved using these labels for kernel ridge-regression.
+
+We explore KIP in the context of compressing and corrupting datasets, validating its effectiveness in the setting of kernel-ridge regression (KRR) and neural network training on benchmark datasets MNIST and CIFAR-10. Our contributions can be summarized as follows:
+
+# 1.1 SUMMARY OF CONTRIBUTIONS
+
+• We formulate a novel concept of $\epsilon$ -approximation of a dataset. This provides a theoretical framework for understanding dataset distillation and compression.
+
+• We introduce Kernel Inducing Points (KIP ), a meta-learning algorithm for obtaining - approximation of datasets. We establish convergence in the case of a linear kernel in Theorem 1. We also introduce a variant called Label Solve (LS ), which gives a closed-form solution for obtaining distilled datasets differing only via labels.
+
+• We explore the following aspects of $\epsilon$ -approximation of datasets:
+
+1. Compression (Distillation) for Kernel Ridge-Regression: For kernel ridge regression, we improve sample efficiency by over one or two orders of magnitude, e.g. using 10 images to outperform hundreds or thousands of images (Tables 1, 2 vs Tables A1, A2). We obtain state of the art results for MNIST and CIFAR-10 classification while using few enough images (10K) to allow for in-memory inference (Tables A3, A4).
+
+2. Compression (Distillation) for Neural Networks: We obtain state of the art dataset distillation results for the training of neural networks, often times even with only a single hidden layer fully-connected network (Tables 1 and 2).
+
+3. Privacy: We obtain datasets with a strong trade-off between corruption and test accuracy, which suggests applications to privacy-preserving dataset creation. In particular, we produce images with up to $90 \%$ of their pixels corrupted with limited degradation in performance as measured by test accuracy in the appropriate regimes (Figures 3, A3, and Tables A5-A10) and which simultaneously outperform natural images, in a wide variety of settings.
+
+• We provide an open source implementation of KIP and LS , available in an interactive Colab notebook1.
+
+# 2 SETUP
+
+In this section we define some key concepts for our methods.
+
+Definition 1. A dataset in $\mathbb { R } ^ { d }$ is a set of $n$ distinct vectors in $\mathbb { R } ^ { d }$ for some $n \geq 1$ . We refer to each such vector as a datapoint. A dataset is labeled if each datapoint is paired with a label vector in $\mathbb { R } ^ { C }$ , for some fixed $C$ . A datapoint along with its corresponding label is a labeled datapoint. We use the notation $D = ( X , y )$ , where $X \in \mathbb { R } ^ { n \times d }$ and $y \in \mathbb { R } ^ { \hat { n } \times C }$ , to denote the tuple of unlabeled datapoints $X$ with their corresponding labels $y$ .
+
+We henceforth assume all datasets are labeled. Next, we introduce our notions of approximation, both of functions (representing learned algorithms) and of datasets, which are characterized in terms of performance with respect to a loss function rather than closeness with respect to a metric. A loss function $\ell : \mathbb { R } ^ { C } \times \mathbb { R } ^ { C } \overset { \cdot } {  } \mathbb { R }$ is one that is nonnegative and satisfies $\ell ( z , z ) = 0$ for all $z$ .
+
+Definition 2. Fix a loss function $\ell$ and let $f , \tilde { f } : \mathbb { R } ^ { d }  \mathbb { R } ^ { C }$ be two functions. Let $\epsilon \geq 0$
+
+1. Given a distribution $\mathcal { P }$ on $\mathbb { R } ^ { d } \times \mathbb { R } ^ { C }$ , we say $f$ and $\tilde { f }$ are weakly $\epsilon$ -close with respect to $( \ell , \mathcal { P } )$ if
+
+$$
+\begin{array} { r } { \left| \mathbb { E } _ { ( x , y ) \sim \mathcal { P } } \Big ( \ell ( f ( x ) , y ) \Big ) - \mathbb { E } _ { ( x , y ) \sim \mathcal { P } } \Big ( \ell ( \tilde { f } ( x ) , y ) \Big ) \right| \leq \epsilon . } \end{array}
+$$
+
+2. Given a distribution $\mathcal { P }$ on $\mathbb { R } ^ { d }$ we say $f$ and $\tilde { f }$ are strongly $\epsilon$ -close with respect to $( \ell , \mathcal { P } )$ if
+
+$$
+\begin{array} { r } { \mathbb { E } _ { x \sim \mathcal { P } } \Big ( \ell ( f ( x ) , \tilde { f } ( x ) ) \Big ) \le \epsilon . } \end{array}
+$$
+
+We drop explicit reference to $( \ell , \mathcal { P } )$ if their values are understood or immaterial.
+
+Given a learning algorithm $A$ (e.g. gradient descent with respect to the loss function of a neural network), let $A _ { D }$ denote the resulting model obtained after training $A$ on $D$ . We regard $A _ { D }$ as a mapping from datapoints to prediction labels.
+
+Definition 3. Fix learning algorithms $A$ and $\tilde { A }$ . Let $D$ and $\tilde { D }$ be two labeled datasets in $\mathbb { R } ^ { d }$ with label space $\mathbb { R } ^ { C }$ . Let $\epsilon \geq 0$ . We say $\tilde { D }$ is a weak $\epsilon$ -approximation of $D$ with respect to $( \tilde { A } , A , \ell , \mathcal { P } )$ if $\tilde { A } _ { \tilde { D } }$ and $A _ { D }$ are weakly $\epsilon$ -close with respect to $( \ell , \mathcal { P } )$ , where $\ell$ is a loss function and $\mathcal { P }$ is a distribution on $\mathbb { R } ^ { d } \times \mathbb { R } ^ { C }$ . We define strong $\epsilon$ -approximation similarly. We drop explicit reference to (some of) the $\tilde { A } , A , \ell , \mathcal { P }$ if their values are understood or immaterial.
+
+We provide some justification for this definition in the Appendix. In this paper, we will measure $\epsilon$ - approximation with respect to 0-1 loss for multiway classification (i.e. accuracy). We focus on weak $\epsilon$ -approximation, since in most of our experiments, we consider models in the low-data regime with large classification error rates, in which case, sample-wise agreement of two models is not of central importance. On the other hand, observe that if two models have population classification error rates less than $\epsilon / 2$ , then (2) is automatically satisfied, in which case, the notions of weak-approximation and strong-approximation converge.
+
+We list several examples of $\epsilon$ -approximation, with $\epsilon = 0$ , for the case when ${ \tilde { A } } = A$ are given by the following:
+
+Example 1: Support Vector Machines. Given a dataset $D$ of size $N$ , train an SVM on $D$ and obtain $M$ support vectors. These $M$ support vectors yield a dataset $\tilde { D }$ that is a strong 0-approximation to $D$ in the linearly separable case, while for the nonseparable case, one has to also include the datapoints with positive slack. Asymptotic lower bounds asserting $M = O ( N )$ have been shown in Steinwart (2003).2
+
+Example 2: Ridge Regression. Any two datasets $D$ and $\tilde { D }$ that determine the same ridge-regressor are 0-approximations of each other. In particular, in the scalar case, we can obtain arbitrarily small 0-approximating $\tilde { D }$ as follows. Given training data $D = ( X , y )$ in $\mathbb { R } ^ { d }$ , the corresponding ridgeregressor is the predictor
+
+$$
+\begin{array} { c } { { x ^ { * } \mapsto w \cdot x ^ { * } , } } \\ { { w = \Phi _ { \lambda } ( X ) y , } } \\ { { \Phi _ { \lambda } ( X ) = X ^ { T } ( X X ^ { T } + \lambda I ) ^ { - 1 } } } \end{array}
+$$
+
+where for $\lambda = 0$ , we interpret the inverse as a pseudoinverse. It follows that for any given $w \in \mathbb { R } ^ { d \times 1 }$ , we can always find $( \tilde { X } , \tilde { y } )$ of arbitrary size (i.e. $\tilde { X } \in \mathbb { R } ^ { n \times d }$ , $y \in \mathbb { R } ^ { n \times 1 }$ with $n$ arbitrarily small) that satisfies $w = \Phi _ { \lambda } ( \tilde { X } ) \tilde { y }$ . Simply choose $\tilde { X }$ such that $w$ is in the range of $\Phi _ { \lambda } ( { \tilde { X } } )$ . The resulting dataset $( \tilde { X } , \tilde { y } )$ is a 0-approximation to $D$ . If we have a $C$ -dimensional regression problem, the preceding analysis can be repeated component-wise in label-space to show 0-approximation with a dataset of size at least $C$ (since then the rank of $\Phi _ { \lambda } ( { \tilde { X } } )$ can be made at least the rank of $w \in \mathbb { R } ^ { d \times C }$ ).
+
+We are interested in learning algorithms given by KRR and neural networks. These can be investigated in unison via neural tangent kernels. Furthermore, we study two settings for the usage of $\epsilon$ -approximate datasets, though there are bound to be others:
+
+1. (Sample efficiency / compression) Fix $\epsilon$ . What is the minimum size of $\tilde { D }$ needed in order for $\tilde { D }$ to be an $\epsilon$ -approximate dataset?   
+2. (Privacy guarantee) Can an $\epsilon$ -approximate dataset be found such that the distribution from which it is drawn and the distribution from which the original training dataset is drawn satisfy a given upper bound in mutual information?
+
+Motivated by these questions, we introduce the following definitions:
+
+Definition 4. (Heuristic) Let $\tilde { D }$ and $D$ be two datasets such that $\tilde { D }$ is a weak $\epsilon$ -approximation of $D$ , with $| \tilde { D } | \leq | D |$ and $\epsilon$ small. We call $| D | / | \tilde { D } |$ the compression ratio.
+
+In other words, the compression ratio is a measure of how well $\tilde { D }$ compresses the information available in $D$ , as measured by approximate agreement of their population loss. Our definition is heuristic in that $\epsilon$ is not precisely quantified and so is meant as a soft measure of compression.
+
+Definition 5. Let $\Gamma$ be an algorithm that takes a dataset $D$ in $\mathbb { R } ^ { d }$ and returns a (random) collection of datasets in $\mathbb { R } ^ { d }$ . For $0 \leq \rho \leq 1$ , we say that $\Gamma$ is $\rho$ -corrupted if for any input dataset $D$ , every datapoint3 drawn from the datasets of $\Gamma ( D )$ has at least $\rho$ fraction of its coordinates independent of $D$ .
+
+In other words, datasets produced by $\Gamma$ have $\rho$ fraction of its entries contain no information about the dataset $D$ (e.g. because they have a fixed value or are filled in randomly). Corrupting information is naturally a way of enhancing privacy, as it makes it more difficult for an attacker to obtain useful information about the data used to train a model. Adding noise to the inputs to neural network or of its gradient updates can be shown to provide differentially private guarantees (Abadi et al. (2016)).
+
+# 3 KERNEL INDUCING POINTS
+
+Given a dataset $D$ sampled from a distribution $\mathcal { P }$ , we want to find a small dataset $\tilde { D }$ that is an $\epsilon$ - approximation to $D$ (or some large subset thereof) with respect to $( \tilde { A } , A , \ell , \mathcal { P } )$ . Focusing on ${ \tilde { A } } = A$ for the moment, and making the approximation
+
+$$
+\begin{array} { r } { \mathbb { E } _ { ( x , y ) \in \mathcal { P } } \ell ( \tilde { A } _ { \tilde { D } } ( x ) , y ) \approx \mathbb { E } _ { ( x , y ) \in D } \ell ( \tilde { A } _ { \tilde { D } } ( x ) , y ) , } \end{array}
+$$
+
+this suggests we should optimize the right-hand side of (6) with respect to $\tilde { D }$ , using $D$ as a validation set. For general algorithms $\tilde { A }$ , the outer optimization for $\tilde { D }$ is computationally expensive and involves second-order derivatives, since one has to optimize over the inner loop encoded by the learning algorithm $\tilde { A }$ . We are thus led to consider the class of algorithms drawn from kernel ridgeregression. The reason for this are two-fold. First, KRR performs convex-optimization resulting in a closed-form solution, so that when optimizing for the training parameters of KRR (in particular, the support data), we only have to consider first-order optimization. Second, since KRR for a neural tangent kernel (NTK) approximates the training of the corresponding wide neural network (Jacot et al., 2018; Lee et al., 2019; Arora et al., 2019a; Lee et al., 2020), we expect the use of neural kernels to yield $\epsilon$ -approximations of $D$ for learning algorithms given by a broad class of neural networks trainings as well. (This will be validated in our experiments.)
+
+Require: A target labeled dataset $( X _ { t } , y _ { t } )$ along with a kernel or family of kernels.   
+1: Initialize a labeled support set $( X _ { s } , y _ { s } )$ .   
+2: while not converged do   
+3: Sample a random kernel. Sample a random batch $( \bar { X } _ { s } , \bar { y } _ { s } )$ from the support set. Sample a random batch $( \bar { X } _ { t } , \bar { y } _ { t } )$ from the target dataset.   
+4: Compute the kernel ridge-regression loss given by (7) using the sampled kernel and the sampled support and target data.   
+5: Backpropagate through ${ \bar { X } } _ { s }$ (and optionally $\bar { y } _ { s }$ and any hyper-parameters of the kernel) and update the support set $( X _ { s } , y _ { s } )$ by updating the subset $( \overleftarrow { X } _ { s } , \overbar { y } _ { s } )$ .   
+6: end while   
+7: return Learned support set $( X _ { s } , y _ { s } )$
+
+This leads to our first-order meta-learning algorithm KIP (Kernel Inducing Points), which uses kernel-ridge regression to learn $\epsilon$ -approximate datasets. It can be regarded as an adaption of the inducing point method for Gaussian processes (Snelson & Ghahramani, 2006) to the case of KRR. Given a kernel $K$ , the KRR loss function trained on a support dataset $( X _ { s } , y _ { s } )$ and evaluated on a target dataset $( X _ { t } , y _ { t } )$ is given by
+
+$$
+L ( X _ { s } , y _ { s } ) = \frac { 1 } { 2 } \| y _ { t } - K _ { X _ { t } X _ { s } } ( K _ { X _ { s } X _ { s } } + \lambda I ) ^ { - 1 } y _ { s } \| ^ { 2 } ,
+$$
+
+where if $U$ and $V$ are sets, $K _ { U V }$ is the matrix of kernel elements $( K ( u , v ) ) _ { u \in U , v \in V }$ . Here $\lambda > 0$ is a fixed regularization parameter. The KIP algorithm consists of optimizing (7) with respect to the support set (either just the $X _ { s }$ or along with the labels $y _ { s }$ ), see Algorithm 1. Depending on the downstream task, it can be helpful to use families of kernels (Step 3) because then KIP produces datasets that are $\epsilon$ -approximations for a variety of kernels instead of a single one. This leads to a corresponding robustness for the learned datasets when used for neural network training. We remark on best experimental practices for sampling methods and initializations for KIP in the Appendix. Theoretical analysis for the convergence properties of KIP for the case of a linear kernel is provided by Theorem 1. Sample KIP -learned images can be found in Section F.
+
+KIP variations: i) We can also randomly augment the sampled target batches in KIP . This effectively enhances the target dataset $( X _ { t } , y _ { t } )$ , and we obtain improved results in this way, with no extra computational cost with respect to the support size. ii) We also can choose a corruption fraction $0 \leq \rho < 1$ and do the following. Initialize a random $\rho$ -percent of the coordinates of each support datapoint via some corruption scheme (zero out all such pixels or initialize with noise). Next, do not update such corrupted coordinates during the KIP training algorithm (i.e. we only perform gradient updates on the complementary set of coordinates). Call this resulting algorithm $\mathrm { K I P } _ { \rho }$ . In this way, $\mathrm { K I P } _ { \rho }$ is $\rho$ -corrupted according to Definition 5 and we use it to obtain our highly corrupted datasets.
+
+Label solving: In addition to KIP , where we learn the support dataset via gradient descent, we propose another inducing point method, Label Solve (LS ), in which we directly find the minimum of (7) with respect to the support labels while holding $X _ { s }$ fixed. This is simple because the loss function is quadratic in $y _ { s }$ . We refer to the resulting labels
+
+$$
+y _ { s } ^ { * } = \Phi _ { 0 } \Bigl ( K _ { X _ { t } X _ { s } } ( K _ { X _ { s } X _ { s } } + \lambda I ) ^ { - 1 } \Bigr ) y _ { t }
+$$
+
+as solved labels. As $\Phi _ { 0 }$ is the pseudo-inverse operation, $y _ { s } ^ { * }$ is the minimum-norm solution among minimizers of (7). If $K _ { X , X _ { s } }$ is injective, using the fact that $\bar { \Phi } _ { 0 } ( A B ) = \Phi _ { 0 } ( B ) \Phi _ { 0 } ( A )$ for $A$ injective and $B$ surjective (Greville (1966)), we can rewrite (8) as
+
+$$
+y _ { s } ^ { * } = ( K _ { X _ { s } X _ { s } } + \lambda I ) \Phi _ { 0 } ( K _ { X _ { t } X _ { s } } ) y _ { t } .
+$$
+
+# 4 EXPERIMENTS
+
+We perform three sets of experiments to validate the efficacy of KIP and LS for dataset learning. The first set of experiments investigates optimizing KIP and LS for compressing datasets and achieving state of the art performance for individual kernels. The second set of experiments explores transferability of such learned datasets across different kernels. The third set of experiments investigate the transferability of KIP -learned datasets to training neural networks. The overall conclusion is that KIP -learned datasets, even highly corrupted versions, perform well in a wide variety of settings. Experimental details can be found in the Appendix.
+
+We focus on MNIST (LeCun et al., 2010) and CIFAR-10 (Krizhevsky et al., 2009) datasets for comparison to previous methods. For LS , we also use Fashion-MNIST. These classification tasks are recast as regression problems by using mean-centered one-hot labels during training and by making class predictions via assigning the class index with maximal predicted value during testing. All our kernel-based experiments use the Neural Tangents library (Novak et al., 2020), built on top of JAX (Bradbury et al., 2018). In what follows, we use $\operatorname { F C } m$ and Convm to denote a depth $m$ fully-connected or fully-convolutional network. Whether we mean a finite-width neural network or else the corresponding neural tangent kernel (NTK) will be understood from the context. We will sometimes also use the neural network Gaussian process (NNGP) kernel associated to a neural network in various places. By default, a neural kernel refers to NTK unless otherwise stated. RBF denotes the radial-basis function kernel. Myrtle- $. N$ architecture follows that of Shankar et al. (2020), where an $N$ -layer neural network consisting of a simple combination of $N - 1$ convolutional layers along with $( 2 , 2 )$ average pooling layers are inter-weaved to reduce internal patch-size.
+
+We would have used deeper and more diverse architectures for KIP , but computational limits, which will be overcome in future work, placed restrictions, see the Experiment Details in Section D.
+
+# 4.1 SINGLE KERNEL RESULTS
+
+We apply KIP to learn support datasets of various sizes for MNIST and CIFAR-10. The objective is to distill the entire training dataset down to datasets of various fixed, smaller sizes to achieve high compression ratio. We present these results against various baselines in Tables 1 and 2. These comparisons occur cross-architecturally, but aside from Myrtle LS results, all our results involve the simplest of kernels (RBF or FC1), whereas prior art use deeper architectures (LeNet, AlexNet, ConvNet).
+
+We obtain state of the art results for KRR on MNIST and CIFAR-10, for the RBF and FC1 kernels, both in terms of accuracy and number of images required, see Tables 1 and 2. In particular, our method produces datasets such that RBF and FC1 kernels fit to them rival the performance of deep convolutional neural networks on MNIST (exceeding $9 9 . 2 \%$ ). By comparing Tables 2 and A2, we see that, e.g. 10 or $1 0 0 \mathtt { K I P }$ images for RBF and FC1 perform on par with tens or hundreds times more natural images, resulting in a compression ratio of one or two orders of magnitude.
+
+For neural network trainings, for CIFAR-10, the second group of rows in Table 2 shows that FC1 trained on KIP images outperform prior art, all of which have deeper, more expressive architectures. On MNIST, we still outperform some prior baselines with deeper architectures. This, along with the state of the art KRR results, suggests that KIP , when scaled up to deeper architectures, should continue to yield strong neural network performance.
+
+For LS , we use a mix of NNGP kernels4 and NTK kernels associated to FC1, Myrtle-5, Myrtle-10 to learn labels on various subsets of MNIST, Fashion-MNIST, and CIFAR-10. Our results comprise the bottom third of Tables 1 and 2 and Figure 2. As Figure 2 shows, the more targets are used, the better the performance. When all possible targets are used, we get an optimal compression ratio of roughly one order of magnitude at intermediate support sizes.
+
+# 4.2 KERNEL TO KERNEL RESULTS
+
+Here we investigate robustness of KIP and LS learned datasets when there is variation in the kernels used for training and testing. We draw kernels coming from FC and Conv layers of depths 1-3, since such components form the basic building blocks of neural networks. Figure A1 shows that KIP - datasets trained with random sampling of all six kernels do better on average than KIP -datasets trained using individual kernels.
+
+![](images/c9c6684ed34735f67fb3afaa3c00d98e6e19fca7876c2ddbd0815f703a48f25e.jpg)  
+Figure 2: LS performance for Myrtle-(5/10) and FC on CIFAR-10/Fashion-MNIST/MNIST. Results computed over 3 independent samples per support set size.
+
+Table 1: MNIST: KIP and LS vs baselines. Comparing KRR (kernel ridge-regression) and NN (neural network) algorithms using various architectures and dataset distillation methods on datasets of varying sizes (10 to 10K).   
+
+<table><tr><td>Alg.</td><td>Arch., Method</td><td>10</td><td>100</td><td>500</td><td>5000</td><td>10000</td></tr><tr><td>KRR</td><td>RBF,KIP</td><td>89.60±0.09</td><td>97.31±0.09</td><td>98.29±0.06</td><td>98.70±0.04</td><td>98.74±0.04</td></tr><tr><td>KRR</td><td>RBF, KIP (a + 1)1</td><td>90.63±0.27</td><td>97.84±0.06</td><td>98.85±0.04</td><td>99.31±0.04</td><td>99.34±0.03</td></tr><tr><td>KRR</td><td>FC1, KIP</td><td>89.30±0.01</td><td>96.64±0.08</td><td>97.64±0.06</td><td>98.52±0.04</td><td>98.59±0.05</td></tr><tr><td>KRR</td><td>FC1, KIP (a + 1)</td><td>85.46±0.04</td><td>97.15±0.11</td><td>98.36±0.08</td><td>99.18±0.04</td><td>99.26±0.03</td></tr><tr><td>NN</td><td>FC1, KIP²</td><td>86.49±0.40</td><td>88.96±0.37</td><td>95.70±0.09</td><td>97.97±0.07</td><td>=</td></tr><tr><td>NN</td><td>ConvNet DC4</td><td>91.7±0.5</td><td>97.4±0.2</td><td></td><td></td><td></td></tr><tr><td>NN</td><td>LeNet,DC</td><td>1</td><td>93.9±0.6</td><td></td><td></td><td></td></tr><tr><td>NN</td><td>LeNet, SLDD</td><td></td><td>82.7±2.8</td><td></td><td></td><td></td></tr><tr><td>NN</td><td>LeNet, DD</td><td></td><td>79.5±8.1</td><td></td><td>=</td><td>=</td></tr><tr><td>KRR</td><td>FC1,LS</td><td>61.0±0.28</td><td>87.2±0.71</td><td>94.4±0.16</td><td>97.5±0.06</td><td>97.9±0.09</td></tr><tr><td>KRR</td><td>Myrtle-5 NNGP, LS</td><td>70.24±1.59</td><td>95.44±0.17</td><td>98.32±0.91</td><td>99.17±0.01</td><td>99.33±0.07</td></tr><tr><td>KRR</td><td>Myrtle-5,LS</td><td>68.50±2.52</td><td>95.53±0.22</td><td>98.17±0.07</td><td>99.05±0.06</td><td>99.22±0.02</td></tr><tr><td>NN</td><td>LeNet,LD</td><td>64.57±2.67</td><td>87.85±0.43</td><td>94.75±0.29</td><td></td><td></td></tr></table>
+
+1 $\left( \mathrm { a } + \mathrm { l } \right)$ denotes KIP trained with augmentations and learning of labels 2 KIP images are trained using the same kernel (FC1) corresponding to the evaluation neural network. Likewise for KRR, the train and test kernels coincide. 3 ConvNet is neural network consisting of 3 convolutional blocks, where a block consists of convolution, instance normalization, and a (2,2) average pooling. See Zhao et al. (2020). 4 DC (Zhao et al., 2020), LD (Bohdal et al., 2020), SLDD (Sucholutsky & Schonlau, 2019), DD (Wang et al., 2018).
+
+For LS , transferability between FC1 and Myrtle-10 kernels on CIFAR-10 is highly robust, see Figure A2. Namely, one can label solve using FC1 and train Myrtle-10 using those labels and vice versa. There is only a negligible difference in performance in nearly all instances between data with transferred learned labels and with natural labels.
+
+# 4.3 KERNEL TO NEURAL NETWORKS RESULTS
+
+Significantly, KIP -learned datasets, even with heavy corruption, transfer remarkably well to the training of neural networks. Here, corruption refers to setting a random $\rho$ fraction of the pixels of each image to uniform noise between $- 1$ and 1 (for KIP , this is implemented via $\mathtt { K I P } _ { \rho } ^ { \mathtt { \tiny \star } } ) ^ { 5 }$ . The deterioriation in test accuracy for KIP -images is limited as a function of the corruption fraction, especially when compared to natural images, and moreover, corrupted KIP -images typically outperform uncorrupted natural images. We verify these conclusions along the following dimensions:
+
+Robustness to dataset size: We perform two sets of experiments.
+
+(i) First, we consider small KIP datasets (10, 100, 200 images) optimized using multiple kernels (FC1-3, Conv1-2), see Tables A5, A6. We find that our in-distribution transfer (the downstream neural network has its neural kernel included among the kernels sampled by KIP ) performs remarkably well, with both uncorrupted and corrupted KIP images beating the uncorrupted natural images of corresponding size. Out of distribution networks (LeNet (LeCun et al., 1998) and Wide Resnet (Zagoruyko & Komodakis, 2016)) have less transferability: the uncorrupted images still outperform natural images, and corrupted KIP images still outperform corrupted natural images, but corrupted KIP images no longer outperform uncorrupted natural images.
+
+Table 2: CIFAR-10: KIP and LS vs baselines. Comparing KRR (kernel ridge-regression) and NN (neural network) algorithms using various architectures and dataset distillation methods on datasets of various sizes (10 to 10K). Notation same as in Table 1.   
+
+<table><tr><td>Alg.</td><td>Arch., Method</td><td>10</td><td>100</td><td>500</td><td>5000</td><td>10000</td></tr><tr><td>KRR</td><td>RBF, KIP</td><td>39.9±0.9</td><td>49.3±0.3</td><td>51.2±0.8</td><td>1</td><td>1</td></tr><tr><td>KRR</td><td>RBF, KIP (a + 1)</td><td>40.3±0.5</td><td>53.8±0.3</td><td>60.1±0.2</td><td>65.6±0.2</td><td>66.3±0.2</td></tr><tr><td>KRR</td><td>FC1, KIP</td><td>39.3±1.6</td><td>49.1±1.1</td><td>52.1±0.8</td><td>54.5±0.5</td><td>54.9±0.5</td></tr><tr><td>KRR</td><td>FC1, KIP (a + 1)</td><td>40.5±0.4</td><td>53.1±0.5</td><td>58.6±0.4</td><td>63.8±0.3</td><td>64.6±0.2</td></tr><tr><td>NN</td><td>FC1, KIP</td><td>36.2±0.1</td><td>45.7±0.3</td><td>46.9±0.2</td><td>50.1±0.4</td><td>51.7±0.4</td></tr><tr><td>NN</td><td>ConvNet, DC</td><td>28.3±0.5</td><td>44.9±0.5</td><td>=</td><td></td><td>=</td></tr><tr><td>NN</td><td>AlexNet,DC</td><td>-</td><td>39.1±1.2</td><td></td><td></td><td></td></tr><tr><td>NN</td><td>AlexNet, SLDD</td><td></td><td>39.8±0.8</td><td></td><td></td><td></td></tr><tr><td>NN</td><td>AlexNet,DD</td><td>-</td><td>36.8±1.2</td><td></td><td>1</td><td>=</td></tr><tr><td>KRR</td><td>FC1 NNGP, LS</td><td>27.5±0.3</td><td>40.1±0.3</td><td>46.4±0.4</td><td>53.5±0.2</td><td>55.1±0.3</td></tr><tr><td>KRR</td><td>Myrtle-10 NNGP, LS + ZCA5</td><td>31.7±0.2</td><td>56.0±0.5</td><td>69.8±0.1</td><td>80.2±0.1</td><td>82.3±0.1</td></tr><tr><td>KRR</td><td>Myrtle-10, LS</td><td>28.8±0.4</td><td>45.8±0.7</td><td>58.0±0.3</td><td>69.6±0.2</td><td>72.0±0.2</td></tr><tr><td>NN</td><td>AlexNet,LD</td><td>25.69±0.72</td><td>38.33±0.44</td><td>43.16±0.47</td><td>1</td><td>1</td></tr></table>
+
+5 We apply regularized ZCA whitening instead of standard preprocessing to the images, see Appendix D for further details.
+
+(ii) We consider larger KIP datasets (1K, 5K, 10K images) optimized using a single FC1 kernel for training of a corresponding FC1 neural network, where the KIP training uses augmentations (with and without label learning), see Tables A7-A10 and Figure A3. We find, as before, KIP images outperform natural images by an impressive margin: for instance, on CIFAR-10, 10K KIP -learned images with $90 \%$ corruption achieves $4 9 . 9 \%$ test accuracy, exceeding 10K natural images with no corruption (acc: $4 5 . 5 \%$ ) and $90 \%$ corruption (acc: $3 3 . 8 \%$ ). Interestingly enough, sometimes higher corruption leads to better test performance (this occurs for CIFAR-10 with cross entropy loss for both natural and KIP -learned images), a phenomenon to be explored in future work. We also find that KIP with label-learning often tends to harm performance, perhaps because the labels are overfitting to KRR.
+
+Robustness to hyperparameters: For CIFAR-10, we took 100 images, both clean and $90 \%$ corrupted, and trained networks on a wide variety of hyperparameters for various neural architectures. We considered both neural networks whose corresponding neural kernels were sampled during KIP - training those that were not. We found that in both cases, the KIP -learned images almost always outperform 100 random natural images, with the optimal set of hyperparameters yielding a margin close to that predicted from the KRR setting, see Figure 3. This suggests that KIP -learned images can be useful in accelerating hyperparameter search.
+
+# 5 RELATED WORK
+
+Coresets: A classical approach for compressing datasets is via subset selection, or some approximation thereof. One notable work is Borsos et al. (2020), utilizing KRR for dataset subselection. For an overview of notions of coresets based on pointwise approximatation of datasets, see Phillips (2016).
+
+Neural network approaches to dataset distillation: Maclaurin et al. (2015); Lorraine et al. (2020) approach dataset distillation through learning the input images from large-scale gradient-based metalearning of hyper-parameters. Properties of distilled input data was first analyzed in Wang et al. (2018). The works Sucholutsky & Schonlau (2019); Bohdal et al. (2020) build upon Wang et al.
+
+![](images/b1acf8c21abfd841d06c91be304386817e2f2df80f1752705646402a530cea1b.jpg)  
+Figure 3: KIP learned images transfers well to finite neural networks. Test accuracy on CIFAR10 comparing natural images $\mathbf { \dot { x } }$ -axis) and KIP -learned images (y-axis). Each scatter point corresponds to varying hyperparameters for training (e.g. learning rate). Top row are clean images, bottom row are $90 \%$ corrupted images. KIP images were trained using FC1-3, Conv1-2 kernels.
+
+(2018) by distilling labels. More recently, Zhao et al. (2020) proposes condensing training set by gradient matching condition and shows improvement over Wang et al. (2018).
+
+Inducing points: Our approach has as antecedant the inducing point method for Gaussian Processes (Snelson & Ghahramani, 2006; Titsias, 2009). However, whereas the latter requires a probabilistic framework that optimizes for marginal likelihood, in our method we only need to consider minimizing mean-square loss on validation data.
+
+Low-rank kernel approximations: Unlike common low-rank approximation methods (Williams & Seeger, 2001; Drineas & Mahoney, 2005), we obtain not only a low-rank support-support kernel matrix with KIP , but also a low-rank target-support kernel matrix. Note that the resulting matrices obtained from KIP need not approximate the original support-support or target-support matrices since KIP only optimizes for the loss function.
+
+Neural network kernels: Our work is motivated by the exact correspondence between infinitelywide neural networks and kernel methods (Neal, 1994; Lee et al., 2018; Matthews et al., 2018; Jacot et al., 2018; Novak et al., 2019; Garriga-Alonso et al., 2019; Arora et al., 2019a). These correspondences allow us to view both Bayesian inference and gradient descent training of wide neural networks with squared loss as yielding a Gaussian process or kernel ridge regression with neural kernels.
+
+Instance-Based Encryption: A related approach to corrupting datasets involves encrypting individual images via sign corruption (Huang et al. (2020)).
+
+# 6 CONCLUSION
+
+We introduced novel algorithms KIP and LS for the meta-learning of datasets. We obtained a variety of compressed and corrupted datasets, achieving state of the art results for KRR and neural network dataset distillation methods. This was achieved even using the simplest of kernels and neural networks (shallow fully-connected networks and purely-convolutional networks without pooling), which notwithstanding their limited expressiveness, outperform most baselines that use deeper architectures. Follow-up work will involve scaling up KIP to deeper architectures with pooling (achievable with multi-device training) for which we expect to obtain even more highly performant datasets, both in terms of overall accuracy and architectural flexibility. Finally, we obtained highly corrupt datasets whose performance match or exceed natural images, which when developed at scale, could lead to practical applications for privacy-preserving machine learning.
+
+# ACKNOWLEDGMENTS
+
+We would like to thank Dumitru Erhan, Yang Li, Hossein Mobahi, Jeffrey Pennington, Si Si, Jascha Sohl-Dickstein, and Lechao Xiao for helpful discussions and references.
+
+# REFERENCES
+
+Martin Abadi, Andy Chu, Ian Goodfellow, H. Brendan McMahan, Ilya Mironov, Kunal Talwar, and Li Zhang. Deep learning with differential privacy. Proceedings of the 2016 ACM SIGSAC Conference on Computer and Communications Security, Oct 2016. doi: 10.1145/2976749.2978318. URL http://dx.doi.org/10.1145/2976749.2978318.
+
+Sanjeev Arora, Simon S Du, Wei Hu, Zhiyuan Li, Russ R Salakhutdinov, and Ruosong Wang. On exact computation with an infinitely wide neural net. In Advances in Neural Information Processing Systems, pp. 8141–8150. Curran Associates, Inc., 2019a.
+
+Sanjeev Arora, Simon S Du, Zhiyuan Li, Ruslan Salakhutdinov, Ruosong Wang, and Dingli Yu. Harnessing the power of infinitely wide deep nets on small-data tasks. arXiv preprint arXiv:1910.01663, 2019b.
+
+Ondrej Bohdal, Yongxin Yang, and Timothy Hospedales. Flexible dataset distillation: Learn labels instead of images. arXiv preprint arXiv:2006.08572, 2020.
+
+Antoine Bordes, Seyda Ertekin, Jason Weston, and Leon Bottou. Fast kernel classifiers with online ´ and active learning. Journal of Machine Learning Research, 6(Sep):1579–1619, 2005.
+
+Zalan Borsos, Mojm ´ ´ır Mutny, and Andreas Krause. Coresets via bilevel optimization for continual \` learning and streaming. arXiv preprint arXiv:2006.03875, 2020.
+
+James Bradbury, Roy Frostig, Peter Hawkins, Matthew James Johnson, Chris Leary, Dougal Maclaurin, and Skye Wanderman-Milne. JAX: composable transformations of Python $^ +$ NumPy programs, 2018. URL http://github.com/google/jax.
+
+Petros Drineas and Michael W Mahoney. On the nystrom method for approximating a gram matrix ¨ for improved kernel-based learning. journal of machine learning research, 6(Dec):2153–2175, 2005.
+
+Adria Garriga-Alonso, Laurence Aitchison, and Carl Edward Rasmussen. Deep convolutional net-\` works as shallow gaussian processes. In International Conference on Learning Representations, 2019.
+
+T. N. E. Greville. Note on the generalized inverse of a matrix product. SIAM Review, 8(4):518–521, 1966. ISSN 00361445. URL http://www.jstor.org/stable/2027337.
+
+Trevor Hastie, Andrea Montanari, Saharon Rosset, and Ryan J. Tibshirani. Surprises in highdimensional ridgeless least squares interpolation, 2019.
+
+Yangsibo Huang, Zhao Song, Kai Li, and Sanjeev Arora. Instahide: Instance-hiding schemes for private distributed learning, 2020.
+
+Arthur Jacot, Franck Gabriel, and Clement Hongler. Neural tangent kernel: Convergence and generalization in neural networks. In Advances in Neural Information Processing Systems, 2018.
+
+Ibrahim Jubran, Alaa Maalouf, and Dan Feldman. Introduction to coresets: Accurate coresets. arXiv preprint arXiv:1910.08707, 2019.
+
+T. Kato. Perturbation Theory of Linear Operators. Springer-Verlag, Berlin, 2 edition, 1976.
+
+Mahmut Kaya and H.s Bilge. Deep metric learning: A survey. Symmetry, 11:1066, 08 2019. doi: 10.3390/sym11091066.
+
+Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. 2009.
+
+Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.
+
+Yann LeCun, Corinna Cortes, and CJ Burges. Mnist handwritten digit database. ATT Labs [Online]. Available: http://yann.lecun.com/exdb/mnist, 2, 2010.
+
+Jaehoon Lee, Yasaman Bahri, Roman Novak, Sam Schoenholz, Jeffrey Pennington, and Jascha Sohldickstein. Deep neural networks as gaussian processes. In International Conference on Learning Representations, 2018.
+
+Jaehoon Lee, Lechao Xiao, Samuel S. Schoenholz, Yasaman Bahri, Roman Novak, Jascha SohlDickstein, and Jeffrey Pennington. Wide neural networks of any depth evolve as linear models under gradient descent. In Advances in Neural Information Processing Systems, 2019.
+
+Jaehoon Lee, Samuel S Schoenholz, Jeffrey Pennington, Ben Adlam, Lechao Xiao, Roman Novak, and Jascha Sohl-Dickstein. Finite versus infinite neural networks: an empirical study. arXiv preprint arXiv:2007.15801, 2020.
+
+Jonathan Lorraine, Paul Vicol, and David Duvenaud. Optimizing millions of hyperparameters by implicit differentiation. In International Conference on Artificial Intelligence and Statistics, pp. 1540–1552. PMLR, 2020.
+
+Dougal Maclaurin, David Duvenaud, and Ryan Adams. Gradient-based hyperparameter optimization through reversible learning. In International Conference on Machine Learning, pp. 2113– 2122, 2015.
+
+Julien Mairal, Piotr Koniusz, Zaid Harchaoui, and Cordelia Schmid. Convolutional kernel networks. In Advances in Neural Information Processing Systems, 2014.
+
+Alexander G. de G. Matthews, Jiri Hron, Mark Rowland, Richard E. Turner, and Zoubin Ghahramani. Gaussian process behaviour in wide deep neural networks. In International Conference on Learning Representations, 2018.
+
+Radford M. Neal. Priors for infinite networks (tech. rep. no. crg-tr-94-1). University of Toronto, 1994.
+
+Roman Novak, Lechao Xiao, Jaehoon Lee, Yasaman Bahri, Greg Yang, Jiri Hron, Daniel A. Abolafia, Jeffrey Pennington, and Jascha Sohl-Dickstein. Bayesian deep convolutional networks with many channels are gaussian processes. In International Conference on Learning Representations, 2019.
+
+Roman Novak, Lechao Xiao, Jiri Hron, Jaehoon Lee, Alexander A. Alemi, Jascha Sohl-Dickstein, and Samuel S. Schoenholz. Neural tangents: Fast and easy infinite neural networks in python. In International Conference on Learning Representations, 2020. URL https://github.com/ google/neural-tangents.
+
+Jeff M Phillips. Coresets and sketches. arXiv preprint arXiv:1601.00617, 2016.
+
+Vaishaal Shankar, Alex Chengyu Fang, Wenshuo Guo, Sara Fridovich-Keil, Ludwig Schmidt, Jonathan Ragan-Kelley, and Benjamin Recht. Neural kernels without tangents. In International Conference on Machine Learning, 2020.
+
+Sam Shleifer and Eric Prokop. Using small proxy datasets to accelerate hyperparameter search. arXiv preprint arXiv:1906.04887, 2019.
+
+Jake Snell, Kevin Swersky, and Richard Zemel. Prototypical networks for few-shot learning. In I. Guyon, U. V. Luxburg, S. Bengio, H. Wallach, R. Fergus, S. Vishwanathan, and R. Garnett (eds.), Advances in Neural Information Processing Systems 30, pp. 4077–4087. Curran Associates, Inc., 2017. URL http://papers.nips.cc/paper/ 6996-prototypical-networks-for-few-shot-learning.pdf.
+
+Edward Snelson and Zoubin Ghahramani. Sparse gaussian processes using pseudo-inputs. In Advances in neural information processing systems, pp. 1257–1264, 2006.
+
+Jascha Sohl-Dickstein, Roman Novak, Samuel S Schoenholz, and Jaehoon Lee. On the infinite width limit of neural networks with a standard parameterization. arXiv preprint arXiv:2001.07301, 2020.
+
+Ingo Steinwart. Sparseness of support vector machines. Journal of Machine Learning Research, 4 (Nov):1071–1105, 2003.
+
+Ilia Sucholutsky and Matthias Schonlau. Soft-label dataset distillation and text dataset distillation. arXiv preprint arXiv:1910.02551, 2019.
+
+Michalis Titsias. Variational learning of inducing variables in sparse gaussian processes. In Artificial Intelligence and Statistics, pp. 567–574, 2009.
+
+Oriol Vinyals, Charles Blundell, Timothy P. Lillicrap, Koray Kavukcuoglu, and Daan Wierstra. Matching networks for one shot learning. CoRR, abs/1606.04080, 2016. URL http://arxiv. org/abs/1606.04080.
+
+Tongzhou Wang, Jun-Yan Zhu, Antonio Torralba, and Alexei A Efros. Dataset distillation. arXiv preprint arXiv:1811.10959, 2018.
+
+Christopher KI Williams and Matthias Seeger. Using the nystrom method to speed up kernel ma-¨ chines. In Advances in neural information processing systems, pp. 682–688, 2001.
+
+Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. CoRR, abs/1605.07146, 2016. URL http://arxiv.org/abs/1605.07146.
+
+Bo Zhao, Konda Reddy Mopuri, and Hakan Bilen. Dataset condensation with gradient matching. arXiv preprint arXiv:2006.05929, 2020.
+
+# A REMARKS ON DEFINITION OF $\epsilon$ -APPROXIMATION
+
+Here, we provide insights into the formulation of Definition 3. One noticeable feature of our definition is that it allows for different algorithms $A$ and $\tilde { A }$ when comparing datasets $D$ and $\tilde { D }$ . On the one hand, such flexibility is required, since for instance, a mere preprocessing of the dataset (e.g. rescaling it), should be regarded as producing an equivalent (0-approximate) dataset. Yet such a rescaling may affect the hyperparameters needed to train an equivalent model (e.g. the learning rate). Thus, one must allow the relevant hyperparameters of an algorithm to vary when the datasets are also varying. On the other hand, it would be impossible to compare two datasets meaningfully if the learned algorithms used to train them differ too significantly. For instance, if $D$ is a much larger dataset than $\tilde { D }$ , but $A$ is a much less expressive algorithm than $\tilde { A }$ , then the two datasets may be $\epsilon$ -approximations of each other, but it would be strange to compare $D$ and $\tilde { D }$ in this way. Thus, we treat the notion of what class of algorithms to consider informally, and leave its specification as a practical matter for each use case. In practice, the pair of algorithms we use to compare datasets should be drawn from a family in which some reasonable range of hyperparameters are varied, the ones typically tuned when learning on an unknown dataset. The main case for us with differing $A$ and $\tilde { A }$ is when we compare neural network training alongside kernel ridge-regression.
+
+Another key feature of our definition is that datapoints of an $\epsilon$ -approximating dataset must have the same shape as those of the original dataset. This makes our notion of an $\epsilon$ -approximate dataset more restrictive than returning a specialized set of extracted features from some initial dataset.
+
+Analogues of our $\epsilon$ -approximation definition have been formulated in the unsupervised setting, e.g.   
+in the setting of clustering data (Phillips, 2016; Jubran et al., 2019).
+
+Finally, note that the loss function $\ell$ used for comparing datasets does not have to coincide with any loss functions optimized in the learning algorithms $A$ and $\tilde { A }$ . Indeed, for kernel ridge-regression, training mimimizes mean square loss while $\ell$ can be 0-1 loss.
+
+# B TUNING KIP
+
+Sampling: When optimizing for KRR performance with support dataset size $N$ , it is best to learn a support set $\tilde { D }$ of size $N$ and sample this entire set during KIP training. It is our observation that subsets of size $M < N$ of $\tilde { D }$ will not perform as well as optimizing directly for a size $M$ dataset through KIP . Conversely, sampling subsets of size $M$ from a support dataset of size $N$ during KIP will not lead to a dataset that does as well as optimizing for all $N$ points. This is sensible: optimizing for small support size requires a resourceful learning of coarse features at the cost of learning fine-grained features from many support datapoints. Conversely, optimizing a large support set means the learned support set has leveraged higher-order information, which will degrade when restricted to smaller subsets.
+
+For sampling from the target set, which we always do in a class-balanced way, we found larger batch sizes typically perform better on the test set if the train and test kernels agree. If the train and test kernels differ, then smaller batch sizes lead to less overfitting to the train kernel.
+
+Initialization: We tried two sets of initializations. The first (“image init”) initializes $( X _ { s } , y _ { s } )$ to be a subset of $( X _ { t } , y _ { t } )$ . The second (“noise init”) initializes $X _ { s }$ with uniform noise and $y _ { s }$ with mean-centered, one-hot labels (in a class-balanced way). We found image initialization to perform better.
+
+egularization: The regularizais the number of datapoints in parameter . This mak $\lambda$ in (7) can be replaced with  the loss function invariant $\textstyle { \frac { 1 } { n } } \lambda \cdot \operatorname { t r } ( K _ { X _ { s } X _ { s } } )$ , wherescaling $n$ $X _ { s }$   
+of the kernel function $K$ and also normalizes the regularization with respect to support size. In practice, we use this scale-invariant regularization with $\lambda = 1 0 ^ { - 6 }$ .
+
+Number of Training Iterations: Remarkably, KIP converges very quickly in all experimental settings we tried. After only on the order of a hundred iterations, independently of the support size, kernel, and corruption factor, the learned support set has already undergone the majority of its learning (test accuracy is within more than $90 \%$ of the final test accuracy). For the platforms available to us, using a single V100 GPU, one hundred training steps for the experiments we ran involving target batch sizes that were a few thousand takes on the order of about 10 minutes. When we add augmentations to our targets, performance continues to improve slowly over time before flattening out after several thousands of iterations.
+
+# C THEORETICAL RESULTS
+
+Here, we analyze convergence properties of KIP in returning an $\epsilon$ -approximate dataset. In what follows, we refer to gradient-descent KIP as the case when we sample from the entire support and train datasets for each update step to KIP . We also assume that the distribution $\mathcal { P }$ used to evaluate $\epsilon$ -approximation is supported on inputs $x \in \mathbb { R } ^ { d }$ with $\| x \| \leq 1$ (merely to provide a convenient normalization when evaluating loss on regression algorithms).
+
+For the case of a linear kernel, we prove the below convergence theorem:
+
+Theorem 1. Let $D = ( X _ { t } , y _ { t } ) \in \mathbb { R } ^ { n _ { t } \times d } \times \mathbb { R } ^ { n _ { t } \times C }$ be an arbitrary dataset. Let $\boldsymbol { w } _ { \lambda } \in \mathbb { R } ^ { d \times C }$ be the coefficients obtained from training $\lambda$ ridge-regression ( $\lambda$ -RR) on $( X _ { t } , y _ { t } )$ , as given by (4).
+
+1. For generic6 initial conditions for the support set $( X _ { s } , y _ { s } ) \subset \mathbb { R } ^ { n _ { s } \times d } \times \mathbb { R } ^ { n _ { s } \times C }$ and sufficiently small $\lambda > 0$ , gradient descent KIP with target dataset $D$ converges to a dataset $\tilde { D }$ .
+
+2. The dataset $\tilde { D }$ is a strong -approximation to $D$ with respect to algorithms (λ-RR, 0-RR) and loss function equal to mean-square loss, where
+
+$$
+\epsilon \leq \frac { 1 } { 2 } \Vert \tilde { w } - w _ { 0 } \Vert _ { 2 } ^ { 2 }
+$$
+
+and $\tilde { w } \in \mathbb { R } ^ { d \times C }$ are the coefficients of the linear classifier obtained from training $\lambda$ -RR on $\tilde { D }$ . If the size of $\tilde { D }$ is at least $C$ , then $\tilde { w }$ is also a least squares classifier for $D$ . In particular, $i f D$ has a unique least squares classifier, then $\epsilon = 0$ .
+
+Proof. We discuss the case where $X _ { s }$ is optimized, with the case where both $( X _ { s } , y _ { s } )$ are optimized proceeding similarly. In this case, by genericity, we can assume $y _ { s } \neq 0$ , else the learning dynamics is trivial. Furthermore, to simplify notation for the time being, assume the dimensionality of the label space is $C = 1$ without loss of generality. First, we establish convergence. For a linear kernel, we can write our loss function as
+
+$$
+L ( X _ { s } ) = \frac 1 2 \| y _ { t } - X _ { t } X _ { s } ^ { T } ( X _ { s } X _ { s } ^ { T } + \lambda I ) ^ { - 1 } y _ { s } \| ^ { 2 } ,
+$$
+
+defined on the space $\mathbb { M } _ { n _ { s } \times d }$ of $n _ { s } \times d$ matrices. It is the pullback of the loss function
+
+$$
+L _ { \mathbb { R } ^ { d \times n _ { s } } } ( \Phi ) = \frac { 1 } { 2 } \| y _ { t } - X _ { t } \Phi y _ { s } \| ^ { 2 } , \qquad \Phi \in \mathbb { R } ^ { d \times n _ { s } }
+$$
+
+under the map $X _ { s } \mapsto \Phi _ { \lambda } ( X _ { s } ) = X _ { s } ^ { T } ( X _ { s } X _ { s } ^ { T } + \lambda I ) ^ { - 1 }$ . The function (A3) is quadratic in $\Phi$ and all its local minima are global minima given by an affine subspace $\mathcal { M } \subset \mathbb { M } _ { d \times n _ { s } }$ . Moreover, each point of $\mathcal { M }$ has a stable manifold of maximal dimension equal to the codimension of $\mathcal { M }$ . Thus, the functional $L$ has global minima given by the inverse image $\Phi _ { \lambda } ^ { - 1 } ( \mathcal { M } )$ (which will be nonempty for sufficiently small $\lambda$ ).
+
+Next, we claim that given a fixed initial $( X _ { s } , y _ { s } )$ , then for sufficiently small $\lambda$ , gradient-flow of (A2) starting from $( X _ { s } , y _ { s } )$ cannot converge to a non-global local minima. We proceed as follows. If $\boldsymbol { X } = \boldsymbol { \check { U } } \boldsymbol { \Sigma } \boldsymbol { V } ^ { T }$ is a singular value decomposition of $X$ , with $\Sigma$ a $n _ { s } \times n _ { s }$ diagional matrix of singular values (and any additional zeros for padding), then $\Phi ( X ) = V \phi ( \Sigma ) U ^ { T }$ where $\phi ( \Sigma )$ denotes the diagonal matrix with the map
+
+$$
+\begin{array} { c } { { \phi : \mathbb { R } ^ { \geq 0 }  \mathbb { R } ^ { \geq 0 } } } \\ { { \phi ( \mu ) = \frac { \mu } { \mu ^ { 2 } + \lambda } } } \end{array}
+$$
+
+applied to each singular value of $\Sigma$ . The singular value decomposition depends analytically on $X$ (Kato (1976)). Given that $\phi : \mathbb { R } ^ { \geq 0 }  \mathbb { R } ^ { \geq 0 }$ is a local diffeomorphism away from its maximum value at $\mu = \mu ^ { * } : = \lambda ^ { 1 / 2 }$ , it follows that $\Phi _ { \lambda } : \mathbb { M } _ { n _ { s } \times d }  \mathbb { M } _ { d \times n _ { s } }$ is locally surjective, i.e. for every $X$ , there exists a neighborhood $\mathcal { U }$ of $X$ such that $\Phi _ { \lambda } ( \mathcal { U } )$ contains a neighborhood of $\Phi _ { \lambda } ( X )$ . Thus, away from the locus of matrices in $\mathbb { M } _ { n _ { s } \times d }$ that have a singular value equaling $\mu ^ { * }$ , the function (A2) cannot have any non-global local minima, since the same would have to be true for (A3). We are left to consider those matrices with some singular values equaling $\mu ^ { * }$ . Note that as $\lambda  0$ , we have $\phi ( \mu ^ { * } ) \to \infty$ . On the other hand, for any initial choice of $X _ { s }$ , the matrices $\Phi _ { \lambda } ( X _ { s } )$ have uniformly bounded singular values as a function of $\lambda$ . Moreover, as $X _ { s } = X _ { s } ( t )$ evolves, $\| \Phi _ { \lambda } ( X _ { s } ( t ) ) \|$ never needs to be larger than some large constant times $\begin{array} { r l } { \| \Phi _ { \lambda } ( X _ { s } ( 0 ) ) \| + \frac { \| y _ { t } \| } { \mu ^ { + } \| y _ { s } \| } } \end{array}$ , where $\mu _ { + }$ is the smallest positive singular value of $X _ { t }$ . Consequently, $X _ { s } ( t )$ never visits a matrix with singular value $\mu ^ { * }$ for sufficiently small $\lambda > 0$ ; in particular, we never have to worry about convergence to a non-global local minimum.
+
+Thus, a generic gradient trajectory $\gamma$ of $L$ will be such that $\Phi _ { \lambda } \circ \gamma$ is a gradient-like7 trajectory for $L _ { \mathbb { R } ^ { d \times n _ { s } } }$ that converges to $\mathcal { M }$ . We have to show that $\gamma$ itself converges. It is convenient to extend $\phi$ to a map defined on the one-point compactification $[ 0 , \infty ] \supset \mathbb { R } ^ { \geq 0 }$ , so as to make $\phi$ a two-to-one map away from $\mu ^ { * }$ . Applying this compactification to every singular value, we obtain a compactification Mns×d of $\mathbb { M } ^ { n _ { s } \times d }$ , and we can naturally extend $\Phi _ { \lambda }$ to such a compactification. We have that $\gamma$ converges to an element of M˜ := Φ−1λ (M) ⊂ Mns×d, where we need the compactification to account for the fact that when $\Phi _ { \lambda } \circ \gamma$ converges to a matrix that has a zero singular value, $\gamma$ may have one of its singular values growing to infinity. Let $\mathcal { M } _ { 0 }$ denote the subset of $\mathcal { M }$ with a zero singular value. Then $\gamma$ converges to an element of $\quad \mathbb { M } ^ { n _ { s } \times d }$ precisely when $\gamma$ does not converge to an element of M˜ ∞ := Φ−1λ (M0) ∩ (Mns×d \ . However, $\mathcal { M } _ { 0 } \subset \mathcal { M }$ has codimension one and hence so does M˜ ∞ ⊂ Φ−1λ (M0). Thus, the stable set to M˜ ∞ has codimension one in Mns×d, and hence its complement is nongeneric. Hence, we have generic convergence of a gradient trajectory of $L$ to a (finite) solution. This establishes the convergence result of Part 1.
+
+For Part 2, the first statement is a general one: the difference of any two linear models, when evaluated on $\mathcal { P }$ , can be pointwise bounded by the spectral norm of the difference of the model coefficient matrices. Thus $\tilde { D }$ is a strong $\epsilon$ -approximation to $D$ with respect to ( $\lambda$ -RR, 0-RR) where $\epsilon$ is given by (A1). For the second statement, observe that $L$ is also the pullback of the loss function
+
+$$
+L _ { \mathbb { R } ^ { d \times c } } ( w ) = \frac { 1 } { 2 } \| y _ { t } - X _ { t } w \| ^ { 2 } , \qquad w \in \mathbb { R } ^ { d \times C } .
+$$
+
+under the map $X _ { s } \mapsto w ( X _ { s } ) = \Phi _ { \lambda } ( X _ { s } ) y _ { s }$ . The function $L _ { \mathbb { R } ^ { d \times C } } ( w )$ is quadratic in $w$ and has a unique minimum value, with the space of global minima being an affine subspace $W ^ { * }$ of $\mathbb { R } ^ { d }$ given by the least squares classifiers for the dataset $( X _ { t } , y _ { t } )$ . Thus, the global minima of $L$ are the preimage of $W ^ { * }$ under the map $w ( X _ { s } )$ . For generic initial $( X _ { s } , y _ { s } )$ , we have $y _ { s } \in \mathbb { R } ^ { n _ { s } \times C }$ is full rank. This implies, for $n _ { s } \geq C$ , that the range of all possible $w ( X _ { s } )$ for varying $X _ { s }$ is all of $\mathbb { R } ^ { d \times C }$ , so that the minima of (A6) and (A3) coincide. This implies the final parts of Part 2. □
+
+We also have the following result about $\epsilon$ -approximation using the label solve algorithm:
+
+Theorem 2. Let $D = ( X _ { t } , y _ { t } ) \in \mathbb { R } ^ { n _ { t } \times d } \times \mathbb { R } ^ { n _ { t } \times C }$ be an arbitrary dataset. Let $\boldsymbol { w } _ { \lambda } \in \mathbb { R } ^ { d \times C }$ be the coefficients obtained from training $\lambda$ ridge-regression $\scriptstyle ( \lambda - R R )$ on $( X _ { t } , y _ { t } )$ , as given by (4). Let $X _ { s } \in \bar { \mathbb { R } ^ { n _ { s } \times d } }$ be an arbitrary initial support set and let $\lambda \geq 0$ . Define $y _ { s } ^ { * } = y _ { s } ^ { * } ( \lambda )$ via (8).
+
+Then $\left( X _ { s } , y _ { s } ^ { * } \right)$ yields a strong $\epsilon ( \lambda )$ -approximation of $( X _ { t } , y _ { t } )$ with respect to algorithms ( $\lambda$ -RR, 0-RR) and mean-square loss, where
+
+$$
+\epsilon ( \lambda ) = \frac { 1 } { 2 } \| w ^ { * } ( \lambda ) - w _ { 0 } \| _ { 2 } ^ { 2 }
+$$
+
+and $w ^ { * } ( \lambda )$ is the solution to
+
+$$
+w ^ { * } ( \lambda ) = \mathrm { a r g m i n } _ { w \in W } \| y _ { t } - X _ { t } w \| ^ { 2 } , \quad \quad W = \mathrm { i m } \bigg ( \Phi _ { \lambda } ( X _ { s } ) : \ker \Big ( X _ { t } \Phi _ { \lambda } ( X _ { s } ) \Big ) ^ { \perp } \to \mathbb { R } ^ { d \times C } \bigg ) .
+$$
+
+Moreover, for $\lambda = 0$ , $i f \operatorname { r a n k } ( X _ { s } ) = \operatorname { r a n k } ( X _ { t } ) = d$ , then $w ^ { * } ( \lambda ) = w _ { 0 }$ . This implies $y _ { s } ^ { * } = X _ { s } w _ { 0 }$ , i.e. $y _ { s } ^ { * }$ coincides with the predictions of the 0-RR classifier trained on $( X _ { t } , y _ { t } )$ evaluated on $X _ { s }$ .
+
+Proof. By definition, $y _ { s } ^ { * }$ is the minimizer of
+
+$$
+L ( y _ { s } ) = \frac { 1 } { 2 } \| y _ { t } - X _ { t } \Phi _ { \lambda } ( X _ { s } ) y _ { s } \| ^ { 2 } ,
+$$
+
+with minimum norm. This implies $\boldsymbol { y } _ { s } ^ { * } \in \ker \left( X _ { t } \Phi _ { \lambda } ( X _ { s } ) \right) ^ { \perp }$ and that $w ^ { * } ( \lambda ) = \Phi _ { \lambda } ( X _ { s } ) y _ { s } ^ { * }$ satisfies (A8). At the same time, $w ^ { * } ( \lambda ) = \Phi _ { \lambda } ( X _ { s } ) y _ { s } ^ { * }$ are the coefficients of the $\lambda$ -RR classifier trained on $( X _ { s } , y _ { s } ^ { * } )$ . If $\mathrm { r a n k } ( X _ { s } ) = \mathrm { r a n k } ( X _ { t } ) = d$ , then $\Phi _ { 0 } ( X _ { s } )$ is surjective and $X _ { t }$ is injective, in which case
+
+$$
+\begin{array} { r l } & { \omega ^ { * } ( 0 ) = \Phi _ { 0 } ( X _ { s } ) y _ { s } ^ { * } } \\ & { \qquad = \Phi _ { 0 } ( X _ { s } ) \Phi _ { 0 } ( X _ { t } \Phi _ { 0 } ( X _ { s } ) ) y _ { t } } \\ & { \qquad = \Phi _ { 0 } ( X _ { s } ) X _ { s } \Phi _ { 0 } ( X _ { t } ) y _ { t } } \\ & { \qquad = \omega _ { 0 } . } \end{array}
+$$
+
+The results follow.
+
+For general kernels, we make the following simple observation concerning the optimal output of KIP .
+
+Theorem 3. Fix a target dataset $( X _ { t } , y _ { t } )$ . Consider the family of all subspaces $s$ of $\mathbb { R } ^ { n _ { t } }$ given by $\{ \mathrm { i m } K _ { X _ { t } X _ { s } } : X _ { s } \in \mathbb { R } ^ { \breve { n } _ { s } \times d } \}$ , i.e. all possible column spaces of $K _ { X , X _ { s } }$ . Then the infimum of the loss (7) over all possible $( X _ { s } , y _ { s } )$ is equal to $\mathrm { i n f } _ { S \in { \mathcal { S } } } \frac { 1 } { 2 } \| \Pi _ { S } ^ { \perp } y _ { t } \| ^ { 2 }$ where $\Pi _ { S } ^ { \perp }$ is orthogonal projection onto the orthogonal complement of $S$ (acting identically on each label component).
+
+Proof. Since $y _ { s }$ is trainable, $( K _ { X _ { s } X _ { s } } + \lambda ) ^ { - 1 } y _ { s }$ is an arbitrary vector in $\mathbb { R } ^ { n _ { s } \times C }$ . Thus, minimizing the training objective corresponds to maximizing the range of the linear map $K _ { X , X _ { s } }$ over all possible $X _ { s }$ . The result follows. □
+
+# D EXPERIMENT DETAILS
+
+In all KIP trainings, we used the Adam optimizer. All our labels are mean-centered 1-hot labels. We used learning rates 0.01 and 0.04 for the MNIST and CIFAR-10 datasets, respectively. When sampling target batches, we always do so in a class-balanced way. When augmenting data, we used the ImageGenerator class from Keras, which enables us to add horizontal flips, height/width shift, rotatations (up to 10 degrees), and channel shift (for CIFAR-10). All datasets are preprocessed using channel-wise standardization (i.e. mean subtraction and division by standard-deviation). For neural (tangent) kernels, we always use weight and bias variance $\sigma _ { w } ^ { 2 } = 2$ and $\sigma _ { b } ^ { 2 } = 1 0 ^ { - 4 }$ , respectively. For both neural kernels and neural networks, we always use ReLU activation. Convolutional layers all use a $( 3 , 3 )$ filter with stride 1 and same padding.
+
+Compute Limitations: Our neural kernel computations, implemented using Neural Tangents libraray (Novak et al., 2020) are such that computation scales (i) linearly with depth; (ii) quadratically in the number of pixels for convolutional kernels; (iii) quartically in the number of pixels for pooling layers. Such costs mean that, using a single V100 GPU with 16GB of RAM, we were (i) only able to sample shallow kernels; (ii) for convolutional kernels, limited to small support sets and small target batch sizes; (iii) unable to use pooling if learning more than just a few images. Scaling up KIP to deeper, more expensive architectures, achievable using multi-device training, will be the subject of future exploration.
+
+Kernel Parameterization: Neural tangent kernels, or more precisely each neural network layer of such kernels, as implemented in Novak et al. (2020) can be parameterized in either the “NTK” parameterization or “standard” parameterization Sohl-Dickstein et al. (2020). The latter depends on the width of a corresponding finite-width neural network while the former does not. Our experiments mix both these parameterizations for variety. However, because we use a scale-invariant regularization for KRR (Section B), the choice of parameterization has a limited effect compared to other more significant hyperparameters (e.g. the support dataset size, learning rate, etc.)8.
+
+Single kernel results: (Tables 1 and 2) For FC, we used kernels with NTK parametrization. For RBF, our rbf kernel is given by
+
+$$
+\mathrm { r b f } ( x _ { 1 } , x _ { 2 } ) = \exp ( - \gamma \| x _ { 1 } - x _ { 2 } \| ^ { 2 } / d )
+$$
+
+where $d$ is the dimension of the inputs and $\gamma = 1$ . We found that treating $\gamma$ as a learnable parameter during KIP had mixed results9 and so keep it fixed for simplicity.
+
+For MNIST, we found target batch size equal to 6K sufficient. For CIFAR-10, it helped to sample the entire training dataset of 50K images per step (hence, along with sampling the full support set, we are doing full gradient descent training). When support dataset size is small or if augmentations are employed, there is no overfitting (i.e. the train and test loss/accuracy stay positively correlated). If the support dataset size is large (5K or larger), sometimes there is overfitting when the target batch size is too large (e.g. for the RBF kernel on CIFAR10, which is why we exclude in Table 2 the entries for 5K and 10K). We could have used a validation dataset for a stopping criterion, but that would have required reducing the target dataset from the entire training dataset.
+
+We train KIP for 10-20k iterations and took 5 random subsets of images for initializations. For each such training, we took 5 checkpoints with lowest train and loss and computed the test accuracy. This gives 25 evaluations, for which we can compute the mean and standard deviation for our test accuracy numbers in Tables 1 and 2.
+
+Kernel transfer results: For transfering of KIP images, both to other kernels and to neural networks, we found it useful to use smaller target batch sizes (either several hundred or several thousand), else the images overfit to their source kernel. For random sampling of kernels used in Figure A1 and producing datasets for training of neural networks, we used FC kernels with width 1024 and Conv kernels with width 128, all with standard parametrization.
+
+Neural network results: Neural network trainings on natural data with mean-square loss use meancentered one-hot labels for consistency with KIP trainings. For cross entropy loss, we use one-hot labels. For neural network trainings on KIP -learned images with label learning, we transfer over the labels directly (as with the images), whatever they may be.
+
+For neural network transfer experiments occurring in Table 1, Table 2, Figure 3, Table A5, and Table A6, we did the following. First, the images were learned using kernels FC1-3, Conv1-2. Second, we trained for a few hundred iterations, after which optimal test performance was achieved. On MNIST images, we trained the networks with constant learning rate and Adam optimizer with cross entropy loss. Learning rate was tuned over small grid search space. For the FC kernels and networks, we use width of 1024. On CIFAR-10 images, we trained the networks with constant learning rate, momentum optimizer with momentum 0.9. Learning rate, L2 regularization, parameterization (standard vs NTK) and loss type (mean square, softmax-cross-entropy) was tuned over small grid search space. Vanilla networks use constant width at each layer: for FC we use width of 1024, for Conv2 we use 512 channels, and for Conv8 we use 128 channels. No pooling layers are used except for the WideResNet architecture, where we follow the original architecture of Zagoruyko & Komodakis (2016) except that our batch normalization layer is stateless (i.e. no exponential moving average of batch statistics are recorded).
+
+For neural network transfer experiments in Figure A3, Tables A7-A10, we did the following. Our KIP -learned images were trained using only an FC1 kernel. The neural network FC1 has an increased width 4096, which helps with the larger number of images. We used learning rate $4 \times 1 0 ^ { - 4 }$ and the Adam optimizer. The KIP learned images with only augmentations used target batch size equal to half the training dataset size and were trained for 10k iterations, since the use of augmentations allows for continued gains after longer training. The KIP learned images with augmentations and label learning used target batch size equal to a tenth of the training dataset size and were trained for 2k iterations (the learned data were observed to overfit to the kernel and have less transferability if larger batch size were used or if trainings were carried out longer).
+
+Table A1: Accuracy on random subsets of MNIST. Standard deviations over 20 resamplings.   
+
+<table><tr><td># Images \Kernel</td><td>Linear</td><td>RBF</td><td>FC1</td></tr><tr><td>10</td><td>44.6±3.7</td><td>45.3±3.9</td><td>45.8±3.9</td></tr><tr><td>20</td><td>51.9±3.1</td><td>54.6±2.9</td><td>54.7±2.8</td></tr><tr><td>40</td><td>59.4±2.4</td><td>66.9±2.0</td><td>66.0±1.9</td></tr><tr><td>80</td><td>62.6±2.7</td><td>75.6±1.6</td><td>74.3±1.7</td></tr><tr><td>160</td><td>62.2±2.1</td><td>82.7±1.4</td><td>81.1±1.6</td></tr><tr><td>320</td><td>52.3±1.9</td><td>88.1±0.8</td><td>86.9±0.9</td></tr><tr><td>640</td><td>41.9±1.4</td><td>91.8±0.5</td><td>91.1±0.5</td></tr><tr><td>1280</td><td>71.0±0.9</td><td>94.2±0.3</td><td>93.6±0.3</td></tr><tr><td>2560</td><td>79.7±0.5</td><td>95.7±0.2</td><td>95.3±0.2</td></tr><tr><td>5000</td><td>83.2±0.4</td><td>96.8±0.2</td><td>96.4±0.2</td></tr><tr><td>10000</td><td>84.9±0.4</td><td>97.5±0.2</td><td>97.2±0.2</td></tr></table>
+
+All neural network trainings were run with 5 random initializations to compute mean and standard deviation of test accuracies.
+
+In Table 2, regularized ZCA preprocessing was used for a Myrtle-10 kernel (denoted with ZCA) on CIFAR-10 dataset. Shankar et al. (2020) and Lee et al. (2020) noticed that for neural (convolutional) kernels on image classification tasks, regularized ZCA preprocessing can improve performance significantly compared to standard preprocessing. We follow the prepossessing scheme used in Shankar et al. (2020), with regularization strength of $\bar { 1 } 0 ^ { - 5 }$ without augmentation.
+
+# E TABLES AND FIGURES
+
+# E.1 KERNEL BASELINES
+
+We report various baselines of KRR trained on natural images. Tables A1 and A2 shows how various kernels vary in performance with respect to random subsets of MNIST and CIFAR-10. Linear denotes a linear kernel, RBF denotes the rbf kernel (A9) with $\gamma = 1$ , and FC1 uses standard parametrization and width 1024. Interestingly enough, we observe non-monotonicity for the linear kernel, owing to double descent phenomenon Hastie et al. (2019). We include additional columns for deeper kernel architectures in Table A2, taken from Shankar et al. (2020) for reference.
+
+Comparing Tables 1, 2 with Tables A1, A2, we see that 10 KIP -learned images, for both RBF and FC1, has comparable performance to several thousand natural images, thereby achieving a compression ratio of over 100. This compression ratio narrows as the support size increases towards the size of the training data.
+
+Next, Table A3 compares FC1, RBF, and other kernels trained on all of MNIST to FC1 and RBF trained on KIP -learned images. We see that our KIP approach, even with 10K images (which fits into memory), leads to RBF and FC1 matching the performance of convolutional kernels on the original 60K images. Table A4 shows state of the art of FC kernels on CIFAR-10. The prior state of the art used kernel ensembling on batches of augmented data in Lee et al. (2020) to obtain test accuracy of $6 1 . 5 \%$ (32 ensembles each of size 45K images). By distilling augmented images using KIP , we are able to obtain $6 4 . 7 \%$ test accuracy using only 10K images.
+
+# E.2 KIP AND LS TRANSFER ACROSS KERNELS
+
+Figure A1 plots how KIP (with only images learned) performs across kernels. There are seven training scenarios: training individually on FC1, FC2, FC3, Conv1, Conv2, Conv3 NTK kernels and random sampling from among all six kernels uniformly (Avg All). Datasets of size 10, 100, 200 are thereby trained then evaluated by averaging over all of FC1-3, Conv1-3, both with the NTK and NNGP kernels for good measure. Moreover, the FC and Conv train kernel widths (1024 and 128) were swapped at test time (FC width 128 and Conv width 1024), as an additional test of robustness. The average performance is recorded along the y-axis. AvgAll leads to overall boost in performance across kernels. Another observation is that Conv kernels alone tend to do a bit better, averaged over the kernels considered, than FC kernels alone.
+
+Table A2: Accuracy on random subsets of CIFAR-10. Standard deviations over 20 resamplings.   
+
+<table><tr><td># Images\Kernel</td><td>Linear</td><td>RBF</td><td>FC1</td><td>CNTK†</td><td>Myrtle10-G‡</td></tr><tr><td>10</td><td>16.2±1.3</td><td>15.7±2.1</td><td>16.4±1.8</td><td>15.33 ± 2.43</td><td>19.15 ± 1.94</td></tr><tr><td>20</td><td>17.1±1.6</td><td>17.1±1.7</td><td>18.0±1.9</td><td>18.79 ± 2.13</td><td>21.65 ± 2.97</td></tr><tr><td>40</td><td>17.8±1.6</td><td>19.7±1.8</td><td>20.6±1.8</td><td>21.34 ± 1.91</td><td>27.20 ± 1.90</td></tr><tr><td>80</td><td>18.6±1.5</td><td>23.0±1.5</td><td>23.9±1.6</td><td>25.48 ± 1.91</td><td>34.22 ± 1.08</td></tr><tr><td>160</td><td>18.5±1.4</td><td>25.8±1.4</td><td>26.5±1.4</td><td>30.48 ± 1.17</td><td>41.89 ± 1.34</td></tr><tr><td>320</td><td>18.1±1.1</td><td>29.2±1.2</td><td>29.9±1.1</td><td>36.57 ± 0.88</td><td>50.06 ± 1.06</td></tr><tr><td>640</td><td>16.8±0.8</td><td>32.8±0.9</td><td>33.4±0.8</td><td>42.63 ± 0.68</td><td>57.60 ± 0.48</td></tr><tr><td>1280</td><td>15.1±0.5</td><td>35.9±0.7</td><td>36.7±0.6</td><td>48.86 ± 0.68</td><td>64.40 ± 0.48</td></tr><tr><td>2560</td><td>13.0±0.5</td><td>39.1±0.7</td><td>40.2±0.7</td><td></td><td></td></tr><tr><td>5000</td><td>17.8±0.4</td><td>42.1±0.5</td><td>43.7±0.6</td><td></td><td></td></tr><tr><td>10000</td><td>24.9±0.6</td><td>45.3±0.6</td><td>47.7±0.6</td><td></td><td></td></tr></table>
+
+† Conv14 kernel with global average pooling (Arora et al., 2019b) ‡ Myrtle10-Gaussian kernel (Shankar et al., 2020)
+
+Table A3: Classification performance on MNIST. Our KIP -datasets, fit to FC1 or RBF kernels, outperform non-convolutional kernels trained on all training images.   
+
+<table><tr><td>Kernel</td><td>Method</td><td>Accuracy</td></tr><tr><td>FC1</td><td>Base1</td><td>98.6</td></tr><tr><td>ArcCosine Kernel²</td><td>Base</td><td>98.8</td></tr><tr><td>Gaussian Kernel</td><td>Base</td><td>98.8</td></tr><tr><td>FC1</td><td>KIP (a+l) 10K images</td><td>99.2</td></tr><tr><td>LeNet-5 (LeCun et al., 1998)</td><td>Base</td><td>99.2</td></tr><tr><td>RBF</td><td>KIP (a+l), 10K images</td><td>99.3</td></tr><tr><td>Myrtle5 Kernel (Shankar et al., 2020)</td><td>Base</td><td>99.5</td></tr><tr><td>CKN (Mairal et al., 2014)</td><td>Base</td><td>99.6</td></tr></table>
+
+1 Base refers to training on entire training dataset of natural images. 2 Non RBF/FC numbers taken from (Shankar et al., 2020) 3 $\left( \mathrm { a } + \mathrm { l } \right)$ denotes KIP with augmentations and label learning during training.
+
+![](images/ed4400f4516a76df34a490e8a82d3d93712d84f1afc844b2c8830d48031258cc.jpg)  
+Figure A1: Studying transfer between kernels.
+
+Table A4: CIFAR-10 test accuracy for FC/RBF kernels. Our KIP -datasets, fit to RBF/FC1, outperform baselines with many more images. Notation same as in Table A3.   
+
+<table><tr><td>Kernel</td><td>Method</td><td>Accuracy</td></tr><tr><td>FC1</td><td>Base</td><td>57.6</td></tr><tr><td>FC3</td><td>Ensembling (Lee et al., 2020)</td><td>61.5</td></tr><tr><td>FC1</td><td>KIP (a+l), 10k images</td><td>64.7</td></tr><tr><td>RBF</td><td>Base</td><td>52.7</td></tr><tr><td>RBF</td><td>KIP (a+l),10k images</td><td>66.3</td></tr></table>
+
+![](images/5c6196c177899204603b1f29a685f41c65a721925a37b4317ce2667191781fec.jpg)  
+Figure A2: Label Solve transfer between Myrtle-10 and FC for CIFAR10. Top row: LS labels using Myrtle-10 applied to FC1. Bottom row: LS labels using FC1 applied to Myrtle-10. Results averaged over 3 samples per support set size. In all these plots, NNGP kernels were used and Myrtle-10 used regularized ZCA preprocessing.
+
+In Figure A2, we plot how LS learned labels using Myrtle-10 kernel transfer to the FC1 kernel and vice versa. We vary the number of targets and support size. We find remarkable stability across all these dimensions in the sense that while the gains from LS may be kernel-specific, LS -labels do not perform meaningfully different from natural labels when switching the train and evaluation kernels.
+
+# E.3 KIP TRANSFER TO NEURAL NETWORKS AND CORRUPTION EXPERIMENTS
+
+Table A5: KIP transfer to NN vs NN baselines on MNIST. For each group of four experiments, the best number is marked boldface, while the second best number is in italics. Corruption refers to $9 0 \%$ noise corruption. KIP images used FC1-3, Conv1-2 kernel during training.   
+
+<table><tr><td>Method</td><td>10 uncrpt</td><td>10 crpt</td><td>100 uncrpt</td><td>100 crpt</td><td>200 uncrpt</td><td>200 crpt</td></tr><tr><td>FC1, KIP</td><td>73.57±1.51</td><td>44.95±1.23</td><td>86.84±1.65</td><td>79.73±1.10</td><td>89.55±0.94</td><td>83.38±1.37</td></tr><tr><td>FC1, Natural</td><td>42.28±1.59</td><td>35.00±2.33</td><td>72.65±1.17</td><td>45.39±2.25</td><td>81.70±1.03</td><td>54.20±2.61</td></tr><tr><td>LeNet,KIP</td><td>59.69±8.98</td><td>38.25±6.42</td><td>87.85±1.46</td><td>69.45±3.99</td><td>91.08±1.65</td><td>70.52±4.39</td></tr><tr><td>LeNet, Natural</td><td>48.69±4.10</td><td>30.56±4.35</td><td>80.32±1.26</td><td>59.99±0.95</td><td>89.03±1.13</td><td>62.00±0.94</td></tr></table>
+
+Table A6: KIP transfer to NN vs NN baselines on CIFAR-10. Notation same as in Table A5.   
+
+<table><tr><td>Method</td><td>100 uncrpt</td><td>100 crpt</td></tr><tr><td>FC3,KIP</td><td>43.09±0.20</td><td>37.71±0.38</td></tr><tr><td>FC3, Natural</td><td>24.48±0.15</td><td>18.92±0.61</td></tr><tr><td>Conv2,KIP</td><td>43.68±0.46</td><td>37.08±0.48</td></tr><tr><td>Conv2, Natural</td><td>26.23 ±0.69</td><td>17.10±1.33</td></tr><tr><td>WideResNet,KIP</td><td>33.29±1.14</td><td>23.89±1.30</td></tr><tr><td>WideResNet, Natural</td><td>27.93±0.75</td><td>19.00±1.01</td></tr></table>
+
+Table A7: MNIST. KIP and natural images on FC1. MSE Loss. Test accuracy of image datasets of size 1K, 5K, 10K, trained using FC1 neural network using mean-square loss. Dataset size, noise corruption percent, and dataset type are varied: natural refers to natural images, KIP refers to KIP - learned images with either augmentations only (a) or both augmentations with label learning $\left( \mathsf { a } + \mathsf { l } \right)$ . Only FC1 kernel was used for KIP . For each KIP row, we place a \* next to the most corrupt entry whose performance exceeds the corresponding $0 \%$ corrupt natural images. For each dataset size, we boldface the best performing entry.   
+
+<table><tr><td>Dataset</td><td>0% crpt</td><td>50% crpt</td><td>75% crpt</td><td>90% crpt</td></tr><tr><td>Natural 1000</td><td>92.8±0.4</td><td>87.3±0.5</td><td>82.3±0.9</td><td>74.3±1.4</td></tr><tr><td>KIP (a) 1000</td><td>94.5±0.4</td><td>95.9±0.1</td><td>94.4±0.2*</td><td>92.0±0.3</td></tr><tr><td>KIP (a+l) 1000</td><td>96.3±0.2</td><td>95.9±0.3</td><td>95.1±0.3</td><td>94.6±1.9*</td></tr><tr><td>Natural 5000</td><td>96.4±0.1</td><td>92.8±0.2</td><td>88.5±0.5</td><td>80.0±0.9</td></tr><tr><td>KIP (a) 5000</td><td>97.0±0.6</td><td>97.1±0.6</td><td>96.3±0.2</td><td>96.6±0.4*</td></tr><tr><td>KIP (a+l) 5000</td><td>97.6±0.0*</td><td>95.8±0.0</td><td>94.5±0.4</td><td>91.4±2.3</td></tr><tr><td>Natural 10000</td><td>97.3±0.1</td><td>93.9±0.1</td><td>90.2±0.1</td><td>81.3±1.0</td></tr><tr><td>KIP (a) 10000</td><td>97.8±0.1*</td><td>96.1±0.2</td><td>95.8±0.2</td><td>96.0±0.2</td></tr><tr><td>KIP (a+l) 10000</td><td>97.9±0.1*</td><td>95.8±0.1</td><td>94.7±0.2</td><td>88.1±3.5</td></tr></table>
+
+Table A8: MNIST. KIP and natural images on FC1. Cross Entropy Loss. Test accuracy of image datasets trained using FC1 neural network using cross entropy loss. Notation same as in Table A7.   
+
+<table><tr><td>Dataset</td><td>0% crpt</td><td>50% crpt</td><td>75% crpt</td><td>90% crpt</td></tr><tr><td>Natural 1000</td><td>91.3±0.4</td><td>86.3±0.3</td><td>81.9±0.5</td><td>75.0±1.3</td></tr><tr><td>KIP (a) 1000</td><td>95.9±0.1</td><td>95.0±0.1</td><td>93.5±0.3*</td><td>90.9±0.3</td></tr><tr><td>Natural 5000</td><td>95.8±0.1</td><td>91.9±0.2</td><td>87.3±0.3</td><td>80.4±0.5</td></tr><tr><td>KIP (a) 5000</td><td>98.3±0.0</td><td>96.8±0.8*</td><td>95.5±0.3</td><td>95.1±0.2</td></tr><tr><td>Natural 10000</td><td>96.9±0.1</td><td>93.8±0.1</td><td>89.6±0.2</td><td>81.3±0.5</td></tr><tr><td>KIP (a) 10000</td><td>98.8±0.0</td><td>97.0±0.0*</td><td>95.2±0.2</td><td>94.7±0.3</td></tr></table>
+
+Table A9: CIFAR-10. KIP and natural images on FC1. MSE Loss. Test accuracy of image datasets trained using FC1 neural network using mean-square loss. Notation same as in Table A7.   
+
+<table><tr><td>Dataset</td><td>0% crpt</td><td>50% crpt</td><td>75% crpt</td><td>90% crpt</td></tr><tr><td>Natural 1000</td><td>34.1±0.5</td><td>34.3±0.4</td><td>31.7±0.5</td><td>27.7±0.8</td></tr><tr><td>KIP (a)1000</td><td>48.0±0.5</td><td>46.7±0.2</td><td>45.7±0.5</td><td>44.3±0.5*</td></tr><tr><td>KIP (a+l) 1000</td><td>47.5±0.3</td><td>46.7±0.8</td><td>44.3±0.4</td><td>41.6±0.5*</td></tr><tr><td>Natural 5000</td><td>41.4±0.6</td><td>41.3±0.4</td><td>37.2±0.2</td><td>32.5±0.7</td></tr><tr><td>KIP (a) 5000</td><td>51.4±0.4</td><td>50.0±0.4</td><td>48.8±0.6</td><td>47.5±0.3*</td></tr><tr><td>KIP ( (a+l) 5000</td><td>50.6±0.5</td><td>48.5±0.9</td><td>44.7±0.6</td><td>43.4±0.5*</td></tr><tr><td>Natural 10000</td><td>44.5±0.3</td><td>43.2±0.2</td><td>39.5±0.2</td><td>34.3±0.2</td></tr><tr><td>KIP(a) 10000</td><td>53.3±0.8</td><td>50.5±1.3</td><td>49.4±0.2</td><td>48.2±0.6*</td></tr><tr><td>KIP (a+l) 10000</td><td>51.9±0.4</td><td>50.0±0.5</td><td>46.5±1.0</td><td>43.8±1.3*</td></tr></table>
+
+Table A10: CIFAR-10. KIP and natural images on FC1. Cross Entropy Loss. Test accuracy of image datasets trained using FC1 neural network using cross entropy loss. Notation same as in Table A7.   
+
+<table><tr><td>Dataset</td><td>0% crpt</td><td>50% crpt</td><td>75% crpt</td><td>90% crpt</td></tr><tr><td>Natural 1000</td><td>35.4±0.3</td><td>35.4±0.3</td><td>31.7±0.9</td><td>27.2±0.8</td></tr><tr><td>KIP (a) 1000</td><td>49.2±0.8</td><td>47.6±0.4</td><td>47.4±0.4</td><td>45.0±0.3*</td></tr><tr><td>Natural 5000</td><td>43.1±0.8</td><td>42.0±0.2</td><td>38.0±0.4</td><td>31.7±0.6</td></tr><tr><td>KIP (a) 5000</td><td>44.5±1.0</td><td>51.5±0.3</td><td>51.0±0.4</td><td>48.9±0.4*</td></tr><tr><td>Natural 10000</td><td>45.3±0.2</td><td>44.8±0.1</td><td>40.6±0.3</td><td>33.8±0.2</td></tr><tr><td>KIP (a) 10000</td><td>46.9±0.4</td><td>54.0±0.3</td><td>52.1±0.3</td><td>49.9±0.2*</td></tr></table>
+
+![](images/69c46a007b4a0b768eb7f1a12871486f25d4adf1c8faf8fec59af38338c79880.jpg)  
+MNIST. KIP vs Natural Images (MSE Loss)   
+MNIST. KIP vs Natural Images (XENT Loss)   
+Figure A3: KIP vs natural images, FC1. Data plotted from Tables A7-A10, showing natural images vs. KIP images for FC1 neural networks across dataset size, corruption type, dataset type, and loss type. For instance, the upper right figure shows that on MNIST using cross entropy loss, 1k $\mathrm { K I P + }$ aug learned images with $90 \%$ corruption achieves $9 0 . 9 \%$ test accuracy, comparable to $1 \mathrm { k }$ natural images (acc: $9 1 . 3 \%$ and far exceeding 1k natural images with $90 \%$ corruption (acc: $7 5 . 0 \%$ ). Similarly, the lower right figure shows on CIFAR10 using cross entropy loss, 1 ${ 0 \mathrm { k } \mathrm { K I P + } }$ aug learned images with $90 \%$ corruption achieves $4 9 . 9 \%$ , exceeding $1 0 \mathrm { k }$ natural images (acc: $4 5 . 3 \%$ ) and 10k natural images with $90 \%$ corruption (acc: $3 3 . 8 \%$ ).
+
+![](images/11adf80f2460cd07f4fc9e0f65eb174744358c3ae0a9f42316f2f93a9dd73b4a.jpg)  
+Figure A4: KIP learned images (left) vs natural MNIST images (right). Samples from 100 learned images. Top row: $0 \%$ corruption. Bottom row: $90 \%$ noise corruption.
+
+![](images/4fa928d326d90dd0d063be8be0c696d1567992fcdb9a579df72f4b481a555e8b.jpg)  
+Figure A5: KIP learned images (left) vs natural CIFAR-10 images (right). Samples from 100 learned images. Top row: $0 \%$ corruption. Bottom row: $90 \%$ noise corruption.

parse/train/nVZtXBI6LNn/nVZtXBI6LNn.md

@@ -0,0 +1,369 @@
+# FAST AND COMPLETE: ENABLING COMPLETE NEURAL NETWORK VERIFICATION WITH RAPID AND MASSIVELY PARALLEL INCOMPLETE VERIFIERS
+
+Kaidi Xu\*,1 Huan Zhang\*,2 Shiqi Wang3 Yihan Wang2   
+Suman Jana3 Xue Lin1 Cho-Jui Hsieh2
+
+1Northeastern University 2UCLA 3Columbia University
+
+xu.kaid@northeastern.edu, huan@huan-zhang.com, tcwangshiqi@cs.columbia.edu, wangyihan617@gmail.com, suman@cs.columbia.edu, xue.lin@northeastern.edu, chohsieh@cs.ucla.edu
+
+# ABSTRACT
+
+Formal verification of neural networks (NNs) is a challenging and important problem. Existing efficient complete solvers typically require the branch-and-bound (BaB) process, which splits the problem domain into sub-domains and solves each sub-domain using faster but weaker incomplete verifiers, such as Linear Programming (LP) on linearly relaxed sub-domains. In this paper, we propose to use the backward mode linear relaxation based perturbation analysis (LiRPA) to replace LP during the BaB process, which can be efficiently implemented on the typical machine learning accelerators such as GPUs and TPUs. However, unlike LP, LiRPA when applied naively can produce much weaker bounds and even cannot check certain conflicts of sub-domains during splitting, making the entire procedure incomplete after BaB. To address these challenges, we apply a fast gradient based bound tightening procedure combined with batch splits and the design of minimal usage of LP bound procedure, enabling us to effectively use LiRPA on the accelerator hardware for the challenging complete NN verification problem and significantly outperform LP-based approaches. On a single GPU, we demonstrate an order of magnitude speedup compared to existing LP-based approaches.
+
+# 1 INTRODUCTION
+
+Although neural networks (NNs) have achieved great success on various complicated tasks, they remain susceptible to adversarial examples (Szegedy et al., 2013): imperceptible perturbations of test samples might unexpectedly change the NN predictions. Therefore, it is crucial to conduct formal verification for NNs such that they can be adopted in safety or security-critical settings.
+
+Formally, the neural network verification problem can be cast into the following decision problem:
+
+Given a neural network $f ( \cdot )$ , an input domain $\mathcal { C }$ , and a property $\mathcal { P }$ $\forall x \in { \mathcal { C } }$ , does $f ( x )$ satisfy $\mathcal { P }$ ?
+
+The property $\mathcal { P }$ is typically a set of desirable outputs of the NN conditioned on the inputs. Typically, consider a binary classifier $f ( x )$ and a positive example $x _ { 0 }$ $( f ( x _ { 0 } ) \geq 0 )$ , we can set $\mathcal { P }$ to be nonnegative numbers $\mathbb { R } ^ { + }$ and $x$ is bounded within an $l _ { \infty }$ norm ball $\mathcal { C } = \{ \boldsymbol { x } | \| \boldsymbol { x } - \boldsymbol { x } _ { 0 } \| _ { \infty } \le \epsilon \}$ . The success of verification guarantees that the label of $x _ { 0 }$ cannot flip for any perturbed inputs within $\mathcal { C }$ .
+
+In this paper we study the complete verification setting, where given sufficient time, the verifier should give a definite “yes/no” answer for a property under verification. In the above setting, it must solve the non-convex optimization problem $\operatorname* { m i n } { } _ { x \in { \mathcal { C } } }$ $f ( x )$ to a global minimum. Complete NN verification is generally a challenging NP-Hard problem (Katz et al., 2017) which usually requires expensive formal verification methods such as SMT (Katz et al., 2017) or MILP solvers (Tjeng et al., 2019b). On the other hand, incomplete solvers such as convex relaxations of NNs (Salman et al., 2019) can only provide a sound analysis, i.e., they can only approximate the lower bound of $\mathrm { m i n } _ { x _ { \in } { \mathcal { C } } } f ( x )$ as $\underline { { f } }$ and verify the property when $\underline { { f } } \geq 0$ . No conclusion can be drawn when $\underline { { f } } < 0$ .
+
+Recently, a Branch and Bound (BaB) style framework (Bunel et al., 2018; 2020b) has been adopted for efficient complete verification. BaB solves the optimization problem $\operatorname* { m i n } _ { x \in { \mathcal { C } } } f ( x )$ to a global minimum by branching into multiple sub-domains recursively and bounding the solution for each sub-domain using incomplete verifiers. BaB typically uses a Linear Programming (LP) bounding procedure as an incomplete verifier to provide feasibility checking and relatively tight bounds for each sub-domain. However, the relatively high solving cost of LPs and incapability of parallelization (especially on massively parallel hardware accelerators like GPUs or TPUs) greatly limit the performance and scalability of the existing complete BaB based verifiers.
+
+In this paper, we aim to use fast and typically weak incomplete verifiers for complete verification. Specifically, we focus on a class of incomplete verifiers using efficient bound propagation operations, referred to as linear relaxation based perturbation analysis (LiRPA) algorithms (Xu et al., 2020). Representative algorithms in this class include convex outer adversarial polytope (Wong & Kolter, 2018), CROWN (Zhang et al., 2018) and DeepPoly (Singh et al., 2019b). LiRPA algorithms exhibit high parallelism as the bound propagation process is similar to forward or backward propagation of NNs, which can fully exploit machine learning accelerators (e.g., GPUs and TPUs).
+
+Although LiRPA bounds are very efficient for incomplete verification, especially in training certified adversarial defenses (Wong et al., 2018; Mirman et al., 2018; Wang et al., 2018a; Zhang et al., 2020), they are generally considered too loose to be useful compared to LPs in the complete verification settings with BaB. As we will demonstrate later, using LiRPA bounds naively in BaB cannot even guarantee the completeness when splitting ReLU nodes, and thus we need additional measures to make them useful for complete verification. In fact, LiRPA methods have been used to get upper and lower bounds for each ReLU neuron in constructing tighter LPs (Bunel et al., 2018; Lu & Kumar, 2020). It was also used in (Wang et al., 2018c) for verifying small-scale problems with relatively low dimensional input domains using input splits, but splitting the input space can be quite ineffective (Bunel et al., 2018) and is unable to scale to high dimensional input case like CIFAR-10. Except one concurrent work (Bunel et al., 2020a), most complete verifiers are based on relatively expensive solvers like LP and cannot fully take benefit from massively parallel hardware (e.g., GPUs) to obtain tight bounds for accelerating large-scale complete verification problems. Our main contributions are:
+
+• We show that LiRPA bounds, when improved with fast gradient optimizers, can potentially outperform bounds obtained by LP verifiers. This is because LiRPA allows joint optimization of both intermediate layer bounds of ReLU neurons (which determine the tightness of relaxation) and output bounds, while LP can only optimize output bounds with fixed relaxations on ReLU neurons.
+
+• We show that BaB purely using LiRPA bounds is insufficient for complete verification due to the lack of feasibility checking for ReLU node splits. To address this issue, we design our algorithm to only invoke LP when absolutely necessary and exploits hardware parallelism when possible.
+
+• To fully exploit the hardware parallelism on the machine learning accelerators, we use a batch splitting approach that splits on multiple neurons simultaneously, further improving our efficiency.
+
+• On a few standard and representative benchmarks, our proposed NN verification framework can outperform previous baselines significantly, with a speedup of around 30X compared to basic $_ \mathrm { B a B + L P }$ baselines, and up to 3X compared to recent state-of-the-art complete verifiers.
+
+# 2 BACKGROUND
+
+# 2.1 FORMAL DEFINITION OF NEURAL NETWORK (NN) VERIFICATION
+
+Notations of NN. For illustration, we define an $L$ -layer feedforward NN $f : \mathbb { R } ^ { | x | }  \mathbb { R }$ with $L$ weights $\mathbf { W } ^ { ( i ) }$ $( i \in \{ 1 , \cdots , L \} )$ recursively as $h ^ { ( i ) } ( x ) { \bf \bar { \Psi } } = { \bf W } ^ { ( i ) } g ^ { ( i - 1 ) } ( x )$ , hidden layer $g ^ { ( i ) } ( x ) =$ $\mathtt { R e L U } ( h ^ { ( i ) } ( x ) )$ , input layer $g ^ { ( 0 ) } ( x ) = x$ , and final output $f ( x ) = h ^ { ( L ) } ( x )$ . For simplicity we ignore biases. We sometimes omit $x$ and use $h _ { j } ^ { ( i ) }$ to represent the pre-activation of the $j$ -th ReLU neuron in $i$ -th layer for $x \in { \mathcal { C } }$ , and we use $g _ { j } ^ { ( i ) }$ to represent the post-activation value. We focus on verifying ReLU based NNs, but our method is generalizable to other activation functions supported by LiRPA.
+
+NN Verification Problem. Given an input $x$ , its bounded input domain $\mathcal { C }$ , and a feedforward NN $f ( \cdot )$ , the aim of formal verification is to prove or disprove certain properties $\mathcal { P }$ of NN outputs. Since most properties studied in previous works can be expressed as a Boolean expression over a linear equation of network output, where the linear property can be merged into the last layer weights of a NN, the ultimate goal of complete verification reduces to prove or disprove:
+
+$$
+\forall x \in \mathcal { C } , f ( x ) \geq 0
+$$
+
+One way to prove Eq. 1 is to solve $\scriptstyle \operatorname* { m i n } _ { x \in { \mathcal { C } } } f ( x )$ . Due to the non-convexity of NNs, finding the exact minimum of $f ( x )$ over $x \in { \mathcal { C } }$ is challenging as the optimization process is generally NPcomplete (Katz et al., 2017). However, in practice, a sound approximation of the lower bound for $f ( x )$ , denoted as $f$ , can be more easily obtained and is sufficient to verify the property. Thus, a good verification strategy to get a tight approximation $\underline { { f } }$ can save significant time cost. Note that $\underline { { f } }$ must be sound, i.e., $\forall x \in \mathcal { C } , \underline { { f } } \leq f ( x )$ , proving $\underline { { f } } \geq 0$ is sufficient to prove the property $f ( x ) \geq 0$ .
+
+2.2 THE BRANCH AND BOUND (BAB) FRAMEWORK FOR NEURAL NETWORK VERIFICATION
+
+Branch and Bound (BaB), an effective strategy in solving traditional combinatorial optimization problems, has been customized and widely adopted for NN verification (Bunel et al., 2018; 2020b). Specifically, BaB based verification framework is a recursive process, consisting of two main steps: branching and bounding. For branching, BaB based methods will divide the bounded input domain $\mathcal { C }$ into sub-domains $\{ \bar { \mathcal { C } } _ { i } \vert \mathcal { C } = \cup _ { i } \mathcal { C } _ { i } \}$ , each defined as a new independent verification problem. For instance, it can split a ReLU unit $g _ { j } ^ { ( k ) } = \mathrm { R e L U } ( h _ { j } ^ { ( k ) } )$ to be negative and positive cases as $\mathcal { C } _ { 0 } =$ $\mathcal { C } \cap \left( h _ { j } ^ { ( k ) } \ge 0 \right)$ and $\mathcal { C } _ { 1 } = \mathcal { C } \cap \left( h _ { j } ^ { ( k ) } < 0 \right)$ for a ReLU-based network; for each sub-domain $\mathcal { C } _ { i }$ , BaB based methods perform bounding to obtain a relaxed but sound lower bound $\underline { { f } } _ { \mathcal { C } _ { i } }$ . A tightened global lower bound over $\mathcal { C }$ can then be obtained by taking the minimum values of the sub-domain lower bounds from all the sub-domains: $\underline { { f } } = \operatorname* { m i n } _ { i } \underline { { f } } _ { \mathcal { C } _ { i } }$ . Branching and bounding will be performed recursively to tighten the approximated global lower bound over $\mathcal { C }$ until either (1) the global lower bound $\underline { { f } }$ becomes larger than 0 and prove the property or (2) a violation (e.g., adversarial example) is located in a sub-domain to disprove the property. Essentially, we build a search tree where each leaf is a sub-domain, and the property $\mathcal { P }$ can be proven only when it is valid on all leaves.
+
+Soundness of BaB We say the verification process is sound if we can always trust the “yes” ( $\mathcal { P }$ is verified) answer given by the verifier. It is straightforward to see that the whole BaB based verification process is sound as long as the bounding method used for each sub-domain $\mathcal { C } _ { i }$ is sound.
+
+Completeness of BaB The completeness of the BaB-based NN verification process, which was usually assumed true in some previous works (Bunel et al., 2020b; 2018), in fact, is not always true even if all possible sub-domains are considered with a sound bounding method. Additional requirements for the bounding method are required - we point out that a key factor for completeness involves feasibility checking in the bounding method which we will discuss in Section 3.2.
+
+Branching in BaB Since branching step determines the shape of the search tree, the main challenge is to efficiently choose a good leaf to split, which can significantly reduce the total number of branches and running time. In this work we focus on branching on activation (ReLU) nodes. BaBSR (Bunel et al., 2018) includes a simple branching heuristic which assigns each ReLU node a score to estimate the improvement for tightening $\underline { { f } }$ by splitting it, and splits the node with the highest score.
+
+Bounding with Linear Programming (LP) A typical bounding method used in BaB based verification is the Linear Programming bounding procedure (sometimes simply referred to as “LP” or “LP verifier” in our paper). Specifically, we transform the original verification problem into a linear programming problem by relaxing every activation unit as a convex (linear) domain (Ehlers, 2017) and then get the lower bound $\underline { { f } } _ { \mathcal { C } _ { i } }$ with a linear solver given domain $\mathcal { C } _ { i }$ . For instance, as shown in Figure 1a, $g _ { j } ^ { ( i ) } = \mathrm { R e L U } ( h _ { j } ^ { ( i ) } )$ can be linearly relaxed with the following 3 constraints: (1 $) g _ { j } ^ { ( i ) } \geq h _ { j } ^ { ( i ) }$ ; $( 2 ) g _ { j } ^ { ( i ) } \geq 0$ ; (3) $\begin{array} { r } { g _ { j } ^ { ( i ) } \le \frac { { \mathbf { u } } _ { j } ^ { ( i ) } } { { \mathbf { u } } _ { j } ^ { ( i ) } - l _ { j } ^ { ( i ) } } \bigl ( h _ { j } ^ { ( i ) } - l _ { j } ^ { ( i ) } \bigr ) } \end{array}$ . Note that the lower bound $\boldsymbol { l } _ { j } ^ { ( i ) }$ and upper bound $\pmb { u } _ { j } ^ { ( i ) }$ fo r each activation node h(i)j are required in the LP construction given $\mathcal { C } _ { i }$ . They are typically computed by the existing cheap bounding methods like LiRPA variants (Wong & Kolter, 2018) with low cost. The tighter the intermediate bounds $( l _ { j } ^ { ( i ) } , u _ { j } ^ { ( i ) } )$ are, the tighter $\underline { { f } }$ approximated by LP is.
+
+# 2.3 LINEAR RELAXATION BASED PERTURBATION ANALYSIS (LiRPA)
+
+Bound propagation in LiRPA We used Linear Relaxation based Perturbation Analysis (LiRPA) as bound procedure in BaB to get linear upper and lower bounds of NN output w.r.t input $x \in { \mathcal { C } }$ :
+
+$$
+\underline { { \mathbf { A } } } x + \underline { { \mathbf { b } } } \leq f ( x ) \leq \overline { { \mathbf { A } } } x + \overline { { \mathbf { b } } } , \quad x \in \mathcal { C }
+$$
+
+![](images/342ee79ebee0dd4e78e11eed01460685099d1107afb867eade9e72b3427223a6.jpg)  
+Figure 1: Relaxations of a ReLU: (a) “triangle” relaxation in LP; (b)(c) No relaxation when $\mathbf { u } _ { j } ^ { ( i ) } \leq 0$ (always inactive) or $\mathbf { l } _ { j } ^ { ( i ) } \geq 0$ (always active); (d) linear relaxation in LiRPA when $\mathbf { l } _ { j } ^ { ( i ) } < 0 , \mathbf { u } _ { j } ^ { ( i ) } > 0$ i)(unstable).
+
+A lower bound $\underline { { f } }$ can then be simply obtained by taking the lower bound of the linear equation $\underline { { \mathbf { A } } } x + \underline { { \mathbf { b } } }$ w.r.t input $x \in { \mathcal { C } }$ , which can be obtained via Holder’s inequality when ¨ $\mathcal { C }$ is a $\ell _ { p }$ norm ball.
+
+To get the coefficients $\underline { { \mathbf { A } } } , \overline { { \mathbf { A } } } , \underline { { \mathbf { b } } } , \overline { { \mathbf { b } } }$ , LiRPA propagates bounds of $f ( x )$ l (i) u(i) xjas a linear function to the output of each layer, in a backward manner. At the output layer $h ^ { ( L ) } ( x )$ we simply have:
+
+$$
+{ \bf I } h ^ { ( L ) } ( x ) \leq f ( x ) \leq { \bf I } h ^ { ( L ) } ( x ) , \quad x \in \mathcal { C }
+$$
+
+Then, the next step is to backward propagate the identity linear relationship through a linear layer $h ^ { ( L ) } ( x ) = \mathbf { W } ^ { ( L ) } g ^ { \top ( L - 1 ) } ( x )$ to get the linear bounds of $f ( x )$ w.r.t $g ^ { ( L - 1 ) }$ :
+
+$$
+\mathbf { W } ^ { ( L ) } g ^ { ( L - 1 ) } ( x ) \leq f ( x ) \leq \mathbf { W } ^ { ( L ) } g ^ { ( L - 1 ) } ( x ) , \quad x \in \mathcal { C }
+$$
+
+To get the linear relationship of $h ^ { ( L - 1 ) }$ w.r.t $f ( x )$ , we need to backward propagate through ReLU layer $g ^ { ( L - 1 ) } ( x ) \ = \ \mathrm { R e L U } ( h ^ { ( L - 1 ) } ( x ) )$ . Since it is nonlinear, we perform linear relaxations. For illustration, considering the $j$ -th ReLU neuron at $i$ -th layer, $g _ { j } ^ { ( i ) } ( x ) \ = \ \mathrm { R e L U } ( h _ { j } ^ { ( i ) } ( x ) )$ , we can linearly upper and lower bound it by $a _ { j } ^ { ( i ) } h _ { j } ^ { ( i ) } ( x ) + \underline { { { b } } } _ { j } ^ { ( i ) } \leq g _ { j } ^ { ( i ) } ( x ) \leq \overline { { { a } } } _ { j } ^ { ( i ) } h _ { j } ^ { ( i ) } ( x ) + \overline { { { b } } } _ { j } ^ { ( i ) }$ , where $\underline { { a } } _ { j } ^ { ( i ) } , \overline { { a } } _ { j } ^ { ( i ) } , \underline { { b } } _ { j } ^ { ( i ) } , \overline { { b } } _ { j } ^ { ( i ) }$ are:
+
+$$
+\left\{ \begin{array} { l l } { \underline { { a _ { j } ^ { ( i ) } } } = \overline { { a _ { j } ^ { ( i ) } } } = 0 , \underline { { b _ { j } ^ { ( i ) } } } = \overline { { b _ { j } ^ { ( i ) } } } = 0 } & { \mathbf { u } _ { j } ^ { ( i ) } \leq 0 \quad \mathrm { ( a l w a y s ~ i n a c t i v e ~ f o r ~ } x \in \mathcal { C } \mathrm { ) } } \\ { \underline { { a _ { j } ^ { ( i ) } } } = \overline { { a _ { j } ^ { ( i ) } } } = 1 , \underline { { b _ { j } ^ { ( i ) } } } = \overline { { b _ { j } ^ { ( i ) } } } = 0 } & { 1 _ { j } ^ { ( i ) } \geq 0 \quad \mathrm { ( a l w a y s ~ a c t i v e ~ f o r ~ } x \in \mathcal { C } \mathrm { ) } } \\ { \underline { { a _ { j } ^ { ( i ) } } } = \alpha _ { j } ^ { ( i ) } , \overline { { a _ { j } ^ { ( i ) } } } = \frac { \mathbf { u } _ { j } ^ { ( i ) } } { \mathbf { u } _ { j } ^ { ( i ) } - \mathbf { 1 } _ { j } ^ { ( i ) } } , \underline { { b _ { j } ^ { ( i ) } } } = 0 , \overline { { b _ { j } ^ { ( i ) } } } = - \frac { \mathbf { u } _ { j } ^ { ( i ) } \mathbf { 1 } _ { j } ^ { ( i ) } } { \mathbf { u } _ { j } ^ { ( i ) } - \mathbf { 1 } _ { j } ^ { ( i ) } } } & { 1 _ { j } ^ { ( i ) } < 0 , \mathbf { u } _ { j } ^ { ( i ) } > 0 \quad \mathrm { ( u n s t a b l e ~ f o r ~ } x \in \mathcal { C } \mathrm { ) } } \end{array} \right.
+$$
+
+Here $\mathbf { l } _ { j } ^ { ( i ) } \leq h _ { j } ^ { ( i ) } ( x ) \leq \mathbf { u } _ { j } ^ { ( i ) }$ are intermediate pre-activation bounds for $x \in { \mathcal { C } }$ , and $\alpha _ { j } ^ { ( i ) }$ is an arbitrary value between 0 and 1. The pre-activation bounds $\mathbf { l } _ { j } ^ { ( i ) }$ and $\mathbf { u } _ { j } ^ { ( i ) }$ can be computed by treating $h _ { j } ^ { ( i ) } ( x )$ as the output neuron with LiRPA. Figure 1(b,c,d) illustrate the relaxation for each state of ReLU neuron. With these linear relaxations, we can get the linear equation of $h ^ { ( L - 1 ) }$ w.r.t output $f ( x )$ :
+
+$$
+\begin{array} { r l } & { \mathbf { W } ^ { ( L ) } \underline { { \mathbf { D } } } _ { \alpha } ^ { ( L - 1 ) } h ^ { ( L - 1 ) } ( x ) + \underline { { \mathbf { b } } } ^ { ( L ) } \leq f ( x ) \leq \mathbf { W } ^ { ( L ) } \overline { { \mathbf { D } } } _ { \alpha } ^ { ( L - 1 ) } h ^ { ( L - 1 ) } ( x ) + \overline { { \mathbf { b } } } ^ { ( L ) } , \quad x \in \mathcal { C } } \\ & { \underline { { \mathbf { D } } } _ { \alpha , ( j , j ) } ^ { ( L ) } = \{ \frac { a _ { j } ^ { ( L ) } } { \overline { { a } } _ { j } ^ { ( L ) } } , \quad \mathbf { W } _ { j } ^ { ( L ) } \geq 0  , \quad \underline { { \mathbf { b } } } ^ { ( L ) } = \underline { { \mathbf { b } } } ^ { \prime ( L ) \top } \mathbf { W } ^ { ( L ) } , \quad \mathrm { w h e r e } \underline { { \mathbf { b } } } _ { j } ^ { \prime ( L ) } = \{ \underline { { b } } _ { j } ^ { ( L ) } , \quad \mathbf { W } _ { j } ^ { ( L ) } \geq 0  } \\ & {  \qquad \quad \overline { { a } } _ { j } ^ { ( L ) } , \quad \mathbf { W } _ { j } ^ { ( L ) } < 0  , \quad \overline { { \mathbf { b } } } ^ { ( L ) } \leq  \mathbf { W } ^ { ( L ) } \overline { { \mathbf { D } } } _ { \alpha } ^ { ( L ) } , \quad \mathrm { w h e r e } \underline { { \mathbf { b } } } _ { j } ^ { \prime ( L ) } = \{ \overline { { b } } _ { j } ^ { ( L ) } , \quad \mathbf { W } _ { j } ^ { ( L ) } < 0  } \end{array}
+$$
+
+The diagonthe signs in al mat D(L−1)α rices  to m , $\overline { { \mathbf { D } } } _ { \alpha } ^ { ( L - 1 ) }$ and biases reflects the linear relaxati and upper bounds. The definitions for s and also considers-th diagonal element $\mathbf { W } ^ { ( L ) }$ $j$ D(L)α,(j, ) and bias b(L) are similar, with the conditions for checking the signs of $\mathbf { W } _ { j } ^ { ( L ) }$ swapped. Importantly, $\underline { { \mathbf { D } } } _ { \alpha } ^ { ( L - 1 ) }$ has free variables $\alpha _ { j } ^ { ( i ) } \in [ 0 , 1 ]$ which do not affect correctness of the bounds. We can continue backward propagating these bounds layer by layer (e.g., $g ^ { ( L - 2 ) } ( x ) , h ^ { ( L - 2 ) } ( x )$ , etc) until reaching $g ^ { ( 0 ) } ( x ) = x$ , getting the eventual linear equations of $f ( x )$ in terms of input $x$ :
+
+$$
+\mathbf { L } ( x , \alpha ) \leq f ( x ) \leq \mathbf { U } ( x , \alpha ) , \quad \forall x \in \mathcal { C } ,
+$$
+
+$$
+\mathbf { L } ( x , \alpha ) = \mathbf { W } _ { , } ^ { ( L ) } \underline { { \mathbf { D } } } _ { \alpha } ^ { ( L - 1 ) } \cdot \cdot \cdot \underline { { \mathbf { D } } } _ { \alpha } ^ { ( 1 ) } \mathbf { W } ^ { ( 1 ) } x + \underline { { \mathbf { b } } } , \quad \mathbf { U } ( x , \alpha ) = \mathbf { W } ^ { ( L ) } \overline { { \mathbf { D } } } _ { \alpha } ^ { ( L - 1 ) } \cdot \cdot \cdot \overline { { \mathbf { D } } } _ { \alpha } ^ { ( 1 ) } \mathbf { W } ^ { ( 1 ) } x + \overline { { \mathbf { b } } }
+$$
+
+Here $_ \alpha$ denotes $\alpha _ { j } ^ { ( i ) }$ for all unstable ReLU neurons in NN. The obtained bounds $( \mathbf { L } ( x , \alpha ) , \mathbf { U } ( x , \alpha ) )$ of $f ( x )$ are linear functions in terms of $x$ . Beyond the simple feedforward NN presented here, LiRPA can support more complicated NN architectures like DenseNet and Transformers by computing $\mathbf { L }$ and $\mathbf { U }$ automatically and efficiently on general computational graphs ( $\mathrm { { X u } }$ et al., 2020).
+
+Soundness of LiRPA The above backward bound propagation process guarantees that $\mathbf { L } ( x , \alpha )$ and ${ \bf U } ( x , \alpha )$ soundly bound $f ( x )$ for all $x \in { \mathcal { C } }$ . Detailed proofs can be found in (Zhang et al., 2018; Singh et al., 2019b) for feedforward NNs and $\mathrm { { X u } }$ et al., 2020) for general networks.
+
+![](images/a018d8d731d7161641d86eaee25a2f0c78b48e04ca0394f31a817e671d38ebd2.jpg)  
+Figure 2: Illustration of our optimized LiRPA bounds and the BaB process. Given a two-layer neural network, we aim to verify output $f ( x ) ~ \geq ~ 0$ . Optimized LiRPA chooses optimized slopes for ReLU lower bounds, allowing tightening the intermediate layer bounds $\boldsymbol { l } _ { j } ^ { ( i ) }$ and $\pmb { u } _ { j } ^ { ( i ) }$ and also the output layer lower bound $\underline { { f } }$ . BaB splits two unstable neurons $h _ { 2 } ^ { ( 2 ) }$ and $h _ { 1 } ^ { ( 2 ) }$ to improve $\underline { { f } }$ and verify all sub-domains $( \underline { { { f } } } ~ \geq 0$ for all cases).
+
+# 3 PROPOSED ALGORITHM
+
+Overview In this section, we will first introduce our proposed efficient optimization of LiRPA bounds on GPUs that can allow us to achieve tight approximation on par with LP or even tighter for some cases but in a much faster manner. In Fig. 2, we provide a two-layer NN example to illustrate how our optimized LiRPA can improve the performance of BaB verification. In Section 3.2, we then show that feasibility checking is important to guarantee the completeness of BaB, and BaB using LiRPA without feasibility checking will end up to be incomplete. To ensure completeness, we design our algorithm with minimal usage of LP for checking feasibility of splits. Finally, we propose a batch split design by solving a batch of sub-domains in a massively parallel manner on GPUs to fully leverage the benefits of cheap and parallelizable LiRPA. We further improve BaBSR in a parallel fashion for branching and we summarize the detailed proposed algorithm in Section 3.4.
+
+# 3.1 OPTIMIZED LiRPA FOR COMPLETE VERIFICATION
+
+Concrete outer bounds with optimizable parameters We propose to use LiRPA as the bounding step in BaB. A pair of sound and concrete lower bound and upper bound $( { \underline { { f } } } , { \overline { { f } } } )$ to $f ( x )$ can be obtained according to Eq. 7 given fixed $\pmb { \alpha } = \pmb { \alpha } _ { 0 }$ :
+
+$$
+{ \underline { { f } } } ( \alpha _ { 0 } ) = \operatorname* { m i n } _ { x \in { \mathcal { C } } } { \mathbf { L } } ( x , \alpha _ { 0 } ) , \quad { \overline { { f } } } ( \alpha _ { 0 } ) = \operatorname* { m a x } _ { x \in { \mathcal { C } } } { \mathbf { U } } ( x , \alpha _ { 0 } )
+$$
+
+Because $\mathbf { L }$ , $\mathbf { U }$ are linear functions w.r.t $x$ when $\pmb { \alpha } _ { 0 }$ is fixed, it is easy to solve Eq. 8 using Holder’s ¨ inequality when $\mathcal { C }$ is a $\ell _ { p }$ norm ball ( $\mathrm { { X u } }$ et al., 2020). In incomplete verification settings, $_ { \pmb { \alpha } }$ can be set via certain heuristics (Zhang et al., 2018). Salman et al. (2019) showed that, the variable $_ \alpha$ is equivalent to dual variables in the LP relaxed verification problem (Wong & Kolter, 2018). Thus, an optimal selection of $_ { \pmb { \alpha } }$ given the same pre-activation bounds $\mathbf { l } _ { j } ^ { ( i ) }$ and $\mathbf { u } _ { j } ^ { ( i ) }$ can in fact, lead to the the same optimal solution for $\underline { { f } }$ and $\overline { { f } }$ as in LP.
+
+Previous complete verifiers typically use LiRPA variants to obtain intermediate layer bounds to construct an LP problem (Bunel et al. (2018); Lu & Kumar (2020)) and solve the LP to obtain bounds at output layer. The main reason for using LP is that it typically produces much tighter bounds than LiRPA when $_ { \pmb { \alpha } }$ is not optimized. We use optimized LiRPA, which is fast, acceleratorfriendly, and can produce tighter bounds, well outperforming LP for complete verification:
+
+$$
+\underline { { f } } = \operatorname* { m i n } _ { \alpha } \operatorname* { m i n } _ { x \in \mathcal { C } } \mathbf { L } ( x , \alpha ) , \quad \overline { { f } } = \operatorname* { m a x } _ { \alpha } \operatorname* { m a x } _ { x \in \mathcal { C } } \mathbf { U } ( x , \alpha ) , \quad \alpha _ { j } ^ { ( i ) } \in [ 0 , 1 ]
+$$
+
+The inner minimization or maximization has closed form solutions $\mathrm { { X u } }$ et al., 2020) based on Holder’s inequality, so we only need to optimize on ¨ $_ { \pmb { \alpha } }$ . Since we use a differentiable framework $\mathrm { { X u } }$ et al., 2020) to compute the LiRPA bound functions $\mathbf { L }$ and $\mathbf { U }$ , the gradients $\frac { \partial \mathbf { L } } { \partial \pmb { \alpha } }$ and $\textstyle { \frac { \partial \mathbf { U } } { \partial \alpha } }$ can be obtained easily. Optimization over $_ \alpha$ can be done via projected gradient descent (each coordinate of $_ \alpha$ is constrained in $[ 0 , 1 ] \cdot$ ). Since the gradient computation and optimization are done on GPUs, the bounding process is still very fast and can be one or two magnitudes faster than solving an LP.
+
+Optimized LiRPA bounds can be tighter than LP Solving Eq. 9 using gradient descent cannot guarantee to converge to the global optima, so it seems the bounds must be looser than LP. Counterintuitively, by optimizing $_ \alpha$ , we can potentially obtain tighter bounds than LP. When a “triangle”
+
+relaxation is constructed for LP, intermediate pre-activation bounds $\mathbf { l } _ { j } ^ { ( i ) }$ , $\mathbf { u } _ { j } ^ { ( i ) }$ must be fixed for the $j$ -th ReLU in layer $i$ . During the LP optimization process, only the output bounds are optimized; intermediate bounds stay unchanged. However, in the LiRPA formulation, $\mathbf { L } ( x , \alpha )$ and $\mathbf { U } ( x , \alpha )$ are complex functions of $_ { \pmb { \alpha } }$ : since intermediate bounds are also computed by LiRPA, they depend on all $\alpha _ { j ^ { \prime } } ^ { ( i ^ { \prime } ) } ( 0 < i ^ { \prime } < i )$ in previous layers. Thus, the gradients $\textstyle { \frac { \partial \mathbf { L } } { \partial \alpha } }$ and $\textstyle { \frac { \partial \mathbf { U } } { \partial \alpha } }$ can tighten output layer bounds $\underline { { f } }$ and $\overline { { f } }$ indirectly by tightening intermediate layer bounds, forming a tighter convex relaxation for the next iteration. An LP solver cannot achieve this because adding $\mathbf { l } _ { j } ^ { ( i ) }$ and $\mathbf { u } _ { j } ^ { ( i ) }$ as optimization variables makes the problem non-linear. This is the key to our success of applying LiRPA based bounds for the complete verification setting, where tighter bounds are essential.
+
+In Figure 3, we illustrate our optimized LiRPA bounds and the LP solution. Initially, we use LiRPA with $_ { \pmb { \alpha } }$ set via a fast heuristic to compute intermediate layer bounds $\mathbf { l } _ { j } ^ { ( i ) }$ and $\mathbf { u } _ { j } ^ { ( i ) }$ and then use them to build a relaxed LP problem. The solution to this initial LP problem (red line) is much tighter than the LiRPA solution with the heuristically set $_ { \pmb { \alpha } }$ (the left-most point of the blue line). Then, we optimize $_ { \pmb { \alpha } }$ with gradient decent, and LiRPA quickly outperforms this initial LP solution due to optimized tighter intermediate layer bounds. We can create a new LP with optimized intermediate bounds (light blue line), producing a slightly tighter bound than LiRPA with optimized $_ { \pmb { \alpha } }$ . The LP bounds in most existing complete verifiers all use intermediate layer bounds obtained from unoptimized LiRPA bounds or even weaker methods like interval arithmetic, ending up to the solution close to or lower than the red line in Figure 3. Instead, our optimized LiRPA bounds can produce tight bounds, and also exploit parallel acceleration from machine learning accelerators, leading to huge improvements in verification time compared to existing baselines.
+
+![](images/ccd1ceb48c28fa2441514e1999b3ad806c6e161021bbcddd981fca7059982abf.jpg)  
+Figure 3: Optimized LiRPA bound (0 to 200 iterations) vs LP bounds.
+
+ReLU Split Constraints In the BaB process, when a ReLU $h _ { j } ^ { ( i ) }$ is split into two sub-domains $( h _ { j } ^ { ( i ) } \geq 0$ and $h _ { j } ^ { ( i ) } < 0 .$ ), we simply set $l _ { j } ^ { ( i ) } \geq 0$ and ${ \pmb u } _ { j } ^ { ( i ) } < 0$ in bounding step. It tighten the LiRPA bounds by forcing the split ReLU linear, reducing relaxation errors. However, when splits are added, LiRPA and LP are not equivalent even under fixed $\mathbf { l } _ { j } ^ { ( i ) }$ , $\mathbf { u } _ { j } ^ { ( i ) }$ and optimal $_ { \pmb { \alpha } }$ . After splits, LiRPA cannot check certain constraints where LP is capable to, as we will discuss in the next section.
+
+# 3.2 COMPLETENESS WITH MINIMAL USAGE OF LP BOUNDING PROCEDURE
+
+Even though our optimized LiRPA can bring us huge speed improvement over LP for BaB based verification, we observe that it may end up to be incomplete due to the lack of feasibility checking: it cannot detect some conflicting settings of ReLU splits. We state such an observation in Theorem 3.1:
+
+Theorem 3.1 (Incompleteness without feasibility checking) When using LiRPA variants described in Section 2.3 as the bounding procedure, BaB based verification is incomplete.
+
+We prove the theorem by giving a counter-example in Appendix A.1 where all ReLU neurons are split and thus LiRPA runs on a linear network for each sub-domain. As a result, LiRPA can still be indecisive for the verification problem. The main reason is that LiRPA variants will lose the feasibility information encoded by the sub-domain constraints. For illustration, consider a subdomain Ci = C ∩ (h(i1)j1 $\bar { \mathcal { C } } _ { i } = C \cap ( h _ { j _ { 1 } } ^ { ( i _ { 1 } ) } < 0 ) \cap ( \bar { h } _ { j _ { 2 } } ^ { ( i _ { 2 } ) } \geq 0 )$ , LiRPA will force g(i1)j1 (x) = 0 (inactive ReLU, a zero function) and these bounds $g _ { j _ { 2 } } ^ { ( i _ { 2 } ) } ( x ) = h _ { j _ { 2 } } ^ { ( i _ { 2 } ) } ( x )$ (active ReLU, anated lower bound ntity function) respectively and propagate. However, the split feasibility constraint $\underline { { f } } _ { \mathcal { C } _ { i } }$ $( h _ { j _ { 1 } } ^ { ( i _ { 1 } ) } < 0 ) \cap ( h _ { j _ { 2 } } ^ { ( i _ { 2 } ) } \geq 0 )$ is ignored, so two conflict splits may be conducted (e.g., when $h _ { j _ { 1 } } ^ { ( i _ { 1 } ) } < 0$ , $h _ { j _ { 2 } } ^ { ( i _ { 2 } ) }$ (i2) cannot be $\geq 0$ ). On the contrary, LP can fully preserve such feasibility information due to the linear solver involved and detect the infeasible sub-domains. Then, in Theorem 3.2 we show that the minimal usage of feasibility checking with LP can guarantee the completeness of BaB with LiRPA.
+
+# Algorithm 1 Parallel BaB with optimized LiRPA bounding (we highlight the differences between our algorithm and regular BaB (Bunel et al., 2018) in blue. Comments are in brown.)
+
+1: Inputs: $f , \mathcal { C } , n$ (batch size), $\eta$ (threshold to switch to LP)   
+2: $( \underline { { f } } , \overline { { f } } ) \gets$ optimized LiRPA $( f , [ { \mathcal { C } } ] )$   
+3: $\mathbb { P } \gets \left[ ( \underline { { f } } , \overline { { f } } , \mathcal { C } ) \right]$ . $\mathbb { P }$ is the set of all unverified sub-domains   
+4: while $\underline { { f } } < 0$ and ${ \overline { { f } } } \geq 0$ do   
+5: $( { \mathcal { C } } _ { 1 } , \ldots , { \mathcal { C } } _ { n } ) \gets$ batch pick out $( \mathbb { P } , n )$ . Pick sub-domains to split and removed them from $\mathbb { P }$   
+6: $[ \mathcal { C } _ { 1 } ^ { l } , \mathcal { C } _ { 1 } ^ { u } , \ldots , \mathcal { C } _ { n } ^ { l } , \mathcal { C } _ { n } ^ { u } ] $ batch split $( { \mathcal { C } } _ { 1 } , \ldots , { \mathcal { C } } _ { n } )$ . Each $\mathcal { C } _ { i }$ splits into two sub-domains $\mathcal { C } _ { i } ^ { l }$ and $\mathcal { C } _ { i } ^ { u }$   
+7: $\underline { { f } } _ { \mathcal { C } _ { 1 } ^ { l } } , \overline { { f } } _ { \mathcal { C } _ { 1 } ^ { l } } , \underline { { f } } _ { \mathcal { C } _ { 1 } ^ { u } } , \overline { { f } } _ { \mathcal { C } _ { 1 } ^ { u } } , \dots , \underline { { f } } _ { \mathcal { C } _ { n } ^ { l } } , \overline { { f } } _ { \mathcal { C } _ { n } ^ { l } } , \underline { { f } } _ { \mathcal { C } _ { n } ^ { u } } , \overline { { f } } _ { \mathcal { C } _ { n } ^ { u } } \Big ] \gets \mathrm { o p t i m i z e d . L i R P A } ( f , [ \mathcal { C } _ { 1 } ^ { l } , \mathcal { C } _ { 1 } ^ { u } , \dots , \mathcal { C } _ { n } ^ { l } , \mathcal { C } _ { n } ^ { u } ] )$ .   
+Compute lower and upper bounds using LiRPA for each sub-domain on GPUs in a batch   
+8: $\mathbb { P }  \mathbb { P } \cup$ Domain Filt $\begin{array} { r } { \mathsf { a r } \left( [ \underline { { f } } _ { \mathcal { C } _ { 1 } ^ { l } } , \overline { { f } } _ { \mathcal { C } _ { 1 } ^ { l } } , \mathcal { C } _ { 1 } ^ { l } ] , [ \underline { { f } } _ { \mathcal { C } _ { 1 } ^ { u } } , \overline { { f } } _ { \mathcal { C } _ { 1 } ^ { u } } , \mathcal { C } _ { 1 } ^ { u } ] , \ldots , [ \underline { { f } } _ { \mathcal { C } _ { n } ^ { l } } , \overline { { f } } _ { \mathcal { C } _ { n } ^ { 1 } } , \mathcal { C } _ { n } ^ { l } ] , [ \underline { { f } } _ { \mathcal { C } _ { n } ^ { u } } , \overline { { f } } _ { \mathcal { C } _ { n } ^ { u } } , \mathcal { C } _ { n } ^ { u } ] \right) } \end{array}$ .   
+Filter out verified sub-domains, insert the left domains back to $\mathbb { P }$   
+9: $\underline { { f } }  \operatorname* { m i n } \{ \underline { { f } } _ { \mathcal { C } _ { i } } \mid ( \underline { { f } } _ { \mathcal { C } _ { i } } , \mathcal { C } _ { i } ) \in \mathbb { P } \}$ , $i = 1 , \ldots , n$ $\triangleright$ To ease notation, $\mathcal { C } _ { i }$ here indicates both $\mathcal { C } _ { i } ^ { u }$ and $\mathcal { C } _ { i } ^ { l }$   
+10: $\overline { { f } }  \operatorname* { m i n } \{ \overline { { f } } _ { \mathcal { C } _ { i } } \mid ( \overline { { f } } _ { \mathcal { C } _ { i } } , \mathcal { C } _ { i } ) \in \mathbb { P } \}$ , $i = 1 , \ldots , n$   
+11: if length $( \mathbb { P } ) > \eta$ then . Fall back to LP for completeness   
+12: $\begin{array} { r l } & { \left[ \underset { - c _ { 1 } ^ { l } } { \overset { \smile } { ⨏ } } , \bar { f } _ { c _ { 1 } ^ { l } } ^ { \prime } , \underset { - c _ { 1 } ^ { l } } { \overset { \cdot } { ⨏ } } , \overline { { f } } _ { c _ { 1 } ^ { u } } , \dots , \underset { - c _ { n } ^ { l } } { \overset { \cdot } { \ b \mathscr { f } } } , \overline { { f } } _ { c _ { n } ^ { l } } , \frac { \dag } { \mathscr { f } } _ { c _ { n } ^ { u } } , \overline { { f } } _ { c _ { n } ^ { u } } , \right] \gets \mathrm { c o m p u t e - b o u n d \ L P } ( f , \left[ \mathcal { C } _ { 1 } ^ { l } , \mathcal { C } _ { 1 } ^ { u } , \dots , \overline { { \mathscr { C } } } _ { n } ^ { l } , \mathcal { C } _ { n } ^ { u } \right] , } \\ & { \mathbb { P } \gets \mathbb { P } \bigcup \mathrm { D o m a i n . F i 1 t e r } \left( [ \underset { - c _ { 1 } ^ { l } } { \overset { \cdot } { \mathscr { f } } } , \overline { { f } } _ { c _ { 1 } ^ { l } } , \mathcal { C } _ { 1 } ^ { l } ] , [ \underset { - c _ { 1 } ^ { u } } { \overset { \cdot } { \mathscr { f } } } , \overline { { f } } _ { c _ { 1 } ^ { u } } , \mathcal { C } _ { 1 } ^ { u } ] , \dots , [ \underset { - c _ { n } ^ { l } } { \overset { \cdot } { \mathscr { f } } } _ { c _ { n } ^ { l } } , \overline { { f } } _ { c _ { n } ^ { l } } ^ { l } , \mathcal { C } _ { n } ^ { l } ] , [ \underset { - c _ { n } ^ { u } } { \overset { \cdot } { \mathscr { f } } } , \overline { { f } } _ { c _ { n } ^ { u } } , \overline { { f } } _ { c _ { n } ^ { u } } ] \right) } \end{array}$ )   
+13:   
+14: Outputs: $\underline { { f } } , \overline { { f } }$
+
+Theorem 3.2 (Minimal feasibility checking for completeness) When using LiRPA variants described in Section 2.3 as the bounding procedure, BaB based verification is complete if all infeasible leaf sub-domains (i.e., sub-domains cannot be further split) are detected by linear programming.
+
+We prove the theorem in Appendix A.2, where we show that by checking the feasibility of splits with LP, we can eliminate the cases where incompatible splits are chosen in the LiRPA BaB process. Since LP is slow while LiRPA is highly efficient, we propose to only use LP when the LiRPA based bounding process is stuck, either (1) when partitioning and bounding new sub-domains with LiRPA cannot further improve the bounds, or (2) when all unstable neurons have been split. In this way, the infeasible sub-domains can be eventually detected by occasional usage of LP while the advantage of massive parallel LiRPA on GPUs is fully enjoyed. We will describe our full algorithm in Sec. 3.4.
+
+# 3.3 BATCH SPLITS
+
+SOTA BaB methods (Bunel et al., 2020b; Lu & Kumar, 2020) only split one sub-domain during each branching step. Since we use cheap and GPU-friendly LiRPA bounds, we can select a batch of sub-domains to split and propagate their LiRPA bounds in a batch. Such a batch splitting design can greatly improve hardware efficiency on GPUs. Given a batch size $n$ that allows us to fully use the GPU memory available, we can obtain $n$ bounds simultaneously. It grows the search tree on a single leaf by a depth of $\log _ { 2 } n$ , or split $n / 2$ leaf nodes at the same time, accelerating by up to $n$ times.
+
+# 3.4 OUR COMPLETE VERIFICATION FRAMEWORK
+
+Our LiRPA based complete verification framework is presented in Alg. 1. The algorithm takes a target NN function $f$ and a domain $\mathcal { C }$ as inputs. We run optimized LiRPA to get initial bounds $( \underline { { f } } , \overline { { f } } )$ for $x \in { \mathcal { C } }$ (Line 2). Then we utilize the power of GPUs to split in parallel and maintain a global set $\mathbb { P }$ storing all the sub-domains which cannot be verified with optimized LiRPA (Line 5-10). Specifically, batch pick out improves BaBSR (Bunel et al., 2018) in a parallel manner to select $n$ sub-domains in $\mathbb { P }$ and determine the corresponding ReLU neuron to split for each of them. If the length of $\mathbb { P }$ is less than $n$ , then we reduce $n$ to the length of $\mathbb { P }$ . batch split splits each selected $\mathcal { C } _ { i }$ to two sub-domains $\mathcal { C } _ { i } ^ { l }$ and $\mathcal { C } _ { i } ^ { u }$ by forcing the selected unstable ReLU neuron to be positive and negative, respectively. optimize LiRPA runs optimized LiRPA in parallel as a batch and returns the lower and upper bounds for $n$ selected sub-domains simultaneously. Domain Filter filters out verified sub-domains (proved with $\underline { { f } } _ { \mathcal { C } _ { i } } \geq 0 \}$ ) and we insert the remaining ones to $\mathbb { P }$ . The loop breaks if the property is proved $( \underline { { { f } } } ) \geq 0 ) ,$ ) or a counter-example is found in any sub-domain $( \overline { { f } } < 0 )$ .
+
+To avoid excessive splits, we set the maximum length of the sub-domains to $\eta$ (Line 12). Once the length of $\mathbb { P }$ reaches this threshold, compute bound LP will be called. It solves these $\eta$ sub-domains by LP (one by one in a loop, or in parallel if using multiple CPUs is allowed) with optimized LiRPA computed intermediate layer bounds. If a sub-domain $\mathcal { C } _ { i } \in \mathbb { P }$ (which previously cannot be verified by LiRPA) is proved or detected to be infeasible by LP, as an effective heuristic, we will backtrack and prioritize to check its parent node with LP. If the parent sub-domain is also proved or infeasible, we can prune all its child nodes to greatly reduce the size of the search tree.
+
+Completeness of our framework Our algorithm is complete, because we follow Theorem 3.2 and check feasibility of all split sub-domains that have deep BaB search tree depth (length of $\mathbb { P }$ reaches threshold $\eta$ ), forming a superset of the worst case where all ReLU neurons are split.
+
+# 4 EXPERIMENTS
+
+In this section, we compare our verifier against the state-of-the-art ones to illustrate the effectiveness of our proposed framework. Overall, our verifier is about 10X, 4X and 20X faster than the best LP-based verifier (Lu & Kumar, 2020) on the Base, Wide and Deep models, respectively.
+
+Setup We follow the most challenging experimental setup used in the state-of-the-art verifiers GNN-ONLINE (Lu & Kumar, 2020) and BABSR (Bunel et al., 2020b). Specifically, we evaluate on CIFAR10 dataset on three NNs: Base, Wide and Deep. The dataset is categorized into three difficulty levels: Easy, Medium, and Hard, which is generated according to the performance of BaBSR. The verification task is defined as given a $l _ { \infty }$ norm perturbation less than $\epsilon$ , the classifier will not predict a specific (predefined) wrong label for each image $x$ (see Appendix B). We set batch size $n = 4 0 0$ , 200, 200 for Base, Wide and Deep model respectively and threshold $\eta = 1 2 0 0 0$ . More details on experimental setup are provided in Appendix B. Our code is available at https://github.com/kaidixu/LiRPA_Verify.
+
+Comparisons against state-of-the-art verifiers We include five different methods for comparison: (1) BABSR (Bunel et al., 2020b), a BaB and LP based verifier using a simple ReLU split heuristic; (2) MIPPLANET (Ehlers, 2017), a customized MIP solver for NN verification where unstable ReLU neurons are randomly selected for split; (3) GNN (Lu & Kumar, 2020) and (4) GNN-ONLINE (Lu & Kumar, 2020) are BaB and LP based verifiers using a learned graph neural network (GNN) to guide the ReLU split. (5) PROXIMAL BABSR (Bunel et al., 2020a) is a very recently proposed verification framework based on Lagrangian decomposition which also supports GPU acceleration without solving LPs. All methods use 1 CPU with 1 GPU. The timeout threshold is 3,600 seconds.
+
+For the Base model in different difficulty levels, Easy, Medium and Hard, Table 1 shows that we are around $5 \sim 4 0 \mathrm { X }$ faster than baseline BaBSR and around $2 \sim 2 0 \mathrm { X }$ faster than GNN split baselines. The accumulative solved properties with increasing runtime are shown in Figure 4. In all our experiments, we use the basic heuristic in BaBSR for branching and do not use GNNs, so our speedup comes purely from the faster LiRPA based bounding procedure. We are also competitive against Lagrangian decomposition on GPUs.
+
+Table 1: Performance of various methods on different models. We compare each method’s avg. solving time, the avg. number of branches required, and the percentage of timed out (TO) properties.   
+
+<table><tr><td></td><td colspan="3">Base - Easy</td><td colspan="3">Base - Medium</td><td colspan="3">Base - Hard</td><td colspan="3">Wide</td><td colspan="3">Deep</td></tr><tr><td>Method</td><td>time(s)</td><td>branches</td><td>%TO</td><td>time(s)</td><td>branches</td><td>%TO</td><td>time(s)</td><td>branches</td><td>%TO</td><td>time(s)</td><td>branches</td><td>%TO</td><td>time(s)</td><td>branches</td><td>%TO</td></tr><tr><td>BABSR</td><td>522.48</td><td>585</td><td>0.0</td><td>1335.40</td><td>1471</td><td>0.0</td><td>2875.16</td><td>1843</td><td>35.2</td><td>3325.65</td><td>455</td><td>50.3</td><td>2855.19</td><td>365</td><td>54.0</td></tr><tr><td>MIPPLANET</td><td>1462.24</td><td></td><td>16.5</td><td>1912.25</td><td>=</td><td>43.5</td><td>2172.23</td><td></td><td>46.2</td><td>3088.40</td><td></td><td>79.4</td><td>2842.54</td><td>-</td><td>73.6</td></tr><tr><td>GNN</td><td>312.93</td><td>301</td><td>0.0</td><td>624.12</td><td>635</td><td>0.9</td><td>1468.75</td><td>931</td><td>15.6</td><td>1791.52</td><td>375</td><td>19.0</td><td>1870.63</td><td>198</td><td>18.4</td></tr><tr><td>GNN-ONLINE</td><td>207.43</td><td>269</td><td>0.0</td><td>638.15</td><td>546</td><td>0.4</td><td>1255.35</td><td>968</td><td>15.6</td><td>1642.03</td><td>389</td><td>19.0</td><td>1845.71</td><td>196</td><td>18.4</td></tr><tr><td>PROXIMAL BABSR</td><td>15.68</td><td>1371</td><td>0.0</td><td>51.88</td><td>6482</td><td>0.4</td><td>627.96</td><td>91880</td><td>13.4</td><td>510.55</td><td>45855</td><td>11.4</td><td>230.06</td><td>6721</td><td>4.4</td></tr><tr><td>OURS</td><td>11.86</td><td>2589</td><td>0.0</td><td>42.04</td><td>9233</td><td>0.0</td><td>633.85</td><td>96755</td><td>13.0</td><td>375.23</td><td>53481</td><td>8.5</td><td>81.55</td><td>1439</td><td>1.6</td></tr></table>
+
+Figure 4: Cactus plots for our method and other baselines in Base (Easy, Medium and Hard ), Wide and Deep models. We plot the percentage of solved properties with growing running time.
+
+![](images/df2e4bdcde62e438d06e74fb7a238a63394822ce66cb97c61affafde8e56c145.jpg)
+
+Performance on Larger Models In Table 1, we show that our verifier is more scalable on larger (wider or deeper) NNs compared to other state-of-the-art verifiers. Our method enjoys efficient GPU acceleration particularly on Deep model and can achieve 30X speedup compared to BABSR, and we are also significantly faster than Lagrangian decomposition based GPU verifier (PROXIMAL BABSR). When compared to the state-of-the-art LP based BaB, GNN-ONLINE, our method can save 20X running time on Deep model. In Appendix C, we analyze the effectiveness of optimized LiRPA and batch splits separately, and find that optimized LiRPA is crucial for NN verification. Performance comparisons of our proposed framework on CPU cores without GPU acceleration are included in Appendix D.
+
+# 5 RELATED WORK
+
+Complete verifiers Early complete verifiers rely on satisfiability modulo theory (SMT) (Katz et al., 2017; Huang et al., 2017; Ehlers, 2017) and mixed integer linear programming (MILP) (Tjeng et al., 2019a; Dutta et al., 2018), and they typically do not scale well. Higher order logic provers such as proof assistant (Bentkamp et al., 2018) can also be potentially used for NN verification, but their scalability to the NN setting has not been demonstrated. Recently, Bunel et al. (2018) unified many approaches used in various complete verifiers into a BaB framework. An LP based bounding procedure is used in most of the existing BaB framework (Bunel et al., 2018; Wang et al., 2018c; Royo et al., 2019; Lu & Kumar, 2020). For branching, two categories of branching strategies were proposed: (1) input node branching (Wang et al., 2018c; Bunel et al., 2020b; Royo et al., 2019; Anderson et al., 2019) where input features are divided into sub-domains, and (2) activation node (especially, ReLU) branching (Katz et al., 2017; Bunel et al., 2018; Wang et al., 2018b; Ehlers, 2017; Lu & Kumar, 2020) where hidden layer activations are split into sub-domains. Bunel et al. (2018) found that input node branching cost is exponential to input dimension. Thus, many state-of-the-art verifiers use activation node branching instead, focusing on heuristics to select good nodes to split. BaBSR (Bunel et al., 2018) prioritizes ReLUs for splitting based on their pre-activation bounds; Lu & Kumar (2020) used a graph neural network (GNN) to learn good splitting heuristics. Our work focuses on improving bounding and can use better branching heuristics to achieve further speedup.
+
+Two mostly relevant concurrent works using GPUs for accelerating NN verification are: (1) GPUPoly (Muller et al., 2020), an extension of DeepPoly on CUDA, is ¨ still an incomplete verifier. Also, it is implemented in CUDA $\mathrm { C } { + } { + }$ , requiring manual effort for customization and gradient computation, so it is not easy to get the gradients for optimizing bounds as we have done in Section 3.1. (2) Lagrangian Decomposition (Bunel et al., 2020a) is a GPU-accelerated BaB based complete verifier that iteratively tightens the bounds based on a Lagrangian decomposition optimization formulation and does not reply on LP. However, it solves a much more complicated optimization problem than LiRPA, and typically requires hundreds of iterations to converge for a single sub-domain.
+
+Incomplete verifiers Many incomplete verification methods rely on convex relaxations of NN, replacing nonlinear activations like ReLUs with linear constraints (Wong & Kolter, 2018; Wang et al., 2018b; Zhang et al., 2018; Weng et al., 2018; Gehr et al., 2018; Singh et al., 2018a;b; 2019b;a) or semidefinite constraints (Raghunathan et al., 2018; Dvijotham et al., 2020; Dathathri et al., 2020). Tightening the relaxation for incomplete verification was discussed in (Dvijotham et al., 2018; Singh et al., 2019a; Lyu et al., 2019; Tjandraatmadja et al., 2020). Typically, tight relaxations require more computation and memory in general. We refer the readers to (Salman et al., 2019) for a comprehensive survey. Recently, Xu et al. (2020) categorized the family of linear relaxation based incomplete verifiers into LiRPA framework, allowing efficient implementation on machine learning accelerators. Our work uses LiRPA as the bounding procedure for complete verification and exploits its computational efficiency to accelerate, and our main contribution is to show that we can use fast but weak incomplete verifiers as the main driver for complete verification when strategically applied.
+
+# 6 CONCLUSION
+
+We use a LiRPA based incomplete NN verifier to accelerate the bounding procedure in branch and bound (BaB) for complete NN verification on massively parallel accelerators. We use a fast gradient based procedure to tighten LiRPA bounds. We study the completeness of BaB with LiRPA, and show up to 5X speedup compared to state-of-the-art verifiers across multiple models and properties.
+
+# ACKNOWLEDGMENTS
+
+This work is supported by NSF grant CNS18-01426; an ARL Young Investigator (YIP) award; an NSF CAREER award; a Google Faculty Fellowship; a Capital One Research Grant; and a J.P. Mor
+
+gan Faculty Award; Air Force Research Laboratory under FA8750-18-2-0058; NSF IIS-1901527 and NSF IIS-2008173.
+
+# REFERENCES
+
+Greg Anderson, Shankara Pailoor, Isil Dillig, and Swarat Chaudhuri. Optimization and abstraction: A synergistic approach for analyzing neural network robustness. In Proceedings of the 40th ACM SIGPLAN Conference on Programming Language Design and Implementation, pp. 731– 744, 2019.
+
+Alexander Bentkamp, Jasmin Christian Blanchette, Simon Cruanes, and Uwe Waldmann. Superposition for lambda-free higher-order logic. In International Joint Conference on Automated Reasoning, pp. 28–46. Springer, 2018.
+
+Rudy Bunel, Alessandro De Palma, Alban Desmaison, Krishnamurthy Dvijotham, Pushmeet Kohli, Philip H. S. Torr, and M. Pawan Kumar. Lagrangian decomposition for neural network verification. Conference on Uncertainty in Artificial Intelligence (UAI) 2020, 2020a.
+
+Rudy Bunel, Jingyue Lu, Ilker Turkaslan, P Kohli, P Torr, and P Mudigonda. Branch and bound for piecewise linear neural network verification. Journal of Machine Learning Research, 21(2020), 2020b.
+
+Rudy R Bunel, Ilker Turkaslan, Philip Torr, Pushmeet Kohli, and Pawan K Mudigonda. A unified view of piecewise linear neural network verification. In Advances in Neural Information Processing Systems, pp. 4790–4799, 2018.
+
+Sumanth Dathathri, Krishnamurthy Dvijotham, Alexey Kurakin, Aditi Raghunathan, Jonathan Uesato, Rudy R Bunel, Shreya Shankar, Jacob Steinhardt, Ian Goodfellow, Percy S Liang, et al. Enabling certification of verification-agnostic networks via memory-efficient semidefinite programming. Advances in Neural Information Processing Systems, 33, 2020.
+
+Souradeep Dutta, Susmit Jha, Sriram Sankaranarayanan, and Ashish Tiwari. Output range analysis for deep feedforward neural networks. In NASA Formal Methods Symposium, pp. 121–138. Springer, 2018.
+
+Krishnamurthy Dvijotham, Sven Gowal, Robert Stanforth, Relja Arandjelovic, Brendan O’Donoghue, Jonathan Uesato, and Pushmeet Kohli. Training verified learners with learned verifiers. arXiv preprint arXiv:1805.10265, 2018.
+
+Krishnamurthy Dj Dvijotham, Robert Stanforth, Sven Gowal, Chongli Qin, Soham De, and Pushmeet Kohli. Efficient neural network verification with exactness characterization. In Uncertainty in Artificial Intelligence, pp. 497–507. PMLR, 2020.
+
+Ruediger Ehlers. Formal verification of piece-wise linear feed-forward neural networks. In International Symposium on Automated Technology for Verification and Analysis, pp. 269–286. Springer, 2017.
+
+Timon Gehr, Matthew Mirman, Dana Drachsler-Cohen, Petar Tsankov, Swarat Chaudhuri, and Martin Vechev. Ai2: Safety and robustness certification of neural networks with abstract interpretation. In 2018 IEEE Symposium on Security and Privacy (SP), pp. 3–18. IEEE, 2018.
+
+Xiaowei Huang, Marta Kwiatkowska, Sen Wang, and Min Wu. Safety verification of deep neural networks. In International Conference on Computer Aided Verification, pp. 3–29. Springer, 2017.
+
+Guy Katz, Clark Barrett, David L Dill, Kyle Julian, and Mykel J Kochenderfer. Reluplex: An efficient smt solver for verifying deep neural networks. In International Conference on Computer Aided Verification, pp. 97–117. Springer, 2017.
+
+Jingyue Lu and M Pawan Kumar. Neural network branching for neural network verification. International Conference on Learning Representation (ICLR), 2020.
+
+Zhaoyang Lyu, Ching-Yun Ko, Zhifeng Kong, Ngai Wong, Dahua Lin, and Luca Daniel. Fastened crown: Tightened neural network robustness certificates. arXiv preprint arXiv:1912.00574, 2019.
+
+Matthew Mirman, Timon Gehr, and Martin Vechev. Differentiable abstract interpretation for provably robust neural networks. In International Conference on Machine Learning, pp. 3575–3583, 2018.
+
+Christoph Muller, Gagandeep Singh, Markus P ¨ uschel, and Martin Vechev. Neural network robust- ¨ ness verification on gpus. arXiv preprint arXiv:2007.10868, 2020.
+
+Aditi Raghunathan, Jacob Steinhardt, and Percy S Liang. Semidefinite relaxations for certifying robustness to adversarial examples. In Advances in Neural Information Processing Systems, pp. 10877–10887, 2018.
+
+Vicenc Rubies Royo, Roberto Calandra, Dusan M Stipanovic, and Claire Tomlin. Fast neural network verification via shadow prices. arXiv preprint arXiv:1902.07247, 2019.
+
+Hadi Salman, Greg Yang, Huan Zhang, Cho-Jui Hsieh, and Pengchuan Zhang. A convex relaxation barrier to tight robustness verification of neural networks. In Advances in Neural Information Processing Systems 32, pp. 9832–9842, 2019.
+
+Gagandeep Singh, Timon Gehr, Matthew Mirman, Markus Puschel, and Martin Vechev. Fast and ¨ effective robustness certification. In Advances in Neural Information Processing Systems, pp. 10825–10836, 2018a.
+
+Gagandeep Singh, Timon Gehr, Markus Puschel, and Martin Vechev. Boosting robustness certifica- ¨ tion of neural networks. In International Conference on Learning Representations, 2018b.
+
+Gagandeep Singh, Rupanshu Ganvir, Markus Puschel, and Martin Vechev. Beyond the single neuron ¨ convex barrier for neural network certification. In Advances in Neural Information Processing Systems, pp. 15072–15083, 2019a.
+
+Gagandeep Singh, Timon Gehr, Markus Puschel, and Martin Vechev. An abstract domain for cer- ¨ tifying neural networks. Proceedings of the ACM on Programming Languages, 3(POPL):41, 2019b.
+
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. In ICLR, 2013.
+
+Christian Tjandraatmadja, Ross Anderson, Joey Huchette, Will Ma, Krunal Patel, and Juan Pablo Vielma. The convex relaxation barrier, revisited: Tightened single-neuron relaxations for neural network verification. arXiv preprint arXiv:2006.14076, 2020.
+
+Vincent Tjeng, Kai Xiao, and Russ Tedrake. Evaluating robustness of neural networks with mixed integer programming. ICLR, 2019a.
+
+Vincent Tjeng, Kai Y. Xiao, and Russ Tedrake. Evaluating robustness of neural networks with mixed integer programming. In 7th International Conference on Learning Representations, ICLR 2019, New Orleans, LA, USA, May 6-9, 2019. OpenReview.net, 2019b. URL https: //openreview.net/forum?id $=$ HyGIdiRqtm.
+
+Shiqi Wang, Yizheng Chen, Ahmed Abdou, and Suman Jana. Mixtrain: Scalable training of formally robust neural networks. arXiv preprint arXiv:1811.02625, 2018a.
+
+Shiqi Wang, Kexin Pei, Justin Whitehouse, Junfeng Yang, and Suman Jana. Efficient formal safety analysis of neural networks. In Advances in Neural Information Processing Systems, pp. 6367– 6377, 2018b.
+
+Shiqi Wang, Kexin Pei, Justin Whitehouse, Junfeng Yang, and Suman Jana. Formal security analysis of neural networks using symbolic intervals. In 27th {USENIX} Security Symposium $\langle \dot { U } S E N I X \rangle$ Security 18), pp. 1599–1614, 2018c.
+
+Tsui-Wei Weng, Huan Zhang, Hongge Chen, Zhao Song, Cho-Jui Hsieh, Luca Daniel, Duane Boning, and Inderjit Dhillon. Towards fast computation of certified robustness for relu networks. In International Conference on Machine Learning, pp. 5273–5282, 2018.
+
+Eric Wong and Zico Kolter. Provable defenses against adversarial examples via the convex outer adversarial polytope. In International Conference on Machine Learning, pp. 5283–5292, 2018.
+
+Eric Wong, Frank Schmidt, Jan Hendrik Metzen, and J Zico Kolter. Scaling provable adversarial defenses. In NIPS, 2018.
+
+Kaidi Xu, Zhouxing Shi, Huan Zhang, Yihan Wang, Kai-Wei Chang, Minlie Huang, Bhavya Kailkhura, Xue Lin, and Cho-Jui Hsieh. Automatic perturbation analysis for scalable certified robustness and beyond. Advances in Neural Information Processing Systems, 33, 2020.
+
+Huan Zhang, Tsui-Wei Weng, Pin-Yu Chen, Cho-Jui Hsieh, and Luca Daniel. Efficient neural network robustness certification with general activation functions. In Advances in neural information processing systems, pp. 4939–4948, 2018.
+
+Huan Zhang, Hongge Chen, Chaowei Xiao, Bo Li, Duane Boning, and Cho-Jui Hsieh. Towards stable and efficient training of verifiably robust neural networks. In International Conference on Learning Representations, 2020.
+
+# A PROOFS
+
+# A.1 PROOF OF THEOREM 3.1
+
+We prove Theorem 3.1 by providing a simple counterexample, and we illustrate the necessity of feasibility checking for the completeness of BaB based verification. Consider an NN with only two ReLU units $g _ { 1 } ^ { ( 2 ) } = \mathrm { R e L U } ( h _ { 1 } ^ { ( 2 ) } )$ and $g _ { 2 } ^ { ( 2 ) } = \mathrm { R e L U } ( h _ { 2 } ^ { ( 2 ) } )$ where they share the same one dimension input h(2)1 $h _ { 1 } ^ { ( 2 ) } = h _ { 2 } ^ { ( 2 ) } = x$ . The final output function of NN is defined as $f = g _ { 1 } ^ { ( 2 ) } - g _ { 2 } ^ { ( 2 ) }$ As a verification problem, we want to verify the property $f \geq 0$ where $x = [ - 1 , 1 ]$ . Since hidden nodes $h _ { 1 }$ and $h _ { 2 }$ are exactly the same, the ground-truth output range is $f ^ { * } ( x ) \in [ 0 , 0 ]$ . A complete BaB based verifier is expected to obtain that optimal bound and prove the property after splitting $h _ { 1 }$ and $h _ { 2 }$ together while BaB with only LiPRA cannot guarantee that completeness. Specifically, BaB with only LiRPA will split the original domain $x \in [ - 1 , 1 ]$ into four sub-domains and approximate the bound with LiRPA respectively:
+
+(1) (feasible) sub-domain $x \in [ - 1 , 1 ] , h _ { 1 } ^ { ( 2 ) } \geq 0 , h _ { 2 } ^ { ( 2 ) } \geq 0 \mathrm { ~ w i t h ~ o u t p u t ~ } f = [ x , x ] - [ x , x ] \in [ 0 , 0 ]$ (2) (feasible) sub-domain $x \in [ - 1 , 1 ] , h _ { 1 } ^ { ( 2 ) } < 0 , h _ { 2 } ^ { ( 2 ) } < 0$ with output $f = [ 0 , 0 ] - [ 0 , 0 ] \in [ 0 , 0 ]$ (3) (infeasible) sub-domain $x \in [ - 1 , 1 ] , h _ { 1 } ^ { ( 2 ) } < 0 , h _ { 2 } ^ { ( 2 ) } \geq 0$ with output $f = [ 0 , 0 ] - [ x , x ] \in [ - 1 , 1 ]$ (4) (infeasible) sub-domain $x \in [ - 1 , 1 ] , h _ { 1 } ^ { ( 2 ) } \geq 0 , h _ { 2 } ^ { ( 2 ) } < 0$ with output $f = [ x , x ] - [ 0 , 0 ] \in [ - 1 , 1 ]$
+
+Only the first two split sub-domains are feasible and therefore the ground-truth lower bound 0 can be obtained by taking the minimum of the estimated bounds from sub-domains (1) and (2). However, pure LiRPA is not able to tell the infeasibility of sub-domains (3) and (4) and thus BaB with pure LiRPA will report the minimum $- 1$ got from all these four sub-domains as the global lower bound for the original input domain, ending up not being able to verify the property, i.e., incomplete.
+
+# A.2 PROOF OF THEOREM 3.2
+
+We prove Theorem 3.2 by considering the worst case where all unstable ReLU neurons are split.
+
+Given a neural network function $f$ with input domain $\mathcal { C }$ , assume there are $N$ unstable ReLU neurons $\{ g _ { i } = \mathrm { R e L U } ( h _ { i } ) | i = 1 , \cdot \cdot \cdot , N \}$ in total. In the worst case, we have $2 ^ { N }$ leaf sub-domains ${ \boldsymbol { s } } =$ $\{ \mathcal { C } _ { i } | i = 1 , \cdots , 2 ^ { N } \}$ , where each $\mathcal { C } _ { i }$ corresponds to one assignment of unstable ReLU neuron splits. For example, we can have
+
+$$
+\begin{array} { r l } & { { \mathcal { C } } _ { 1 } = { \mathcal { C } } \cap ( h _ { 1 } \geq 0 ) \cap ( h _ { 2 } \geq 0 ) \cap \cdots \cap ( h _ { N } \geq 0 ) } \\ & { { \mathcal { C } } _ { 2 } = { \mathcal { C } } \cap ( h _ { 1 } < 0 ) \cap ( h _ { 2 } \geq 0 ) \cap \cdots \cap ( h _ { N } \geq 0 ) } \\ & { { \mathcal { C } } _ { 3 } = { \mathcal { C } } \cap ( h _ { 1 } \geq 0 ) \cap ( h _ { 2 } < 0 ) \cap \cdots \cap ( h _ { N } \geq 0 ) } \\ & { { \mathcal { C } } _ { 4 } = { \mathcal { C } } \cap ( h _ { 1 } < 0 ) \cap ( h _ { 2 } < 0 ) \cap \cdots \cap ( h _ { N } \geq 0 ) } \\ & { \qquad \cdots \qquad } \end{array}
+$$
+
+Note that by definition the original input domain $\mathcal { C } = \cup _ { \mathcal { C } ^ { \prime } \in \mathcal { S } } \mathcal { C } ^ { \prime }$ ; in other words, all the $2 ^ { N }$ split sub-domains combined will be the same as the original input domain.
+
+Not all of the sub-domains are actually feasible, due to the consistency requirements between neurons. For example, in our proof in Section A.1, $h _ { 1 } ^ { ( 2 ) }$ and $h _ { 2 } ^ { ( 2 ) }$ cannot be both $\geq 0$ or both $< 0$ . We can divide the sub-domains $s$ into two mutually exclusive sub-sets, $S ^ { \mathrm { f e a s } }$ for all the feasible sub-domains, and $S ^ { \mathrm { i n f e a s } }$ for all the infeasible sub-domains. We have $\mathcal { C } = \cup _ { \mathcal { C } ^ { \prime } \in \mathcal { S } ^ { \mathrm { f e a s } } } \mathcal { C } ^ { \prime }$ since these infeasible sub-domains are empty sets.
+
+We first show that linear programming (LP) can be used to effectively detect these infeasible subdomains. For some $\mathcal { C } ^ { \prime } \in \mathrm { \bar { \mathcal { S } } ^ { \mathrm { i n f \bar { e } a s } } }$ , because all the ReLU neurons are fixed to be positive or negative, no relaxation is needed and the network is essentially linear; thus, the input value of every hidden neuron $h _ { i }$ can be written as a linear equation w.r.t. input $x$ . We add all the Boolean predicates on $h _ { i }$ to a LP problem as linear constraints w.r.t $x$ . If this LP is feasible, then we can find some input $x _ { 0 }$ that assigns compatible values to all $h _ { i }$ ; otherwise, the LP is infeasible.
+
+Due to the lack of feasibility checking in LiRPA, the computed global lower (or upper) bounds from LiRPA is $\begin{array} { r } { \underline { { f } } _ { \mathrm { L i R P A } } = \operatorname* { m i n } _ { \mathcal { C } ^ { \prime } \in S } \underline { { f } } _ { \mathcal { C } ^ { \prime } } = \operatorname* { m i n } \left( \operatorname* { m i n } _ { \mathcal { C } ^ { \prime } \in S ^ { \mathrm { f e a s } } } \underline { { f } } _ { \mathcal { C } ^ { \prime } } , \operatorname* { m i n } _ { \mathcal { C } ^ { \prime } \in S ^ { \mathrm { i n f e a s } } } \underline { { f } } _ { \mathcal { C } ^ { \prime } } \right) } \end{array}$ . With feasibility checking from LP, we can remove all infeasible sub-domains from this min such that they do not contribute to the global lower bound: $\underline { { f } } = \operatorname* { m i n } _ { \scriptstyle { \mathcal { C } } ^ { \prime } \in S ^ { \mathrm { f e a s } } } \underline { { f } } _ { \boldsymbol { \mathcal { C } } ^ { \prime } }$ .
+
+To prove the whole BaB verification is complete, it is sufficient to prove this lower bound $\underline { { f } }$ is the exact minimum of $f$ bounded in $\mathcal { C }$ . Since any sub-domain $\mathcal { C } ^ { \prime } \in \mathcal { S } ^ { \mathrm { f e a s } }$ is a leaf sub-domain with no unstable ReLU neurons, the neural network bounded within $\mathcal { C } ^ { \prime }$ is a linear function. LiRPA can give an exact minimum of $f$ within sub-domain $\mathcal { C } ^ { \prime }$ . Since $\mathcal { C } = \cup _ { \mathcal { C } ^ { \prime } \in \mathcal { S } ^ { \mathrm { f e a s } } } \mathcal { C } ^ { \prime }$ (in other words, $S ^ { \mathrm { f e a s } }$ covers all the feasible sub-domains within $\mathcal { C }$ ), the minimal value for all of them $\underline { { f } } = \operatorname* { m i n } _ { \scriptstyle { \mathcal { C } ^ { \prime } } \in S ^ { \mathrm { f e a s } } } \underline { { f } } _ { \boldsymbol { \mathcal { C } ^ { \prime } } }$ forms the exact minimum of $f$ within the input domain $\mathcal { C }$ . Thus, BaB with LiRPA based bounding procedure is complete when feasibility checking is applied.
+
+# B EXPERIMENTAL SETUP
+
+We use the same set of models and benchmark examples used in the state-of-the-art verifiers GNNONLINE (Lu & Kumar, 2020) and BABSR (Bunel et al., 2020b). Specifically, we evaluate on the most challenging CIFAR-10 dataset with the same standard robustly trained convolutional neural networks: Base, Wide, and Deep. These model structures are also used in (Lu & Kumar, 2020; Bunel et al., 2020a). The Base model contains 2 convolution layers with 8 and 16 filters as well as two linear layers with 100 and 10 hidden units, respectively. In total, the Base model has 3,172 ReLU activation units. The Wide model contains 2 convolution layers with 16 and 32 filters and two linear layers with 100 and 10 hidden units, respectively, which contains 6,244 ReLU activation units in total. The Deep model contains 4 convolution layers and all of them have 8 filters and two linear layers with 100 and 10 hidden units, respectively, with 3,756 ReLU activation units in total. The source code of BABSR, MIPPLANET, GNN and GNN-ONLINE are available at https: //github.com/oval-group/GNN_branching. The source code of PROXIMAL BABSR is available at https://github.com/verivital/vnn-comp by replacing the dataset to the same one we used here.
+
+Given an correctly classified image $x$ with label $y _ { c }$ , and another wrong label $y _ { c ^ { \prime } } \ne y _ { c }$ (pre-defined in this benchmark) and $\epsilon$ , the verifier needs to prove:
+
+$$
+( e ^ { ( c ) } - e ^ { ( c ^ { \prime } ) } ) ^ { T } f ( x ^ { \prime } ) > 0 \qquad \mathrm { s . t } \forall x ^ { \prime } \quad \| x - x ^ { \prime } \| _ { \infty } \leq \epsilon
+$$
+
+where $f ( \cdot )$ is the logit-layer output of a multi-class classifier, $e ^ { ( c ) }$ and $e ^ { ( c ^ { \prime } ) }$ are one-hot encoding vectors for labels $y _ { c }$ and $y _ { c ^ { \prime } }$ . We want to verify that for a given $\epsilon$ , the trained classifier will not predict wrong label $y _ { c ^ { \prime } }$ for image $x$ . All properties including $x , \epsilon .$ , and $c ^ { \prime }$ are provided by (Lu & Kumar, 2020). Specifically, they categorize verification properties solved by BABSR within 800s as easy, between 800s and 2400s as medium and more than 2400s as hard.
+
+Our experiments are conducted on one Intel I7-7700K CPU and one Nvidia GTX 1080 Ti GPU. The parallel batch size $n$ is set to 400, 200 and 200 for base, wide and deep model respectively and the $\eta$ is set to 12,000 due to GPU memory constraint. To make a fair comparison, we use one CPU core for all methods. Also, we use one GPU for GNN, GNN-ONLINE, PROXIMAL-BABSR and our method. When optimizing the LiRPA bounds, we apply 100 steps gradient decent for obtaining the initial $f$ (Line 2 in Algorithm 1). After that, we use 10 steps gradient decent (Line 7) and early stop once $\underline { { \bar { f } } } > 0$ or $\underline { { f } }$ has no improvement.
+
+# C ABLATION STUDY
+
+Our efficient framework leverages two powerful components: (1) optimized LiRPA bounds and (2) batch splits on GPUs. In this section, we conduct breakdown experiments to show how each individual technique can help with complete verification. As we can see in Table 2, using batched split with unoptimized LiRPA is not very successful and cannot beat BABSR. We observe that, without optimized LiRPA, the bounds are very loose and cannot quickly improve the global lower bound. In contrast, using optimized LiRPA bounds without batch splits (splitting a single node at a time and running a batch size of 1 on GPU) can still significantly speed up complete verification, around $2 \sim 1 0 \mathrm { X }$ compared to BABSR. Finally, combining batch splits and optimized LiRPA allows us to gain up to 44X speedup compared to BABSR.
+
+Table 2: Ablation study for different components of our algorithm. The speedup rate is computed based on running time of BABSR baseline: speedup $=$ Time of BaBSR/Time of our method.   
+
+<table><tr><td></td><td colspan="2">Easy</td><td colspan="2">Medium</td><td colspan="2">Hard</td><td colspan="2">Wide</td><td colspan="2">Deep</td></tr><tr><td>Method</td><td>time(s)</td><td>speedup</td><td>time(s)</td><td>speedup</td><td>time(s)</td><td>speedup</td><td>time(s)</td><td>speedup</td><td>time(s)</td><td>speedup</td></tr><tr><td>BABSRbaseline</td><td>522.48</td><td></td><td>1335.40</td><td></td><td>2875.16</td><td></td><td>3325.65</td><td></td><td>2855.19</td><td></td></tr><tr><td>Batch Splits (unoptimized LiRPA)</td><td>587.10</td><td>0.89</td><td>1470.02</td><td>0.91</td><td>3013.57</td><td>0.95</td><td>3457.30</td><td>0.96</td><td>2998.50</td><td>0.95</td></tr><tr><td>Optimized LiRPA (no batch splits)</td><td>94.08</td><td>5.58</td><td>361.53</td><td>3.70</td><td>1384.22</td><td>2.07</td><td>736.56</td><td>4.51</td><td>287.33</td><td>9.94</td></tr><tr><td>Optimized LiRPA&amp;Batch Splits</td><td>11.86</td><td>44.05</td><td>42.04</td><td>31.80</td><td>633.85</td><td>4.53</td><td>375.23</td><td>8.86</td><td>81.55</td><td>35.01</td></tr></table>
+
+# D COMPLETE VERIFICATION WITH LiRPA ON CPU VS GPU
+
+For a fair comparison, we only use one CPU core and one GPU (the same as GNN and GNNONLINE) in our experimental results in Section 4. In this section, we investigate the performance of our algorithm for the cases where one or multiple CPU cores are available without GPU acceleration. Note that existing baselines such as BABSR and MIPPLANET can only effectively utilize one CPU core subject to the Gurobi solver. GNN and GNN-ONLINE can utilize one GPU to run the GNN during branching while the rest of the verification processes all perform on one CPU core. In contrast, our method is much more flexible, and we are not limited by the number of CPU cores or GPUs. When running on multi-core CPUs, LiRPA can be automatically accelerated by the underlying linear algebra library (e.g., Intel MKL or OpenBLAS) since the main computation of LiRPA is just matrix multiplications.
+
+In Figure 5, we show the performance of our algorithm on a single CPU core and multiple CPU cores (in blue), and compare it to our main results with one CPU core plus one GPU (in red). As we can see, the running time decreases when the number of CPU cores increases, but the speedup is not linear due to the limitation of the underlying linear algebra library and hardware. There is a big gap between the running time on 8 CPU cores and the time on one CPU core $^ +$ one GPU, and the performance gap is more obvious on Wide and Deep models. Thus, the speedup of LiRPA computation on GPUs is significant. However, surprisingly, even when using only one CPU core, we are still significantly faster than baseline BABSR and also get very competitive performance when compared to GNN-ONLINE which needs one GPU additionally. This shows the efficiency of LiRPA based verification algorithms.
+
+![](images/b2b40cf2e3fbf49a1424e231f3de29e34fdc5c82f3aa969b26f8ba4a869d5138.jpg)  
+Figure 5: Running time of our method on the Base, Wide, and Deep networks when using 1, 2, 4 and 8 CPU cores without a GPU (blue), and our method using 1 CPU core $^ { + 1 }$ GPU (red) and a strong baseline method, GNN-ONLINE (green). We report the baseline BABSR verification time in captions because they are out of range on the figures.

parse/train/r1aPbsFle/r1aPbsFle.md

@@ -0,0 +1,287 @@
+# TYING WORD VECTORS AND WORD CLASSIFIERS:A LOSS FRAMEWORK FOR LANGUAGE MODELING
+
+Hakan Inan, Khashayar Khosravi   
+Stanford University   
+Stanford, CA, USA   
+{inanh,khosravi}@stanford.edu   
+Richard Socher   
+Salesforce Research   
+Palo Alto, CA, USA   
+rsocher@salesforce.com
+
+# ABSTRACT
+
+Recurrent neural networks have been very successful at predicting sequences of words in tasks such as language modeling. However, all such models are based on the conventional classification framework, where the model is trained against one-hot targets, and each word is represented both as an input and as an output in isolation. This causes inefficiencies in learning both in terms of utilizing all of the information and in terms of the number of parameters needed to train. We introduce a novel theoretical framework that facilitates better learning in language modeling, and show that our framework leads to tying together the input embedding and the output projection matrices, greatly reducing the number of trainable variables. Our framework leads to state of the art performance on the Penn Treebank with a variety of network models.
+
+# 1 INTRODUCTION
+
+Neural network models have recently made tremendous progress in a variety of NLP applications such as speech recognition (Irie et al., 2016), sentiment analysis (Socher et al., 2013), text summarization (Rush et al., 2015; Nallapati et al., 2016), and machine translation (Firat et al., 2016).
+
+Despite the overwhelming success achieved by recurrent neural networks in modeling long range dependencies between words, current recurrent neural network language models (RNNLM) are based on the conventional classification framework, which has two major drawbacks: First, there is no assumed metric on the output classes, whereas there is evidence suggesting that learning is improved when one can define a natural metric on the output space (Frogner et al., 2015). In language modeling, there is a well established metric space for the outputs (words in the language) based on word embeddings, with meaningful distances between words (Mikolov et al., 2013; Pennington et al., 2014). Second, in the classical framework, inputs and outputs are considered as isolated entities with no semantic link between them. This is clearly not the case for language modeling, where inputs and outputs in fact live in identical spaces. Therefore, even for models with moderately sized vocabularies, the classical framework could be a vast source of inefficiency in terms of the number of variables in the model, and in terms of utilizing the information gathered by different parts of the model (e.g. inputs and outputs).
+
+In this work, we introduce a novel loss framework for language modeling to remedy the above two problems. Our framework is comprised of two closely linked improvements. First, we augment the classical cross-entropy loss with an additional term which minimizes the KL-divergence between the model’s prediction and an estimated target distribution based on the word embeddings space. This estimated distribution uses knowledge of word vector similarity. We then theoretically analyze this loss, and this leads to a second and synergistic improvement: tying together two large matrices by reusing the input word embedding matrix as the output classification matrix. We empirically validate our theory in a practical setting, with much milder assumptions than those in theory. We also find empirically that for large networks, most of the improvement could be achieved by only reusing the word embeddings.
+
+We test our framework by performing extensive experiments on the Penn Treebank corpus, a dataset widely used for benchmarking language models (Mikolov et al., 2010; Merity et al., 2016). We demonstrate that models trained using our proposed framework significantly outperform models trained using the conventional framework. We also perform experiments on the newly introduced Wikitext-2 dataset (Merity et al., 2016), and verify that the empirical performance of our proposed framework is consistent across different datasets.
+
+# 2 BACKGROUND: RECURRENT NEURAL NETWORK LANGUAGE MODEL
+
+In any variant of recurrent neural network language model (RNNLM), the goal is to predict the next word indexed by $t$ in a sequence of one-hot word tokens $( y _ { 1 } ^ { * } , \dots y _ { N } ^ { * } )$ as follows:
+
+$$
+\begin{array} { r l } & { x _ { t } = L y _ { t - 1 } ^ { * } , } \\ & { h _ { t } = f ( x _ { t } , h _ { t - 1 } ) , } \\ & { y _ { t } = \mathrm { s o f t m a x } \left( W h _ { t } + b \right) . } \end{array}
+$$
+
+The matrix $L \in \mathbb { R } ^ { d _ { x } \times | V | }$ is the word embedding matrix, where $d _ { x }$ is the word embedding dimension and $| V |$ is the size of the vocabulary. The function $f ( . , . )$ represents the recurrent neural network which takes in the current input and the previous hidden state and produces the next hidden state. $W \in \mathbb { R } ^ { | V | \times d _ { h } }$ and $b \in \mathbb { R } ^ { | V | }$ are the the output projection matrix and the bias, respectively, and $d _ { h }$ is the size of the RNN hidden state. The $| V |$ dimensional $y _ { t }$ models the discrete probability distribution for the next word.
+
+Note that the above formulation does not make any assumptions about the specifics of the recurrent neural units, and $f$ could be replaced with a standard recurrent unit, a gated recurrent unit (GRU) (Cho et al., 2014), a long-short term memory (LSTM) unit (Hochreiter & Schmidhuber, 1997), etc. For our experiments, we use LSTM units with two layers.
+
+Given $y _ { t }$ for the $t ^ { \mathrm { { t h } } }$ example, a loss is calculated for that example. The loss used in the RNNLMs is almost exclusively the cross-entropy between $y _ { t }$ and the observed one-hot word token, ${ \boldsymbol y } _ { t } ^ { * }$ :
+
+$$
+J _ { t } = \mathbf { C E } ( y _ { t } ^ { * } \parallel y _ { t } ) = - \sum _ { i \in | V | } y _ { t , i } ^ { * } \log y _ { t , i } .
+$$
+
+We shall refer to $y _ { t }$ as the model prediction distribution for the $t ^ { \mathrm { { t h } } }$ example, and $\boldsymbol { y } _ { t } ^ { * }$ as the empirical target distribution (both are in fact conditional distributions given the history). Since crossentropy and Kullback-Leibler divergence are equivalent when the target distribution is one-hot, we can rewrite the loss for the $t ^ { \mathrm { { t h } } }$ example as
+
+$$
+J _ { t } = \mathbf { D } _ { K L } ( y _ { t } ^ { * } \parallel y _ { t } ) .
+$$
+
+Therefore, we can think of the optimization of the conventional loss in an RNNLM as trying to minimize the distance1 between the model prediction distribution $( y )$ and the empirical target distribution $( y ^ { \ast } )$ , which, with many training examples, will get close to minimizing distance to the actual target distribution. In the framework which we will introduce, we utilize Kullback-Leibler divergence as opposed to cross-entropy due to its intuitive interpretation as a distance between distributions, although the two are not equivalent in our framework.
+
+# 3 AUGMENTING THE CROSS-ENTROPY LOSS
+
+We propose to augment the conventional cross-entropy loss with an additional loss term as follows:
+
+$$
+\begin{array} { r } { \hat { y } _ { t } = \operatorname { s o f t m a x } \left( W h _ { t } / \tau \right) , } \\ { J _ { t } ^ { a u g } = \operatorname { \mathrm { D } } _ { K L } ( \tilde { y } _ { t } \parallel \hat { y } _ { t } ) , ~ } \\ { J _ { t } ^ { t o t } = J _ { t } + \alpha J _ { t } ^ { a u g } . ~ } \end{array}
+$$
+
+In above, $\alpha$ is a hyperparameter to be adjusted, and $\hat { y } _ { t }$ is almost identical to the regular model prediction distribution $y _ { t }$ with the exception that the logits are divided by a temperature parameter $\tau$ . We define $\tilde { y } _ { t }$ as some probability distribution that estimates the true data distribution (conditioned on the word history) which satisfies $\mathbb { E } \tilde { y } _ { t } = \mathbb { E } y _ { t } ^ { * }$ . The goal of this framework is to minimize the distribution distance between the prediction distribution and a more accurate estimate of the true data distribution.
+
+To understand the effect of optimizing in this setting, let’s focus on an ideal case in which we are given the true data distribution so that $\tilde { y } _ { t } = \mathbb { E } y _ { t } ^ { * }$ , and we only use the augmented loss, $J ^ { a u g }$ . We will carry out our investigation through stochastic gradient descent, which is the technique dominantly used for training neural networks. The gradient of ${ J } _ { t } ^ { a u g }$ with respect to the logits $W h _ { t }$ is
+
+$$
+\nabla { J _ { t } ^ { a u g } } = \frac { 1 } { \tau } ( \hat { y } _ { t } - \tilde { y } _ { t } ) .
+$$
+
+Let’s denote by $e _ { j } \in \mathbb { R } ^ { | V | }$ the vector whose $j ^ { \mathrm { t h } }$ entry is 1, and others are zero. We can then rewrite (3.4) as
+
+$$
+\tau \nabla { \cal J } _ { t } ^ { a u g } = \widehat { y } _ { t } - \left[ e _ { 1 } , \ldots , e _ { | V | } \right] \tilde { y } _ { t } = \sum _ { i \in V } \tilde { y } _ { t , i } ( \widehat { y } _ { t } - e _ { i } ) .
+$$
+
+Implication of (3.5) is the following: Every time the optimizer sees one training example, it takes a step not only on account of the label seen, but it proceeds taking into account all the class labels for which the conditional probability is not zero, and the relative step size for each step is given by the conditional probability for that label, $\tilde { y } _ { t , i }$ . Furthermore, this is a much less noisy update since the target distribution is exact and deterministic. Therefore, unless all the examples exclusively belong to a specific class with probability 1, the optimization will act much differently and train with greatly improved supervision.
+
+The idea proposed in the recent work by Hinton et al. (2015) might be considered as an application of this framework, where they try to obtain a good set of $\tilde { y }$ ’s by training very large models and using the model prediction distributions of those.
+
+Although finding a good $\tilde { y }$ in general is rather nontrivial, in the context of language modeling we can hope to achieve this by exploiting the inherent metric space of classes encoded into the model, namely the space of word embeddings. Specifically, we propose the following for $\tilde { y }$ :
+
+$$
+\begin{array} { l } { { \displaystyle { u _ { t } = L y _ { t } ^ { * } , } } } \\ { { \displaystyle \tilde { y } _ { t } = \mathrm { s o f t m a x } \left( \frac { L ^ { T } u _ { t } } { \tau } \right) . } } \end{array}
+$$
+
+In words, we first find the target word vector which corresponds to the target word token (resulting in $u _ { t }$ ), and then take the inner product of the target word vector with all the other word vectors to get an unnormalized probability distribution. We adjust this with the same temperature parameter $\tau$ used for obtaining $\hat { y } _ { t }$ and apply softmax. The target distribution estimate, $\tilde { y }$ , therefore measures the similarity between the word vectors and assigns similar probability masses to words that the language model deems close. Note that the estimation of $\tilde { y }$ with this procedure is iterative, and the estimates of $\tilde { y }$ in the initial phase of the training are not necessarily informative. However, as training procedes, we expect $\tilde { y }$ to capture the word statistics better and yield a consistently more accurate estimate of the true data distribution.
+
+# 4 THEORETICALLY DRIVEN REUSE OF WORD EMBEDDINGS
+
+We now theoretically motivate and introduce a second modification to improve learning in the language model. We do this by analyzing the proposed augmented loss in a particular setting, and observe an implicit core mechanism of this loss. We then make our proposition by making this mechanism explicit.
+
+We start by introducing our setting for the analysis. We restrict our attention to the case where the input embedding dimension is equal to the dimension of the RNN hidden state, i.e. $d \triangleq d _ { x } = d _ { h }$ . We also set $b = 0$ in (2.3) so that $y _ { t } = W h _ { t }$ . We only use the augmented loss, i.e. ${ J ^ { t o t } = J ^ { a u g } }$ , and we assume that we can achieve zero training loss. Finally, we set the temperature parameter $\tau$ to be large.
+
+We first show that when the temperature parameter, $\tau$ , is high enough, ${ J } _ { t } ^ { a u g }$ acts to match the logits of the prediction distribution to the logits of the the more informative labels, $\tilde { y }$ . We proceed in the same way as was done in Hinton et al. (2015) to make an identical argument. Particularly, we consider the derivative of ${ J } _ { t } ^ { a u g }$ with respect to the entries of the logits produced by the neural network.
+
+Let’s denote by $l _ { i }$ the $i ^ { \mathrm { { t h } } }$ column of L. Using the first order approximation of exponential function around zero $( \exp { ( x ) } \approx 1 + x )$ ), we can approximate $\tilde { y } _ { t }$ (same holds for $\hat { y } _ { t } ^ { \phantom { } }$ ) at high temperatures as follows:
+
+$$
+\tilde { y } _ { t , i } = \frac { \exp { ( \langle u _ { t } , l _ { i } \rangle / \tau ) } } { \sum _ { j \in V } \exp { ( \langle u _ { t } , l _ { j } \rangle / \tau ) } } \approx \frac { 1 + \langle u _ { t } , l _ { i } \rangle / \tau } { \lvert V \rvert + \sum _ { j \in V } \langle u _ { t } , l _ { j } \rangle / \tau } .
+$$
+
+We can further simplify (4.1) if we assume that $\langle u _ { t } , l _ { j } \rangle = 0$ on average:
+
+$$
+\tilde { y } _ { t , i } \approx \frac { 1 + \langle u _ { t } , l _ { i } \rangle / \tau } { | V | } .
+$$
+
+By replacing $\tilde { y } _ { t }$ and $\hat { y } _ { t }$ in (3.4) with their simplified forms according to (4.2), we get
+
+$$
+\frac { \partial J _ { t } ^ { a u g } } { \partial \left( W h _ { t } \right) _ { i } } \to \frac { 1 } { \tau ^ { 2 } | V | } \left( W h _ { t } - L ^ { T } u _ { t } \right) _ { i } \mathrm { a s } \tau \to \infty ,
+$$
+
+which is the desired result that augmented loss tries to match the logits of the model to the logits of $\tilde { y }$ ’s. Since the training loss is zero by assumption, we necessarily have
+
+$$
+W h _ { t } = L ^ { T } u _ { t }
+$$
+
+for each training example, i.e., gradient contributed by each example is zero. Provided that $W$ and $L$ are full rank matrices and there are more linearly independent examples of $h _ { t }$ ’s than the embedding dimension $d$ , we get that the space spanned by the columns of $L ^ { T }$ is equivalent to that spanned by the columns of $W$ . Let’s now introduce a square matrix $A$ such that $W \overset { \cdot } { = } L ^ { T } A$ . (We know $A$ exists since $L ^ { T }$ and $W$ span the same column space). In this case, we can rewrite
+
+$$
+W h _ { t } = L ^ { T } A h _ { t } \triangleq L ^ { T } \tilde { h } _ { t } .
+$$
+
+In other words, by reusing the embedding matrix in the output projection layer (with a transpose) and letting the neural network do the necessary linear mapping $h  A h$ , we get the same result as we would have in the first place.
+
+Although the above scenario could be difficult to exactly replicate in practice, it uncovers a mechanism through which our proposed loss augmentation acts, which is trying to constrain the output (unnormalized) probability space to a small subspace governed by the embedding matrix. This suggests that we can make this mechanism explicit and constrain $W \overset { \cdot } { = } L ^ { T }$ during training while setting the output bias, $b$ , to zero. Doing so would not only eliminate a big matrix which dominates the network size for models with even moderately sized vocabularies, but it would also be optimal in our setting of loss augmentation as it would eliminate much work to be done by the augmented loss.
+
+# 5 RELATED WORK
+
+Since their introduction in Mikolov et al. (2010), many improvements have been proposed for RNNLMs , including different dropout methods (Zaremba et al., 2014; Gal, 2015), novel recurrent units (Zilly et al., 2016), and use of pointer networks to complement the recurrent neural network (Merity et al., 2016). However, none of the improvements dealt with the loss structure, and to the best of our knowledge, our work is the first to offer a new loss framework.
+
+Our technique is closely related to the one in Hinton et al. (2015), where they also try to estimate a more informed data distribution and augment the conventional loss with KL divergence between model prediction distribution and the estimated data distribution. However, they estimate their data distribution by training large networks on the data and then use it to improve learning in smaller networks. This is fundamentally different from our approach, where we improve learning by transferring knowledge between different parts of the same network, in a self contained manner.
+
+The work we present in this paper is based on a report which was made public in Inan & Khosravi (2016). We have recently come across a concurrent preprint (Press & Wolf, 2016) where the authors reuse the word embedding matrix in the output projection to improve language modeling.
+
+However, their work is purely empirical, and they do not provide any theoretical justification for their approach. Finally, we would like to note that the idea of using the same representation for input and output words has been explored in the past, and there exists language models which could be interpreted as simple neural networks with shared input and output embeddings (Bengio et al., 2001; Mnih & Hinton, 2007). However, shared input and output representations were implicitly built into these models, rather than proposed as a supplement to a baseline. Consequently, possibility of improvement was not particularly pursued by sharing input and output representations.
+
+# 6 EXPERIMENTS
+
+In our experiments, we use the Penn Treebank corpus (PTB) (Marcus et al., 1993), and the Wikitext2 dataset (Merity et al., 2016). PTB has been a standard dataset used for benchmarking language models. It consists of 923k training, 73k validation, and 82k test words. The version of this dataset which we use is the one processed in Mikolov et al. (2010), with the most frequent 10k words selected to be in the vocabulary and rest replaced with a an ${ \tt c u n k } >$ token 2. Wikitext-2 is a dataset released recently as an alternative to $\mathrm { P T B } ^ { 3 }$ . It contains 2, 088k training, 217k validation, and $2 4 5 \mathrm { k }$ test tokens, and has a vocabulary of 33, 278 words; therefore, in comparison to PTB, it is roughly 2 times larger in dataset size, and 3 times larger in vocabulary.
+
+# 6.1 MODEL AND TRAINING HIGHLIGHTS
+
+We closely follow the LSTM based language model proposed in Zaremba et al. (2014) for constructing our baseline model. Specifically, we use a 2-layer LSTM with the same number of hidden units in each layer, and we use 3 different network sizes: small (200 units), medium (650 units), and large (1500 units). We train our models using stochastic gradient descent, and we use a variant of the dropout method proposed in Gal (2015). We defer further details regarding training the models to section A of the appendix. We refer to our baseline network as variational dropout LSTM, or VD-LSTM in short.
+
+# 6.2 EMPIRICAL VALIDATION FOR THE THEORY OF REUSING WORD EMBEDDINGS
+
+In Section 4, we showed that the particular loss augmentation scheme we choose constrains the output projection matrix to be close to the input embedding matrix, without explicitly doing so by reusing the input embedding matrix. As a first experiment, we set out to validate this theoretical result. To do this, we try to simulate the setting in Section 4 by doing the following: We select a randomly chosen 20, 000 contiguous word sequence in the PTB training set, and train a 2-layer LSTM language model with 300 units in each layer with loss augmentation by minimizing the following loss:
+
+$$
+J ^ { t o t } = \beta J ^ { a u g } \tau ^ { 2 } | V | + ( 1 - \beta ) J .
+$$
+
+Here, $\beta$ is the proportion of the augmented loss used in the total loss, and $J ^ { a u g }$ is scaled by $\tau ^ { 2 } | V |$ to approximately match the magnitudes of the derivatives of $J$ and $J ^ { a u g }$ (see (4.3)). Since we aim to achieve the minimum training loss possible, and the goal is to show a particular result rather than to achieve good generalization, we do not use any kind of regularization in the neural network (e.g. weight decay, dropout). For this set of experiments, we also constrain each row of the input embedding matrix to have a norm of 1 because training becomes difficult without this constraint when only augmented loss is used. After training, we compute a metric that measures distance between the subspace spanned by the rows of the input embedding matrix, $L$ , and that spanned by the columns of the output projection matrix, $W$ . For this, we use a common metric based on the relative residual norm from projection of one matrix onto another (Bjorck & Golub ¨ , 1973). The computed distance between the subspaces is 1 when they are orthogonal, and 0 when they are the same. Interested reader may refer to section B in the appendix for the details of this metric.
+
+Figure 1 shows the results from two tests. In one (panel a), we test the effect of using the augmented loss by sweeping $\beta$ in (6.1) from 0 to 1 at a reasonably high temperature $\tau = 1 0$ ). With no loss augmentation ( $\beta = 0$ ), the distance is almost 1, and as more and more augmented loss is used the distance decreases rapidly, and eventually reaches around 0.06 when only augmented loss is used. In the second test (panel b), we set $\beta = 1$ , and try to see the effect of the temperature on the subspace distance (remember the theory predicts low distance when $\tau  \infty$ ). Notably, the augmented loss causes $W$ to approach $L ^ { T }$ sufficiently even at temperatures as low as 2, although higher temperatures still lead to smaller subspace distances.
+
+![](images/c8f6c4ac0b38cd5adff94c8df284c9ca2ca5c16a5d356924d8c4d7a5774c909c.jpg)  
+Figure 1: Subspace distance between $L ^ { T }$ and $W$ for different experiment conditions for the validation experiments. Results are averaged over 10 independent runs. These results validate our theory under practical conditions.
+
+These results confirm the mechanism through which our proposed loss pushes $W$ to learn the same column space as $L ^ { T }$ , and it suggests that reusing the input embedding matrix by explicitly constraining $\mathbf { \bar { \boldsymbol { W } } } = \mathbf { \boldsymbol { L } } ^ { T }$ is not simply a kind of regularization, but is in fact an optimal choice in our framework. What can be achieved separately with each of the two proposed improvements as well as with the two of them combined is a question of empirical nature, which we investigate in the next section.
+
+# 6.3 RESULTS ON PTB AND WIKITEXT-2 DATASETS
+
+In order to investigate the extent to which each of our proposed improvements helps with learning, we train 4 different models for each network size: (1) 2-Layer LSTM with variational dropout (VD-LSTM) (2) 2-Layer LSTM with variational dropout and augmented loss (VD-LSTM $+ \mathrm { A L }$ ) (3) 2-Layer LSTM with variational dropout and reused embeddings (VD-LSTM $+ \mathrm { R E }$ ) (4) 2-Layer LSTM with variational dropout and both RE and AL (VD-LSTM $+ \mathrm { R E A L }$ ).
+
+Figure 2 shows the validation perplexities of the four models during training on the PTB corpus for small (panel a) and large (panel b) networks. All of AL, RE, and REAL networks significantly outperform the baseline in both cases. Table 1 compares the final validation and test perplexities of the four models on both PTB and Wikitext-2 for each network size. In both datasets, both AL and RE improve upon the baseline individually, and using RE and AL together leads to the best performance. Based on performance comparisons, we make the following notes on the two proposed improvements:
+
+• AL provides better performance gains for smaller networks. This is not surprising given the fact that small models are rather inflexible, and one would expect to see improved learning by training against a more informative data distribution (contributed by the augmented loss) (see Hinton et al. (2015)). For the smaller PTB dataset, performance with AL surpasses that with RE. In comparison, for the larger Wikitext-2 dataset, improvement by AL is more limited. This is expected given larger training sets better represent the true data distribution, mitigating the supervision problem. In fact, we set out to validate this reasoning in a direct manner, and additionally train the small networks separately on the first and second halves of the Wikitext-2 training set. This results in two distinct datasets which are each about the same size as PTB (1044K vs 929K). As can be seen in Table 2, AL has significantly improved competitive performance against RE and REAL despite the fact that embedding size is 3 times larger compared to PTB. These results support our argument that the proposed augmented loss term acts to improve the amount of information gathered from the dataset.
+
+![](images/79a74db09e252b3916e14b02939c9c72b6cb35eb02fbb4d38c7e074b7c9f7001.jpg)  
+Figure 2: Progress of validation perplexities during training for the 4 different models for two (small (200) and large (1500)) network sizes.
+
+• RE significantly outperforms AL for larger networks. This indicates that, for large models, the more effective mechanism of our proposed framework is the one which enforces proximity between the output projection space and the input embedding space. From a model complexity perspective, the nontrivial gains offered by RE for all network sizes and for both datasets could be largely attributed to its explicit function to reduce the model size while preserving the representational power according to our framework.
+
+We list in Table 3 the comparison of models with and without our proposed modifications on the Penn Treebank Corpus. The best LSTM model (VD-LSTM $^ +$ REAL) outperforms all previous work which uses conventional framework, including large ensembles. The recently proposed recurrent highway networks (Zilly et al., 2016) when trained with reused embeddings (VD-RHN $+ \mathrm { R E }$ ) achieves the best overall performance, improving on VD-RHN by a perplexity of 2.5.
+
+Table 1: Comparison of the final word level perplexities on the validation and test set for the 4 different models.   
+
+<table><tr><td colspan="2"></td><td colspan="2">PTB</td><td colspan="2">Wikitext-2</td></tr><tr><td>Network</td><td>Model</td><td>Valid</td><td>Test</td><td>Valid</td><td>Test</td></tr><tr><td rowspan="4">Small4 (200 units)</td><td>VD-LSTM</td><td>92.6</td><td>87.3</td><td>112.2</td><td>105.9</td></tr><tr><td>VD-LSTM+AL</td><td>86.3</td><td>82.9</td><td>110.3</td><td>103.8</td></tr><tr><td>VD-LSTM+RE</td><td>89.9</td><td>85.1</td><td>106.1</td><td>100.5</td></tr><tr><td>VD-LSTM+REAL</td><td>86.3</td><td>82.7</td><td>105.6</td><td>98.9</td></tr><tr><td rowspan="4">Medium (650 units)</td><td>VD-LSTM</td><td>82.0</td><td>77.7</td><td>100.2</td><td>95.3</td></tr><tr><td>VD-LSTM+AL</td><td>77.4</td><td>74.7</td><td>98.8</td><td>93.1</td></tr><tr><td>VD-LSTM+RE</td><td>77.1</td><td>73.9</td><td>92.3</td><td>87.7</td></tr><tr><td>VD-LSTM+REAL</td><td>75.7</td><td>73.2</td><td>91.5</td><td>87.0</td></tr><tr><td rowspan="4">(1500 units)</td><td>VD-LSTM</td><td>76.8</td><td>72.6</td><td>-</td><td>-</td></tr><tr><td>VD-LSTM+AL</td><td>74.5</td><td>71.2</td><td></td><td></td></tr><tr><td>VD-LSTM+RE</td><td>72.5</td><td>69.0</td><td></td><td></td></tr><tr><td>VD-LSTM+REAL</td><td>71.1</td><td>68.5</td><td>=</td><td></td></tr></table>
+
+Table 2: Performance of the four different small models trained on the equally sized two partitions of Wikitext2 training set. These results are consistent with those on PTB (see Table 1), which has a similar training set size with each of these partitions, although its word embedding dimension is three times smaller.   
+
+<table><tr><td colspan="2"></td><td colspan="2">Wikitext-2, Partition 1</td><td colspan="2">Wikitext-2,Partition 2</td></tr><tr><td>Network</td><td>Model</td><td>Valid</td><td>Test</td><td>Valid</td><td>Test</td></tr><tr><td rowspan="4">Small (200 units)</td><td>VD-LSTM</td><td>159.1</td><td>148.0</td><td>163.19</td><td>148.6</td></tr><tr><td>VD-LSTM+AL</td><td>153.0</td><td>142.5</td><td>156.4</td><td>143.7</td></tr><tr><td>VD-LSTM+RE</td><td>152.4</td><td>141.9</td><td>152.5</td><td>140.9</td></tr><tr><td>VD-LSTM+REAL</td><td>149.3</td><td>140.6</td><td>150.5</td><td>138.4</td></tr></table>
+
+Table 3: Comparison of our work to previous state of the art on word-level validation and test perplexities on the Penn Treebank corpus. Models using our framework significantly outperform other models.
+
+<table><tr><td>Model</td><td>Parameters</td><td>Validation</td><td>Test</td></tr><tr><td>RNN (Mikolov &amp; Zweig)</td><td>6M</td><td></td><td>124.7</td></tr><tr><td>RNN+LDA (Mikolov &amp; Zweig)</td><td>7M</td><td>=</td><td>113.7</td></tr><tr><td>RNN+LDA+KN-5+Cache (Mikolov &amp; Zweig)</td><td>9M</td><td>=</td><td>92.0</td></tr><tr><td>Deep RNN (Pascanu et al., 2013a)</td><td>6M</td><td>-</td><td>107.5</td></tr><tr><td>Sum-Prod Net (Cheng et al.,2014)</td><td>5M</td><td>■</td><td>100.0</td></tr><tr><td>LSTM (medium) (Zaremba et al., 2014)</td><td>20M</td><td>86.2</td><td>82.7</td></tr><tr><td>CharCNN (Kim et al., 2015)</td><td>19M</td><td>-</td><td>78.9</td></tr><tr><td>LSTM (large) (Zaremba et al., 2014)</td><td>66M</td><td>82.2</td><td>78.4</td></tr><tr><td>VD-LSTM (large,untied, MC) (Gal, 2015)</td><td>66M</td><td>1</td><td>73.4± 0.0</td></tr><tr><td>Pointer Sentinel-LSTM(medium) (Merity et al., 2016)</td><td>21M</td><td>72.4</td><td>70.9</td></tr><tr><td>38Large LSTMs (Zaremba et al., 2014)</td><td>2.51B</td><td>71.9</td><td>68.7</td></tr><tr><td>10 Large VD-LSTMs (Gal,2015)</td><td>660M</td><td>1</td><td>68.7</td></tr><tr><td>VD-RHN (Zilly et al., 2016)</td><td>32M</td><td>71.2</td><td>68.5</td></tr><tr><td>VD-LSTM+REAL (large)</td><td>51M</td><td>71.1</td><td>68.5</td></tr><tr><td>VD-RHN +RE (Zilly et al., 2016) </td><td>24M</td><td>68.1</td><td>66.0</td></tr></table>
+
+# 6.4 QUALITATIVE RESULTS
+
+One important feature of our framework that leads to better word predictions is the explicit mechanism to assign probabilities to words not merely according to the observed output statistics, but also considering the metric similarity between words. We observe direct consequences of this mechanism qualitatively in the Penn Treebank in different ways: First, we notice that the probability of generating the ${ \tt c u n k } >$ token with our proposed network (VD-LSTM $+$ REAL) is significantly lower compared to the baseline network (VD-LSTM) across many words. This could be explained by noting the fact that the ${ \mathrm { \ c u n k { \mathrm { > } } } }$ token is an aggregated token rather than a specific word, and it is often not expected to be close to specific words in the word embedding space. We observe the same behavior with very frequent words such as ”a”, ”an”, and ”the”, owing to the same fact that they are not correlated with particular words. Second, we not only observe better probability assignments for the target words, but we also observe relatively higher probability weights associated with the words close to the targets. Sometimes this happens in the form of predicting words semantically close together which are plausible even when the target word is not successfully captured by the model. We provide a few examples from the PTB test set which compare the prediction performance of 1500 unit VD-LSTM and 1500 unit VD-LSTM $+ \mathrm { R E A L }$ in table 4. We would like to note that prediction performance of VD-LSTM $+ \mathrm { R E }$ is similar to VD-LSTM $+$ REAL for the large network.
+
+Table 4: Prediction for the next word by the baseline (VD-LSTM) and proposed (VD-LSTM $+$ REAL) networks for a few example phrases in the PTB test set. Top 10 word predictions are sorted in descending probability, and are arranged in column-major format.   
+
+<table><tr><td>Phrase + Next word(s)</td><td colspan="2">Top 10 predicted words VD-LSTM</td><td colspan="2">Top 10 predicted words VD-LSTM+REAL</td></tr><tr><td>information international said it believes that the complaints filed in + federal court</td><td>the 0.27 a 0.13 federal 0.13 N 0.09 {unk) 0.05</td><td>an 0.03 august 0.01 new 0.01 response 0.01 connection 0.01</td><td>federal 0.22 the 0.1 a 0.08 N 0.06 state 0.04</td><td>connection 0.03 august 0.03 july 0.03 an 0.03 september 0.03</td></tr><tr><td>oil company refineries ran flat out to prepare for a robust holiday driving season in july and +august</td><td>the 0.09 N 0.08 a 0.07 {unk) 0.07 was 0.04</td><td>in 0.03 has 0.03 is 0.02 will 0.02 its 0.02</td><td>august 0.08 N 0.05 early 0.05 september 0.05 the 0.03</td><td>a0.03 in 0.03 that 0.02 ended 0.02 its 0.02</td></tr><tr><td>southmark said it plans to {unk&gt;its {unk&gt; to provide financial results as soon as its audit is +completed</td><td>the 0.06 {unk)0.05 a 0.05 in 0.04 n&#x27;t 0.04</td><td>to 0.03 likely 0.03 expected 0.03 scheduled 0.01 completed 0.01</td><td>expected 0.1 completed 0.04 {unk) 0.03 the 0.03 in 0.03</td><td>a 0.03 scheduled 0.03 n&#x27;t 0.03 due 0.02 to 0.01</td></tr><tr><td>merieux said the government &#x27;s minister of industry science and + technology</td><td>{unk) 0.33 the 0.06 a 0.01 other 0.01 others 0.01</td><td>industry 0.01 commerce 0.01 planning 0.01 management 0.01 mail 0.01</td><td>{unk) 0.09 health 0.08 development 0.04 the 0.04 a 0.03</td><td>industry 0.03 business 0.02 telecomm. 0.02 human 0.02 other 0.01</td></tr></table>
+
+# 7 CONCLUSION
+
+In this work, we introduced a novel loss framework for language modeling. Particularly, we showed that the metric encoded into the space of word embeddings could be used to generate a more informed data distribution than the one-hot targets, and that additionally training against this distribution improves learning. We also showed theoretically that this approach lends itself to a second improvement, which is simply reusing the input embedding matrix in the output projection layer. This has an additional benefit of reducing the number of trainable variables in the model. We empirically validated the theoretical link, and verified that both proposed changes do in fact belong to the same framework. In our experiments on the Penn Treebank corpus and Wikitext-2, we showed that our framework outperforms the conventional one, and that even the simple modification of reusing the word embedding in the output projection layer is sufficient for large networks.
+
+The improvements achieved by our framework are not unique to vanilla language modeling, and are readily applicable to other tasks which utilize language models such as neural machine translation, speech recognition, and text summarization. This could lead to significant improvements in such models especially with large vocabularies, with the additional benefit of greatly reducing the number of parameters to be trained.
+
+# REFERENCES
+
+Yoshua Bengio, Rejean Ducharme, and Pascal Vincent. A neural probabilistic language model.´ 2001. URL http://www.iro.umontreal.ca/˜lisa/pointeurs/nips00_lm.ps.
+
+◦Ake Bjorck and Gene H Golub. Numerical methods for computing angles between linear subspaces. ¨ Mathematics of computation, 27(123):579–594, 1973.
+
+Wei-Chen Cheng, Stanley Kok, Hoai Vu Pham, Hai Leong Chieu, and Kian Ming Adam Chai. Language modeling with sum-product networks. 2014.
+
+Kyunghyun Cho, Bart Van Merrienboer, Dzmitry Bahdanau, and Yoshua Bengio. On the properties ¨ of neural machine translation: Encoder-decoder approaches. arXiv preprint arXiv:1409.1259, 2014.
+
+Orhan Firat, Kyunghyun Cho, and Yoshua Bengio. Multi-way, multilingual neural machine translation with a shared attention mechanism. arXiv preprint arXiv:1601.01073, 2016.
+
+Charlie Frogner, Chiyuan Zhang, Hossein Mobahi, Mauricio Araya, and Tomaso A Poggio. Learning with a wasserstein loss. In Advances in Neural Information Processing Systems, pp. 2053– 2061, 2015.
+
+Yarin Gal. A theoretically grounded application of dropout in recurrent neural networks. arXiv preprint arXiv:1512.05287, 2015.
+
+Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. arXiv preprint arXiv:1503.02531, 2015.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997.
+
+Hakan Inan and Khashayar Khosravi. Improved learning through augmenting the loss. Stanford CS 224D: Deep Learning for Natural Language Processing, Spring 2016, 2016.
+
+Kazuki Irie, Zoltan T ´ uske, Tamer Alkhouli, Ralf Schl ¨ uter, and Hermann Ney. Lstm, gru, high-¨ way and a bit of attention: an empirical overview for language modeling in speech recognition. Interspeech, San Francisco, CA, USA, 2016.
+
+Camille Jordan. Essai sur la geom´ etrie ´ a\` $n$ dimensions. Bulletin de la Societ´ e math ´ ematique de ´ France, 3:103–174, 1875.
+
+Yoon Kim, Yacine Jernite, David Sontag, and Alexander M Rush. Character-aware neural language models. arXiv preprint arXiv:1508.06615, 2015.
+
+Mitchell P Marcus, Mary Ann Marcinkiewicz, and Beatrice Santorini. Building a large annotated corpus of english: The penn treebank. Computational linguistics, 19(2):313–330, 1993.
+
+Stephen Merity, Caiming Xiong, James Bradbury, and Richard Socher. Pointer sentinel mixture models. arXiv preprint arXiv:1609.07843, 2016.
+
+Tomas Mikolov and Geoffrey Zweig. Context dependent recurrent neural network language model.
+
+Tomas Mikolov, Martin Karafiat, Lukas Burget, Jan Cernock ´ y, and Sanjeev Khudanpur. Recurrent \` neural network based language model. In Interspeech, volume 2, pp. 3, 2010.
+
+Tomas Mikolov, Ilya Sutskever, Kai Chen, Greg S Corrado, and Jeff Dean. Distributed representations of words and phrases and their compositionality. In Advances in neural information processing systems, pp. 3111–3119, 2013.
+
+Andriy Mnih and Geoffrey Hinton. Three new graphical models for statistical language modelling. In Proceedings of the 24th international conference on Machine learning, pp. 641–648. ACM, 2007.
+
+Ramesh Nallapati, Bowen Zhou, C¸ aglar Gulc¸ehre, and Bing Xiang. Abstractive text summarization using sequence-to-sequence rnns and beyond. 2016.
+
+Razvan Pascanu, C¸ aglar Gulc¸ehre, Kyunghyun Cho, and Yoshua Bengio. How to construct deep ¨ recurrent neural networks. CoRR, abs/1312.6026, 2013a.   
+Razvan Pascanu, Tomas Mikolov, and Yoshua Bengio. On the difficulty of training recurrent neural networks. ICML (3), 28:1310–1318, 2013b.   
+Jeffrey Pennington, Richard Socher, and Christopher D Manning. Glove: Global vectors for word representation. In EMNLP, volume 14, pp. 1532–43, 2014.   
+Ofir Press and Lior Wolf. Using the output embedding to improve language models. arXiv preprint arXiv:1608.05859, 2016.   
+Alexander M Rush, Sumit Chopra, and Jason Weston. A neural attention model for abstractive sentence summarization. arXiv preprint arXiv:1509.00685, 2015.   
+Richard Socher, Alex Perelygin, Jean Y Wu, Jason Chuang, Christopher D Manning, Andrew $\mathrm { \Delta Y N g }$ , and Christopher Potts. Recursive deep models for semantic compositionality over a sentiment treebank. Citeseer, 2013.   
+Wojciech Zaremba, Ilya Sutskever, and Oriol Vinyals. Recurrent neural network regularization. arXiv preprint arXiv:1409.2329, 2014.   
+Julian Georg Zilly, Rupesh Kumar Srivastava, Jan Koutn´ık, and Jurgen Schmidhuber. Recurrent ¨ highway networks. arXiv preprint arXiv:1607.03474, 2016.
+
+# APPENDIX
+
+A MODEL AND TRAINING DETAILS
+
+We begin training with a learning rate of 1 and start decaying it with a constant rate after a certain epoch. This is 5, 10, and 1 for the small, medium, and large networks respectively. The decay rate is 0.9 for the small and medium networks, and 0.97 for the large network.
+
+For both PTB and Wikitext-2 datasets, we unroll the network for 35 steps for backpropagation.
+
+We use gradient clipping (Pascanu et al., 2013b); i.e. we rescale the gradients using the global norm if it exceeds a certain value. For both datasets, this is 5 for the small and the medium network, and 6 for the large network.
+
+We use the dropout method introduced in Gal (2015); particularly, we use the same dropout mask for each example through the unrolled network. Differently from what was proposed in Gal (2015), we tie the dropout weights for hidden states further, and we use the same mask when they are propagated as states in the current layer and when they are used as inputs for the next layer. We don’t use dropout in the input embedding layer, and we use the same dropout probability for inputs and hidden states. For PTB, dropout probabilities are 0.7, 0.5 and 0.35 for small, medium and large networks respectively. For Wikitext-2, probabilities are 0.8 for the small and 0.6 for the medium networks.
+
+When training the networks with the augmented loss (AL), we use a temperature $\tau = 2 0$ . We have empirically observed that setting $\alpha$ , the weight of the augmented loss, according to $\alpha = \gamma \tau$ for all the networks works satisfactorily. We set $\gamma$ to values between 0.5 and 0.8 for the PTB dataset, and between 1.0 and 1.5 for the Wikitext-2 dataset. We would like to note that we have not observed sudden deteriorations in the performance with respect to moderate variations in either $\tau$ or $\alpha$ .
+
+# B METRIC FOR CALCULATING SUBSPACE DISTANCES
+
+In this section, we detail the metric used for computing the subspace distance between two matrices. The computed metric is closely related with the principle angles between subspaces, first defined in Jordan (1875).
+
+Our aim is to compute a metric distance between two given matrices, $X$ and $Y$ . We do this in three steps:
+
+(1) Obtain two matrices with orthonormal columns, $U$ and $V$ , such that s $\scriptstyle \operatorname { \mathtt { p a n } } ( U ) = \operatorname { \mathtt { s p a n } } ( X )$ and span $\scriptstyle 1 ( V ) = \operatorname { s p a n } ( Y )$ . $U$ and $V$ could be obtained with a QR decomposition.   
+(2) Calculate the projection of either one of $U$ and $V$ onto the other; e.g. do $S = U U ^ { T } V$ , where $S$ is the projection of $V$ onto $U$ . Then calculate the residual matrix as $R = V - S$ .   
+(3) Let $\| . \| _ { F r }$ denote the frobenious norm, and let $C$ be the number of columns of $R$ . Then the distance metric is found as $d$ where $\begin{array} { r } { d ^ { 2 } = \frac { 1 } { C } \| R \| _ { F r } ^ { 2 } = \frac { 1 } { C } \mathrm { T r a c e } ( R ^ { T } R ) } \end{array}$ .
+
+We note that $d$ as calculated above is a valid metric up to the equivalence set of matrices which span the same column space, although we are not going to show it. Instead, we will mention some metric properties of $d$ , and relate it to the principal angles between the subspaces. We first work out an expression for $d$ :
+
+$$
+\begin{array} { r l } { C d ^ { 2 } = \operatorname { T a c e } ( R ^ { T } R ) = \operatorname { T r a c e } \left( ( V - U U ^ { T } V ) ^ { T } ( V - U U ^ { T } V ) \right) } \\ & { = \operatorname { T a c e } \left( V ^ { T } ( I - U U ^ { T } ) ( I - U U ^ { T } V ) V \right) } \\ & { = \operatorname { T a c e } \left( V ^ { T } ( I - U U ^ { T } ) V \right) } \\ & { = \operatorname { T a c e } \left( ( I - U U ^ { T } ) V V ^ { T } \right) } \\ & { = \operatorname { T a c e } \left( V ^ { T } V \right) - \operatorname { T a c e } \left( U U ^ { T } V V ^ { T } \right) } \\ & { = C - \operatorname { T a c e } \left( U U ^ { T } V V ^ { T } \right) } \\ & { = C - \operatorname { T a c e } \left( ( U ^ { T } V ) ^ { T } ( U ^ { T } V ) \right) } \\ & { = C - \operatorname { T a c e } \left( ( U ^ { T } V ) ^ { T } ( U ^ { T } V ) \right) } \\ & { = C - \operatorname { \alpha c e } \left( 1 6 ^ { T } V \right) } \\ & { = \frac { C } { \lambda - 1 } ^ { 1 } - \rho _ { i } ^ { 2 } , } \end{array}
+$$
+
+where $\rho _ { i }$ is the $i ^ { \mathrm { { t h } } }$ singular value of $U ^ { T } V$ , commonly referred to as the $i ^ { \mathrm { { t h } } }$ principle angle between the subspaces of $X$ and $Y , \theta _ { i }$ . In above, we used the cyclic permutation property of the trace in the third and the fourth lines.
+
+Since $d ^ { 2 }$ is $\scriptstyle { \frac { 1 } { C } } \mathrm { T r a c e } ( R ^ { T } R )$ , it is always nonnegative, and it is only zero when the residual is zero, which is the case whenthe form of (B.1) (singu $\operatorname { s p a n } ( X ) = \operatorname { s p a n } ( \mathrm { Y } )$ .d er, it is symmetric bare the same). Also, $U$ $V$ , $V ^ { T } U$ $V ^ { T } U$ $\begin{array} { r } { d ^ { 2 } = \frac { 1 } { C } \sum _ { i = 1 } ^ { C } \sin ^ { 2 } ( \theta _ { i } ) . } \end{array}$ namely the average of the sines of the principle angles, which is a quantity between 0 and 1.

parse/train/r1aPbsFle/r1aPbsFle_content_list.json

@@ -0,0 +1,1436 @@
+[
+    {
+        "type": "text",
+        "text": "TYING WORD VECTORS AND WORD CLASSIFIERS:A LOSS FRAMEWORK FOR LANGUAGE MODELING",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            782,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Hakan Inan, Khashayar Khosravi   \nStanford University   \nStanford, CA, USA   \n{inanh,khosravi}@stanford.edu   \nRichard Socher   \nSalesforce Research   \nPalo Alto, CA, USA   \nrsocher@salesforce.com ",
+        "bbox": [
+            184,
+            170,
+            465,
+            227
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            539,
+            170,
+            758,
+            226
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            262,
+            544,
+            277
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recurrent neural networks have been very successful at predicting sequences of words in tasks such as language modeling. However, all such models are based on the conventional classification framework, where the model is trained against one-hot targets, and each word is represented both as an input and as an output in isolation. This causes inefficiencies in learning both in terms of utilizing all of the information and in terms of the number of parameters needed to train. We introduce a novel theoretical framework that facilitates better learning in language modeling, and show that our framework leads to tying together the input embedding and the output projection matrices, greatly reducing the number of trainable variables. Our framework leads to state of the art performance on the Penn Treebank with a variety of network models. ",
+        "bbox": [
+            233,
+            292,
+            764,
+            444
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            468,
+            336,
+            484
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Neural network models have recently made tremendous progress in a variety of NLP applications such as speech recognition (Irie et al., 2016), sentiment analysis (Socher et al., 2013), text summarization (Rush et al., 2015; Nallapati et al., 2016), and machine translation (Firat et al., 2016). ",
+        "bbox": [
+            176,
+            500,
+            823,
+            541
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Despite the overwhelming success achieved by recurrent neural networks in modeling long range dependencies between words, current recurrent neural network language models (RNNLM) are based on the conventional classification framework, which has two major drawbacks: First, there is no assumed metric on the output classes, whereas there is evidence suggesting that learning is improved when one can define a natural metric on the output space (Frogner et al., 2015). In language modeling, there is a well established metric space for the outputs (words in the language) based on word embeddings, with meaningful distances between words (Mikolov et al., 2013; Pennington et al., 2014). Second, in the classical framework, inputs and outputs are considered as isolated entities with no semantic link between them. This is clearly not the case for language modeling, where inputs and outputs in fact live in identical spaces. Therefore, even for models with moderately sized vocabularies, the classical framework could be a vast source of inefficiency in terms of the number of variables in the model, and in terms of utilizing the information gathered by different parts of the model (e.g. inputs and outputs). ",
+        "bbox": [
+            174,
+            547,
+            825,
+            728
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work, we introduce a novel loss framework for language modeling to remedy the above two problems. Our framework is comprised of two closely linked improvements. First, we augment the classical cross-entropy loss with an additional term which minimizes the KL-divergence between the model’s prediction and an estimated target distribution based on the word embeddings space. This estimated distribution uses knowledge of word vector similarity. We then theoretically analyze this loss, and this leads to a second and synergistic improvement: tying together two large matrices by reusing the input word embedding matrix as the output classification matrix. We empirically validate our theory in a practical setting, with much milder assumptions than those in theory. We also find empirically that for large networks, most of the improvement could be achieved by only reusing the word embeddings. ",
+        "bbox": [
+            174,
+            736,
+            825,
+            875
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We test our framework by performing extensive experiments on the Penn Treebank corpus, a dataset widely used for benchmarking language models (Mikolov et al., 2010; Merity et al., 2016). We demonstrate that models trained using our proposed framework significantly outperform models trained using the conventional framework. We also perform experiments on the newly introduced Wikitext-2 dataset (Merity et al., 2016), and verify that the empirical performance of our proposed framework is consistent across different datasets. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            826,
+            146
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 BACKGROUND: RECURRENT NEURAL NETWORK LANGUAGE MODEL",
+        "text_level": 1,
+        "bbox": [
+            173,
+            166,
+            769,
+            183
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In any variant of recurrent neural network language model (RNNLM), the goal is to predict the next word indexed by $t$ in a sequence of one-hot word tokens $( y _ { 1 } ^ { * } , \\dots y _ { N } ^ { * } )$ as follows: ",
+        "bbox": [
+            174,
+            198,
+            825,
+            228
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fab21099ded6c356e51d74f6c2067d3a1ea3d25347ad025d4317935a8e2883ac.jpg",
+        "text": "$$\n\\begin{array} { r l } & { x _ { t } = L y _ { t - 1 } ^ { * } , } \\\\ & { h _ { t } = f ( x _ { t } , h _ { t - 1 } ) , } \\\\ & { y _ { t } = \\mathrm { s o f t m a x } \\left( W h _ { t } + b \\right) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            410,
+            233,
+            586,
+            290
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The matrix $L \\in \\mathbb { R } ^ { d _ { x } \\times | V | }$ is the word embedding matrix, where $d _ { x }$ is the word embedding dimension and $| V |$ is the size of the vocabulary. The function $f ( . , . )$ represents the recurrent neural network which takes in the current input and the previous hidden state and produces the next hidden state. $W \\in \\mathbb { R } ^ { | V | \\times d _ { h } }$ and $b \\in \\mathbb { R } ^ { | V | }$ are the the output projection matrix and the bias, respectively, and $d _ { h }$ is the size of the RNN hidden state. The $| V |$ dimensional $y _ { t }$ models the discrete probability distribution for the next word. ",
+        "bbox": [
+            173,
+            296,
+            825,
+            383
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Note that the above formulation does not make any assumptions about the specifics of the recurrent neural units, and $f$ could be replaced with a standard recurrent unit, a gated recurrent unit (GRU) (Cho et al., 2014), a long-short term memory (LSTM) unit (Hochreiter & Schmidhuber, 1997), etc. For our experiments, we use LSTM units with two layers. ",
+        "bbox": [
+            174,
+            388,
+            825,
+            445
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Given $y _ { t }$ for the $t ^ { \\mathrm { { t h } } }$ example, a loss is calculated for that example. The loss used in the RNNLMs is almost exclusively the cross-entropy between $y _ { t }$ and the observed one-hot word token, ${ \\boldsymbol y } _ { t } ^ { * }$ : ",
+        "bbox": [
+            171,
+            452,
+            823,
+            481
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/92a95a4c127d5343da2a569ae8c14bdb5d1405f9686ebe3b8347ad5ff46fa22c.jpg",
+        "text": "$$\nJ _ { t } = \\mathbf { C E } ( y _ { t } ^ { * } \\parallel y _ { t } ) = - \\sum _ { i \\in | V | } y _ { t , i } ^ { * } \\log y _ { t , i } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            364,
+            488,
+            632,
+            525
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We shall refer to $y _ { t }$ as the model prediction distribution for the $t ^ { \\mathrm { { t h } } }$ example, and $\\boldsymbol { y } _ { t } ^ { * }$ as the empirical target distribution (both are in fact conditional distributions given the history). Since crossentropy and Kullback-Leibler divergence are equivalent when the target distribution is one-hot, we can rewrite the loss for the $t ^ { \\mathrm { { t h } } }$ example as ",
+        "bbox": [
+            174,
+            532,
+            823,
+            589
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/99f5c360769bffe2997e73c36c55fa878c1486544ec975ccd9aefea3778beea5.jpg",
+        "text": "$$\nJ _ { t } = \\mathbf { D } _ { K L } ( y _ { t } ^ { * } \\parallel y _ { t } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            429,
+            597,
+            568,
+            614
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Therefore, we can think of the optimization of the conventional loss in an RNNLM as trying to minimize the distance1 between the model prediction distribution $( y )$ and the empirical target distribution $( y ^ { \\ast } )$ , which, with many training examples, will get close to minimizing distance to the actual target distribution. In the framework which we will introduce, we utilize Kullback-Leibler divergence as opposed to cross-entropy due to its intuitive interpretation as a distance between distributions, although the two are not equivalent in our framework. ",
+        "bbox": [
+            173,
+            619,
+            825,
+            704
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 AUGMENTING THE CROSS-ENTROPY LOSS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            726,
+            562,
+            742
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We propose to augment the conventional cross-entropy loss with an additional loss term as follows: ",
+        "bbox": [
+            173,
+            757,
+            821,
+            772
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/36fcfe7759d9471a9f178c0ac2d67e754a2aa81cda3a64aa86933573193a9ef8.jpg",
+        "text": "$$\n\\begin{array} { r } { \\hat { y } _ { t } = \\operatorname { s o f t m a x } \\left( W h _ { t } / \\tau \\right) , } \\\\ { J _ { t } ^ { a u g } = \\operatorname { \\mathrm { D } } _ { K L } ( \\tilde { y } _ { t } \\parallel \\hat { y } _ { t } ) , ~ } \\\\ { J _ { t } ^ { t o t } = J _ { t } + \\alpha J _ { t } ^ { a u g } . ~ } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            408,
+            777,
+            588,
+            838
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In above, $\\alpha$ is a hyperparameter to be adjusted, and $\\hat { y } _ { t }$ is almost identical to the regular model prediction distribution $y _ { t }$ with the exception that the logits are divided by a temperature parameter $\\tau$ . We define $\\tilde { y } _ { t }$ as some probability distribution that estimates the true data distribution (conditioned on the word history) which satisfies $\\mathbb { E } \\tilde { y } _ { t } = \\mathbb { E } y _ { t } ^ { * }$ . The goal of this framework is to minimize the distribution distance between the prediction distribution and a more accurate estimate of the true data distribution. ",
+        "bbox": [
+            173,
+            842,
+            825,
+            900
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To understand the effect of optimizing in this setting, let’s focus on an ideal case in which we are given the true data distribution so that $\\tilde { y } _ { t } = \\mathbb { E } y _ { t } ^ { * }$ , and we only use the augmented loss, $J ^ { a u g }$ . We will carry out our investigation through stochastic gradient descent, which is the technique dominantly used for training neural networks. The gradient of ${ J } _ { t } ^ { a u g }$ with respect to the logits $W h _ { t }$ is ",
+        "bbox": [
+            173,
+            138,
+            823,
+            195
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/225d5c61b3ba363952eb4e343250b145c9c8db884ad3861a3ec3e95f27e412f3.jpg",
+        "text": "$$\n\\nabla { J _ { t } ^ { a u g } } = \\frac { 1 } { \\tau } ( \\hat { y } _ { t } - \\tilde { y } _ { t } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            424,
+            202,
+            573,
+            231
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Let’s denote by $e _ { j } \\in \\mathbb { R } ^ { | V | }$ the vector whose $j ^ { \\mathrm { t h } }$ entry is 1, and others are zero. We can then rewrite (3.4) as ",
+        "bbox": [
+            169,
+            239,
+            823,
+            268
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7d37b8bf98bb84c8794098e9dc59d0d362961037de862e22a007c82d6d21a6cb.jpg",
+        "text": "$$\n\\tau \\nabla { \\cal J } _ { t } ^ { a u g } = \\widehat { y } _ { t } - \\left[ e _ { 1 } , \\ldots , e _ { | V | } \\right] \\tilde { y } _ { t } = \\sum _ { i \\in V } \\tilde { y } _ { t , i } ( \\widehat { y } _ { t } - e _ { i } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            318,
+            273,
+            679,
+            309
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Implication of (3.5) is the following: Every time the optimizer sees one training example, it takes a step not only on account of the label seen, but it proceeds taking into account all the class labels for which the conditional probability is not zero, and the relative step size for each step is given by the conditional probability for that label, $\\tilde { y } _ { t , i }$ . Furthermore, this is a much less noisy update since the target distribution is exact and deterministic. Therefore, unless all the examples exclusively belong to a specific class with probability 1, the optimization will act much differently and train with greatly improved supervision. ",
+        "bbox": [
+            174,
+            314,
+            825,
+            412
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The idea proposed in the recent work by Hinton et al. (2015) might be considered as an application of this framework, where they try to obtain a good set of $\\tilde { y }$ ’s by training very large models and using the model prediction distributions of those. ",
+        "bbox": [
+            174,
+            419,
+            825,
+            462
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Although finding a good $\\tilde { y }$ in general is rather nontrivial, in the context of language modeling we can hope to achieve this by exploiting the inherent metric space of classes encoded into the model, namely the space of word embeddings. Specifically, we propose the following for $\\tilde { y }$ : ",
+        "bbox": [
+            174,
+            468,
+            825,
+            511
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/df399d2baae0e79927755f4dce04533425f62c86879e70d210db68c1ba2f02b4.jpg",
+        "text": "$$\n\\begin{array} { l } { { \\displaystyle { u _ { t } = L y _ { t } ^ { * } , } } } \\\\ { { \\displaystyle \\tilde { y } _ { t } = \\mathrm { s o f t m a x } \\left( \\frac { L ^ { T } u _ { t } } { \\tau } \\right) . } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            415,
+            516,
+            583,
+            573
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In words, we first find the target word vector which corresponds to the target word token (resulting in $u _ { t }$ ), and then take the inner product of the target word vector with all the other word vectors to get an unnormalized probability distribution. We adjust this with the same temperature parameter $\\tau$ used for obtaining $\\hat { y } _ { t }$ and apply softmax. The target distribution estimate, $\\tilde { y }$ , therefore measures the similarity between the word vectors and assigns similar probability masses to words that the language model deems close. Note that the estimation of $\\tilde { y }$ with this procedure is iterative, and the estimates of $\\tilde { y }$ in the initial phase of the training are not necessarily informative. However, as training procedes, we expect $\\tilde { y }$ to capture the word statistics better and yield a consistently more accurate estimate of the true data distribution. ",
+        "bbox": [
+            173,
+            577,
+            825,
+            703
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4 THEORETICALLY DRIVEN REUSE OF WORD EMBEDDINGS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            722,
+            687,
+            738
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We now theoretically motivate and introduce a second modification to improve learning in the language model. We do this by analyzing the proposed augmented loss in a particular setting, and observe an implicit core mechanism of this loss. We then make our proposition by making this mechanism explicit. ",
+        "bbox": [
+            174,
+            753,
+            825,
+            810
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We start by introducing our setting for the analysis. We restrict our attention to the case where the input embedding dimension is equal to the dimension of the RNN hidden state, i.e. $d \\triangleq d _ { x } = d _ { h }$ . We also set $b = 0$ in (2.3) so that $y _ { t } = W h _ { t }$ . We only use the augmented loss, i.e. ${ J ^ { t o t } = J ^ { a u g } }$ , and we assume that we can achieve zero training loss. Finally, we set the temperature parameter $\\tau$ to be large. ",
+        "bbox": [
+            174,
+            816,
+            825,
+            888
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We first show that when the temperature parameter, $\\tau$ , is high enough, ${ J } _ { t } ^ { a u g }$ acts to match the logits of the prediction distribution to the logits of the the more informative labels, $\\tilde { y }$ . We proceed in the same way as was done in Hinton et al. (2015) to make an identical argument. Particularly, we consider the derivative of ${ J } _ { t } ^ { a u g }$ with respect to the entries of the logits produced by the neural network. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Let’s denote by $l _ { i }$ the $i ^ { \\mathrm { { t h } } }$ column of L. Using the first order approximation of exponential function around zero $( \\exp { ( x ) } \\approx 1 + x )$ ), we can approximate $\\tilde { y } _ { t }$ (same holds for $\\hat { y } _ { t } ^ { \\phantom { } }$ ) at high temperatures as follows: ",
+        "bbox": [
+            174,
+            138,
+            825,
+            180
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bf2b3551fe2839e6325c699923ab374dd0eb7f1c4c716a786b5abbeb4c8fcbbe.jpg",
+        "text": "$$\n\\tilde { y } _ { t , i } = \\frac { \\exp { ( \\langle u _ { t } , l _ { i } \\rangle / \\tau ) } } { \\sum _ { j \\in V } \\exp { ( \\langle u _ { t } , l _ { j } \\rangle / \\tau ) } } \\approx \\frac { 1 + \\langle u _ { t } , l _ { i } \\rangle / \\tau } { \\lvert V \\rvert + \\sum _ { j \\in V } \\langle u _ { t } , l _ { j } \\rangle / \\tau } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            308,
+            185,
+            691,
+            222
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We can further simplify (4.1) if we assume that $\\langle u _ { t } , l _ { j } \\rangle = 0$ on average: ",
+        "bbox": [
+            173,
+            227,
+            643,
+            243
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f535d68ae47eba33b6966d5a5ca59bcbab2025267d575d30c10d785a1938d0fd.jpg",
+        "text": "$$\n\\tilde { y } _ { t , i } \\approx \\frac { 1 + \\langle u _ { t } , l _ { i } \\rangle / \\tau } { | V | } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            424,
+            250,
+            573,
+            285
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "By replacing $\\tilde { y } _ { t }$ and $\\hat { y } _ { t }$ in (3.4) with their simplified forms according to (4.2), we get ",
+        "bbox": [
+            176,
+            290,
+            728,
+            305
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d3d8492e4a97fb04bf0a1ae17fa537e5523028ccf92b011bc15c5e2db48a3e04.jpg",
+        "text": "$$\n\\frac { \\partial J _ { t } ^ { a u g } } { \\partial \\left( W h _ { t } \\right) _ { i } } \\to \\frac { 1 } { \\tau ^ { 2 } | V | } \\left( W h _ { t } - L ^ { T } u _ { t } \\right) _ { i } \\mathrm { a s } \\tau \\to \\infty ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            330,
+            310,
+            666,
+            347
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "which is the desired result that augmented loss tries to match the logits of the model to the logits of $\\tilde { y }$ ’s. Since the training loss is zero by assumption, we necessarily have ",
+        "bbox": [
+            171,
+            353,
+            823,
+            381
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e0f61c10f7c04f80959f06ab0e22dc13a479dba5a528abd7a055e10c057ac32b.jpg",
+        "text": "$$\nW h _ { t } = L ^ { T } u _ { t }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            452,
+            387,
+            547,
+            406
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "for each training example, i.e., gradient contributed by each example is zero. Provided that $W$ and $L$ are full rank matrices and there are more linearly independent examples of $h _ { t }$ ’s than the embedding dimension $d$ , we get that the space spanned by the columns of $L ^ { T }$ is equivalent to that spanned by the columns of $W$ . Let’s now introduce a square matrix $A$ such that $W \\overset { \\cdot } { = } L ^ { T } A$ . (We know $A$ exists since $L ^ { T }$ and $W$ span the same column space). In this case, we can rewrite ",
+        "bbox": [
+            173,
+            412,
+            825,
+            483
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ab47c7dd8f767f5a10b1dae4c77f6f7e2b4810009a9949d87460d6b9dd7a914e.jpg",
+        "text": "$$\nW h _ { t } = L ^ { T } A h _ { t } \\triangleq L ^ { T } \\tilde { h } _ { t } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            413,
+            489,
+            583,
+            508
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In other words, by reusing the embedding matrix in the output projection layer (with a transpose) and letting the neural network do the necessary linear mapping $h  A h$ , we get the same result as we would have in the first place. ",
+        "bbox": [
+            174,
+            515,
+            825,
+            559
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Although the above scenario could be difficult to exactly replicate in practice, it uncovers a mechanism through which our proposed loss augmentation acts, which is trying to constrain the output (unnormalized) probability space to a small subspace governed by the embedding matrix. This suggests that we can make this mechanism explicit and constrain $W \\overset { \\cdot } { = } L ^ { T }$ during training while setting the output bias, $b$ , to zero. Doing so would not only eliminate a big matrix which dominates the network size for models with even moderately sized vocabularies, but it would also be optimal in our setting of loss augmentation as it would eliminate much work to be done by the augmented loss. ",
+        "bbox": [
+            173,
+            564,
+            825,
+            662
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "5 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            683,
+            344,
+            699
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Since their introduction in Mikolov et al. (2010), many improvements have been proposed for RNNLMs , including different dropout methods (Zaremba et al., 2014; Gal, 2015), novel recurrent units (Zilly et al., 2016), and use of pointer networks to complement the recurrent neural network (Merity et al., 2016). However, none of the improvements dealt with the loss structure, and to the best of our knowledge, our work is the first to offer a new loss framework. ",
+        "bbox": [
+            174,
+            713,
+            825,
+            784
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our technique is closely related to the one in Hinton et al. (2015), where they also try to estimate a more informed data distribution and augment the conventional loss with KL divergence between model prediction distribution and the estimated data distribution. However, they estimate their data distribution by training large networks on the data and then use it to improve learning in smaller networks. This is fundamentally different from our approach, where we improve learning by transferring knowledge between different parts of the same network, in a self contained manner. ",
+        "bbox": [
+            173,
+            790,
+            825,
+            875
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The work we present in this paper is based on a report which was made public in Inan & Khosravi (2016). We have recently come across a concurrent preprint (Press & Wolf, 2016) where the authors reuse the word embedding matrix in the output projection to improve language modeling. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "However, their work is purely empirical, and they do not provide any theoretical justification for their approach. Finally, we would like to note that the idea of using the same representation for input and output words has been explored in the past, and there exists language models which could be interpreted as simple neural networks with shared input and output embeddings (Bengio et al., 2001; Mnih & Hinton, 2007). However, shared input and output representations were implicitly built into these models, rather than proposed as a supplement to a baseline. Consequently, possibility of improvement was not particularly pursued by sharing input and output representations. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            202
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "6 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            222,
+            326,
+            237
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In our experiments, we use the Penn Treebank corpus (PTB) (Marcus et al., 1993), and the Wikitext2 dataset (Merity et al., 2016). PTB has been a standard dataset used for benchmarking language models. It consists of 923k training, 73k validation, and 82k test words. The version of this dataset which we use is the one processed in Mikolov et al. (2010), with the most frequent 10k words selected to be in the vocabulary and rest replaced with a an ${ \\tt c u n k } >$ token 2. Wikitext-2 is a dataset released recently as an alternative to $\\mathrm { P T B } ^ { 3 }$ . It contains 2, 088k training, 217k validation, and $2 4 5 \\mathrm { k }$ test tokens, and has a vocabulary of 33, 278 words; therefore, in comparison to PTB, it is roughly 2 times larger in dataset size, and 3 times larger in vocabulary. ",
+        "bbox": [
+            174,
+            252,
+            825,
+            363
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "6.1 MODEL AND TRAINING HIGHLIGHTS",
+        "text_level": 1,
+        "bbox": [
+            176,
+            380,
+            472,
+            395
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We closely follow the LSTM based language model proposed in Zaremba et al. (2014) for constructing our baseline model. Specifically, we use a 2-layer LSTM with the same number of hidden units in each layer, and we use 3 different network sizes: small (200 units), medium (650 units), and large (1500 units). We train our models using stochastic gradient descent, and we use a variant of the dropout method proposed in Gal (2015). We defer further details regarding training the models to section A of the appendix. We refer to our baseline network as variational dropout LSTM, or VD-LSTM in short. ",
+        "bbox": [
+            174,
+            406,
+            825,
+            503
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "6.2 EMPIRICAL VALIDATION FOR THE THEORY OF REUSING WORD EMBEDDINGS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            520,
+            751,
+            535
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In Section 4, we showed that the particular loss augmentation scheme we choose constrains the output projection matrix to be close to the input embedding matrix, without explicitly doing so by reusing the input embedding matrix. As a first experiment, we set out to validate this theoretical result. To do this, we try to simulate the setting in Section 4 by doing the following: We select a randomly chosen 20, 000 contiguous word sequence in the PTB training set, and train a 2-layer LSTM language model with 300 units in each layer with loss augmentation by minimizing the following loss: ",
+        "bbox": [
+            173,
+            546,
+            825,
+            643
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6db53247d8a7c94b0f7be050ff7fdcef7ec3d166a1379800433ab598d1c9f7e2.jpg",
+        "text": "$$\nJ ^ { t o t } = \\beta J ^ { a u g } \\tau ^ { 2 } | V | + ( 1 - \\beta ) J .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            392,
+            647,
+            606,
+            666
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Here, $\\beta$ is the proportion of the augmented loss used in the total loss, and $J ^ { a u g }$ is scaled by $\\tau ^ { 2 } | V |$ to approximately match the magnitudes of the derivatives of $J$ and $J ^ { a u g }$ (see (4.3)). Since we aim to achieve the minimum training loss possible, and the goal is to show a particular result rather than to achieve good generalization, we do not use any kind of regularization in the neural network (e.g. weight decay, dropout). For this set of experiments, we also constrain each row of the input embedding matrix to have a norm of 1 because training becomes difficult without this constraint when only augmented loss is used. After training, we compute a metric that measures distance between the subspace spanned by the rows of the input embedding matrix, $L$ , and that spanned by the columns of the output projection matrix, $W$ . For this, we use a common metric based on the relative residual norm from projection of one matrix onto another (Bjorck & Golub ¨ , 1973). The computed distance between the subspaces is 1 when they are orthogonal, and 0 when they are the same. Interested reader may refer to section B in the appendix for the details of this metric. ",
+        "bbox": [
+            173,
+            671,
+            825,
+            838
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Figure 1 shows the results from two tests. In one (panel a), we test the effect of using the augmented loss by sweeping $\\beta$ in (6.1) from 0 to 1 at a reasonably high temperature $\\tau = 1 0$ ). With no loss augmentation ( $\\beta = 0$ ), the distance is almost 1, and as more and more augmented loss is used the distance decreases rapidly, and eventually reaches around 0.06 when only augmented loss is used. In the second test (panel b), we set $\\beta = 1$ , and try to see the effect of the temperature on the subspace distance (remember the theory predicts low distance when $\\tau  \\infty$ ). Notably, the augmented loss causes $W$ to approach $L ^ { T }$ sufficiently even at temperatures as low as 2, although higher temperatures still lead to smaller subspace distances. ",
+        "bbox": [
+            173,
+            845,
+            823,
+            875
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/c8f6c4ac0b38cd5adff94c8df284c9ca2ca5c16a5d356924d8c4d7a5774c909c.jpg",
+        "image_caption": [
+            "Figure 1: Subspace distance between $L ^ { T }$ and $W$ for different experiment conditions for the validation experiments. Results are averaged over 10 independent runs. These results validate our theory under practical conditions. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            192,
+            107,
+            794,
+            309
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            390,
+            825,
+            473
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "These results confirm the mechanism through which our proposed loss pushes $W$ to learn the same column space as $L ^ { T }$ , and it suggests that reusing the input embedding matrix by explicitly constraining $\\mathbf { \\bar { \\boldsymbol { W } } } = \\mathbf { \\boldsymbol { L } } ^ { T }$ is not simply a kind of regularization, but is in fact an optimal choice in our framework. What can be achieved separately with each of the two proposed improvements as well as with the two of them combined is a question of empirical nature, which we investigate in the next section. ",
+        "bbox": [
+            174,
+            481,
+            825,
+            564
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "6.3 RESULTS ON PTB AND WIKITEXT-2 DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            583,
+            540,
+            598
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In order to investigate the extent to which each of our proposed improvements helps with learning, we train 4 different models for each network size: (1) 2-Layer LSTM with variational dropout (VD-LSTM) (2) 2-Layer LSTM with variational dropout and augmented loss (VD-LSTM $+ \\mathrm { A L }$ ) (3) 2-Layer LSTM with variational dropout and reused embeddings (VD-LSTM $+ \\mathrm { R E }$ ) (4) 2-Layer LSTM with variational dropout and both RE and AL (VD-LSTM $+ \\mathrm { R E A L }$ ). ",
+        "bbox": [
+            174,
+            611,
+            825,
+            681
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Figure 2 shows the validation perplexities of the four models during training on the PTB corpus for small (panel a) and large (panel b) networks. All of AL, RE, and REAL networks significantly outperform the baseline in both cases. Table 1 compares the final validation and test perplexities of the four models on both PTB and Wikitext-2 for each network size. In both datasets, both AL and RE improve upon the baseline individually, and using RE and AL together leads to the best performance. Based on performance comparisons, we make the following notes on the two proposed improvements: ",
+        "bbox": [
+            173,
+            688,
+            825,
+            785
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "• AL provides better performance gains for smaller networks. This is not surprising given the fact that small models are rather inflexible, and one would expect to see improved learning by training against a more informative data distribution (contributed by the augmented loss) (see Hinton et al. (2015)). For the smaller PTB dataset, performance with AL surpasses that with RE. In comparison, for the larger Wikitext-2 dataset, improvement by AL is more limited. This is expected given larger training sets better represent the true data distribution, mitigating the supervision problem. In fact, we set out to validate this reasoning in a direct manner, and additionally train the small networks separately on the first and second halves of the Wikitext-2 training set. This results in two distinct datasets which are each about the same size as PTB (1044K vs 929K). As can be seen in Table 2, AL has significantly improved competitive performance against RE and REAL despite the fact that embedding size is 3 times larger compared to PTB. These results support our argument that the proposed augmented loss term acts to improve the amount of information gathered from the dataset. ",
+        "bbox": [
+            215,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/79a74db09e252b3916e14b02939c9c72b6cb35eb02fbb4d38c7e074b7c9f7001.jpg",
+        "image_caption": [
+            "Figure 2: Progress of validation perplexities during training for the 4 different models for two (small (200) and large (1500)) network sizes. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            113,
+            790,
+            296
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            230,
+            385,
+            825,
+            454
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "• RE significantly outperforms AL for larger networks. This indicates that, for large models, the more effective mechanism of our proposed framework is the one which enforces proximity between the output projection space and the input embedding space. From a model complexity perspective, the nontrivial gains offered by RE for all network sizes and for both datasets could be largely attributed to its explicit function to reduce the model size while preserving the representational power according to our framework. ",
+        "bbox": [
+            217,
+            455,
+            825,
+            537
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We list in Table 3 the comparison of models with and without our proposed modifications on the Penn Treebank Corpus. The best LSTM model (VD-LSTM $^ +$ REAL) outperforms all previous work which uses conventional framework, including large ensembles. The recently proposed recurrent highway networks (Zilly et al., 2016) when trained with reused embeddings (VD-RHN $+ \\mathrm { R E }$ ) achieves the best overall performance, improving on VD-RHN by a perplexity of 2.5. ",
+        "bbox": [
+            174,
+            561,
+            825,
+            632
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/bfd105264191ba57a695cd0b9d358d4b2572268a6f7880081f2fe54ea81dcad7.jpg",
+        "table_caption": [
+            "Table 1: Comparison of the final word level perplexities on the validation and test set for the 4 different models. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\"></td><td colspan=\"2\">PTB</td><td colspan=\"2\">Wikitext-2</td></tr><tr><td>Network</td><td>Model</td><td>Valid</td><td>Test</td><td>Valid</td><td>Test</td></tr><tr><td rowspan=\"4\">Small4 (200 units)</td><td>VD-LSTM</td><td>92.6</td><td>87.3</td><td>112.2</td><td>105.9</td></tr><tr><td>VD-LSTM+AL</td><td>86.3</td><td>82.9</td><td>110.3</td><td>103.8</td></tr><tr><td>VD-LSTM+RE</td><td>89.9</td><td>85.1</td><td>106.1</td><td>100.5</td></tr><tr><td>VD-LSTM+REAL</td><td>86.3</td><td>82.7</td><td>105.6</td><td>98.9</td></tr><tr><td rowspan=\"4\">Medium (650 units)</td><td>VD-LSTM</td><td>82.0</td><td>77.7</td><td>100.2</td><td>95.3</td></tr><tr><td>VD-LSTM+AL</td><td>77.4</td><td>74.7</td><td>98.8</td><td>93.1</td></tr><tr><td>VD-LSTM+RE</td><td>77.1</td><td>73.9</td><td>92.3</td><td>87.7</td></tr><tr><td>VD-LSTM+REAL</td><td>75.7</td><td>73.2</td><td>91.5</td><td>87.0</td></tr><tr><td rowspan=\"4\">(1500 units)</td><td>VD-LSTM</td><td>76.8</td><td>72.6</td><td>-</td><td>-</td></tr><tr><td>VD-LSTM+AL</td><td>74.5</td><td>71.2</td><td></td><td></td></tr><tr><td>VD-LSTM+RE</td><td>72.5</td><td>69.0</td><td></td><td></td></tr><tr><td>VD-LSTM+REAL</td><td>71.1</td><td>68.5</td><td>=</td><td></td></tr></table>",
+        "bbox": [
+            274,
+            699,
+            722,
+            915
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/65e08f1d9cf82f9097f87ba50f4ace09b4adaaeca034d2877e086671f379bd67.jpg",
+        "table_caption": [
+            "Table 2: Performance of the four different small models trained on the equally sized two partitions of Wikitext2 training set. These results are consistent with those on PTB (see Table 1), which has a similar training set size with each of these partitions, although its word embedding dimension is three times smaller. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\"></td><td colspan=\"2\">Wikitext-2, Partition 1</td><td colspan=\"2\">Wikitext-2,Partition 2</td></tr><tr><td>Network</td><td>Model</td><td>Valid</td><td>Test</td><td>Valid</td><td>Test</td></tr><tr><td rowspan=\"4\">Small (200 units)</td><td>VD-LSTM</td><td>159.1</td><td>148.0</td><td>163.19</td><td>148.6</td></tr><tr><td>VD-LSTM+AL</td><td>153.0</td><td>142.5</td><td>156.4</td><td>143.7</td></tr><tr><td>VD-LSTM+RE</td><td>152.4</td><td>141.9</td><td>152.5</td><td>140.9</td></tr><tr><td>VD-LSTM+REAL</td><td>149.3</td><td>140.6</td><td>150.5</td><td>138.4</td></tr></table>",
+        "bbox": [
+            230,
+            159,
+            764,
+            252
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 3: Comparison of our work to previous state of the art on word-level validation and test perplexities on the Penn Treebank corpus. Models using our framework significantly outperform other models. ",
+        "bbox": [
+            173,
+            279,
+            823,
+            305
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/2e364a64be6178d1682c3a93cb33397dbfea265c71b78de341bf959daaba1c1e.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Parameters</td><td>Validation</td><td>Test</td></tr><tr><td>RNN (Mikolov &amp; Zweig)</td><td>6M</td><td></td><td>124.7</td></tr><tr><td>RNN+LDA (Mikolov &amp; Zweig)</td><td>7M</td><td>=</td><td>113.7</td></tr><tr><td>RNN+LDA+KN-5+Cache (Mikolov &amp; Zweig)</td><td>9M</td><td>=</td><td>92.0</td></tr><tr><td>Deep RNN (Pascanu et al., 2013a)</td><td>6M</td><td>-</td><td>107.5</td></tr><tr><td>Sum-Prod Net (Cheng et al.,2014)</td><td>5M</td><td>■</td><td>100.0</td></tr><tr><td>LSTM (medium) (Zaremba et al., 2014)</td><td>20M</td><td>86.2</td><td>82.7</td></tr><tr><td>CharCNN (Kim et al., 2015)</td><td>19M</td><td>-</td><td>78.9</td></tr><tr><td>LSTM (large) (Zaremba et al., 2014)</td><td>66M</td><td>82.2</td><td>78.4</td></tr><tr><td>VD-LSTM (large,untied, MC) (Gal, 2015)</td><td>66M</td><td>1</td><td>73.4± 0.0</td></tr><tr><td>Pointer Sentinel-LSTM(medium) (Merity et al., 2016)</td><td>21M</td><td>72.4</td><td>70.9</td></tr><tr><td>38Large LSTMs (Zaremba et al., 2014)</td><td>2.51B</td><td>71.9</td><td>68.7</td></tr><tr><td>10 Large VD-LSTMs (Gal,2015)</td><td>660M</td><td>1</td><td>68.7</td></tr><tr><td>VD-RHN (Zilly et al., 2016)</td><td>32M</td><td>71.2</td><td>68.5</td></tr><tr><td>VD-LSTM+REAL (large)</td><td>51M</td><td>71.1</td><td>68.5</td></tr><tr><td>VD-RHN +RE (Zilly et al., 2016) </td><td>24M</td><td>68.1</td><td>66.0</td></tr></table>",
+        "bbox": [
+            196,
+            321,
+            799,
+            568
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6.4 QUALITATIVE RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            598,
+            379,
+            613
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "One important feature of our framework that leads to better word predictions is the explicit mechanism to assign probabilities to words not merely according to the observed output statistics, but also considering the metric similarity between words. We observe direct consequences of this mechanism qualitatively in the Penn Treebank in different ways: First, we notice that the probability of generating the ${ \\tt c u n k } >$ token with our proposed network (VD-LSTM $+$ REAL) is significantly lower compared to the baseline network (VD-LSTM) across many words. This could be explained by noting the fact that the ${ \\mathrm { \\ c u n k { \\mathrm { > } } } }$ token is an aggregated token rather than a specific word, and it is often not expected to be close to specific words in the word embedding space. We observe the same behavior with very frequent words such as ”a”, ”an”, and ”the”, owing to the same fact that they are not correlated with particular words. Second, we not only observe better probability assignments for the target words, but we also observe relatively higher probability weights associated with the words close to the targets. Sometimes this happens in the form of predicting words semantically close together which are plausible even when the target word is not successfully captured by the model. We provide a few examples from the PTB test set which compare the prediction performance of 1500 unit VD-LSTM and 1500 unit VD-LSTM $+ \\mathrm { R E A L }$ in table 4. We would like to note that prediction performance of VD-LSTM $+ \\mathrm { R E }$ is similar to VD-LSTM $+$ REAL for the large network. ",
+        "bbox": [
+            174,
+            625,
+            825,
+            845
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/4d7b7a7f015ab1343e5a29b3acb8c3a5fa270141a68a8955f4a9fb8b862734d8.jpg",
+        "table_caption": [
+            "Table 4: Prediction for the next word by the baseline (VD-LSTM) and proposed (VD-LSTM $+$ REAL) networks for a few example phrases in the PTB test set. Top 10 word predictions are sorted in descending probability, and are arranged in column-major format. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Phrase + Next word(s)</td><td colspan=\"2\">Top 10 predicted words VD-LSTM</td><td colspan=\"2\">Top 10 predicted words VD-LSTM+REAL</td></tr><tr><td>information international said it believes that the complaints filed in + federal court</td><td>the 0.27 a 0.13 federal 0.13 N 0.09 {unk) 0.05</td><td>an 0.03 august 0.01 new 0.01 response 0.01 connection 0.01</td><td>federal 0.22 the 0.1 a 0.08 N 0.06 state 0.04</td><td>connection 0.03 august 0.03 july 0.03 an 0.03 september 0.03</td></tr><tr><td>oil company refineries ran flat out to prepare for a robust holiday driving season in july and +august</td><td>the 0.09 N 0.08 a 0.07 {unk) 0.07 was 0.04</td><td>in 0.03 has 0.03 is 0.02 will 0.02 its 0.02</td><td>august 0.08 N 0.05 early 0.05 september 0.05 the 0.03</td><td>a0.03 in 0.03 that 0.02 ended 0.02 its 0.02</td></tr><tr><td>southmark said it plans to {unk&gt;its {unk&gt; to provide financial results as soon as its audit is +completed</td><td>the 0.06 {unk)0.05 a 0.05 in 0.04 n&#x27;t 0.04</td><td>to 0.03 likely 0.03 expected 0.03 scheduled 0.01 completed 0.01</td><td>expected 0.1 completed 0.04 {unk) 0.03 the 0.03 in 0.03</td><td>a 0.03 scheduled 0.03 n&#x27;t 0.03 due 0.02 to 0.01</td></tr><tr><td>merieux said the government &#x27;s minister of industry science and + technology</td><td>{unk) 0.33 the 0.06 a 0.01 other 0.01 others 0.01</td><td>industry 0.01 commerce 0.01 planning 0.01 management 0.01 mail 0.01</td><td>{unk) 0.09 health 0.08 development 0.04 the 0.04 a 0.03</td><td>industry 0.03 business 0.02 telecomm. 0.02 human 0.02 other 0.01</td></tr></table>",
+        "bbox": [
+            173,
+            159,
+            849,
+            496
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "7 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            526,
+            320,
+            541
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this work, we introduced a novel loss framework for language modeling. Particularly, we showed that the metric encoded into the space of word embeddings could be used to generate a more informed data distribution than the one-hot targets, and that additionally training against this distribution improves learning. We also showed theoretically that this approach lends itself to a second improvement, which is simply reusing the input embedding matrix in the output projection layer. This has an additional benefit of reducing the number of trainable variables in the model. We empirically validated the theoretical link, and verified that both proposed changes do in fact belong to the same framework. In our experiments on the Penn Treebank corpus and Wikitext-2, we showed that our framework outperforms the conventional one, and that even the simple modification of reusing the word embedding in the output projection layer is sufficient for large networks. ",
+        "bbox": [
+            173,
+            556,
+            825,
+            696
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The improvements achieved by our framework are not unique to vanilla language modeling, and are readily applicable to other tasks which utilize language models such as neural machine translation, speech recognition, and text summarization. This could lead to significant improvements in such models especially with large vocabularies, with the additional benefit of greatly reducing the number of parameters to be trained. ",
+        "bbox": [
+            174,
+            703,
+            825,
+            773
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            287,
+            117
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yoshua Bengio, Rejean Ducharme, and Pascal Vincent. A neural probabilistic language model.´ 2001. URL http://www.iro.umontreal.ca/˜lisa/pointeurs/nips00_lm.ps. ",
+        "bbox": [
+            174,
+            126,
+            823,
+            155
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "◦Ake Bjorck and Gene H Golub. Numerical methods for computing angles between linear subspaces. ¨ Mathematics of computation, 27(123):579–594, 1973. ",
+        "bbox": [
+            173,
+            165,
+            821,
+            195
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Wei-Chen Cheng, Stanley Kok, Hoai Vu Pham, Hai Leong Chieu, and Kian Ming Adam Chai. Language modeling with sum-product networks. 2014. ",
+        "bbox": [
+            173,
+            203,
+            821,
+            232
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kyunghyun Cho, Bart Van Merrienboer, Dzmitry Bahdanau, and Yoshua Bengio. On the properties ¨ of neural machine translation: Encoder-decoder approaches. arXiv preprint arXiv:1409.1259, 2014. ",
+        "bbox": [
+            176,
+            239,
+            823,
+            284
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Orhan Firat, Kyunghyun Cho, and Yoshua Bengio. Multi-way, multilingual neural machine translation with a shared attention mechanism. arXiv preprint arXiv:1601.01073, 2016. ",
+        "bbox": [
+            173,
+            291,
+            823,
+            320
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Charlie Frogner, Chiyuan Zhang, Hossein Mobahi, Mauricio Araya, and Tomaso A Poggio. Learning with a wasserstein loss. In Advances in Neural Information Processing Systems, pp. 2053– 2061, 2015. ",
+        "bbox": [
+            176,
+            329,
+            821,
+            372
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yarin Gal. A theoretically grounded application of dropout in recurrent neural networks. arXiv preprint arXiv:1512.05287, 2015. ",
+        "bbox": [
+            171,
+            381,
+            823,
+            410
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. arXiv preprint arXiv:1503.02531, 2015. ",
+        "bbox": [
+            171,
+            417,
+            823,
+            446
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997. ",
+        "bbox": [
+            173,
+            455,
+            823,
+            484
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hakan Inan and Khashayar Khosravi. Improved learning through augmenting the loss. Stanford CS 224D: Deep Learning for Natural Language Processing, Spring 2016, 2016. ",
+        "bbox": [
+            171,
+            492,
+            823,
+            522
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kazuki Irie, Zoltan T ´ uske, Tamer Alkhouli, Ralf Schl ¨ uter, and Hermann Ney. Lstm, gru, high-¨ way and a bit of attention: an empirical overview for language modeling in speech recognition. Interspeech, San Francisco, CA, USA, 2016. ",
+        "bbox": [
+            176,
+            530,
+            820,
+            574
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Camille Jordan. Essai sur la geom´ etrie ´ a\\` $n$ dimensions. Bulletin de la Societ´ e math ´ ematique de ´ France, 3:103–174, 1875. ",
+        "bbox": [
+            174,
+            580,
+            821,
+            611
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yoon Kim, Yacine Jernite, David Sontag, and Alexander M Rush. Character-aware neural language models. arXiv preprint arXiv:1508.06615, 2015. ",
+        "bbox": [
+            174,
+            618,
+            821,
+            648
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mitchell P Marcus, Mary Ann Marcinkiewicz, and Beatrice Santorini. Building a large annotated corpus of english: The penn treebank. Computational linguistics, 19(2):313–330, 1993. ",
+        "bbox": [
+            174,
+            656,
+            821,
+            686
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Stephen Merity, Caiming Xiong, James Bradbury, and Richard Socher. Pointer sentinel mixture models. arXiv preprint arXiv:1609.07843, 2016. ",
+        "bbox": [
+            174,
+            694,
+            821,
+            723
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tomas Mikolov and Geoffrey Zweig. Context dependent recurrent neural network language model. ",
+        "bbox": [
+            171,
+            731,
+            821,
+            747
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tomas Mikolov, Martin Karafiat, Lukas Burget, Jan Cernock ´ y, and Sanjeev Khudanpur. Recurrent \\` neural network based language model. In Interspeech, volume 2, pp. 3, 2010. ",
+        "bbox": [
+            173,
+            755,
+            823,
+            785
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tomas Mikolov, Ilya Sutskever, Kai Chen, Greg S Corrado, and Jeff Dean. Distributed representations of words and phrases and their compositionality. In Advances in neural information processing systems, pp. 3111–3119, 2013. ",
+        "bbox": [
+            173,
+            791,
+            823,
+            835
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Andriy Mnih and Geoffrey Hinton. Three new graphical models for statistical language modelling. In Proceedings of the 24th international conference on Machine learning, pp. 641–648. ACM, 2007. ",
+        "bbox": [
+            174,
+            843,
+            821,
+            886
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ramesh Nallapati, Bowen Zhou, C¸ aglar Gulc¸ehre, and Bing Xiang. Abstractive text summarization using sequence-to-sequence rnns and beyond. 2016. ",
+        "bbox": [
+            176,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Razvan Pascanu, C¸ aglar Gulc¸ehre, Kyunghyun Cho, and Yoshua Bengio. How to construct deep ¨ recurrent neural networks. CoRR, abs/1312.6026, 2013a.   \nRazvan Pascanu, Tomas Mikolov, and Yoshua Bengio. On the difficulty of training recurrent neural networks. ICML (3), 28:1310–1318, 2013b.   \nJeffrey Pennington, Richard Socher, and Christopher D Manning. Glove: Global vectors for word representation. In EMNLP, volume 14, pp. 1532–43, 2014.   \nOfir Press and Lior Wolf. Using the output embedding to improve language models. arXiv preprint arXiv:1608.05859, 2016.   \nAlexander M Rush, Sumit Chopra, and Jason Weston. A neural attention model for abstractive sentence summarization. arXiv preprint arXiv:1509.00685, 2015.   \nRichard Socher, Alex Perelygin, Jean Y Wu, Jason Chuang, Christopher D Manning, Andrew $\\mathrm { \\Delta Y N g }$ , and Christopher Potts. Recursive deep models for semantic compositionality over a sentiment treebank. Citeseer, 2013.   \nWojciech Zaremba, Ilya Sutskever, and Oriol Vinyals. Recurrent neural network regularization. arXiv preprint arXiv:1409.2329, 2014.   \nJulian Georg Zilly, Rupesh Kumar Srivastava, Jan Koutn´ık, and Jurgen Schmidhuber. Recurrent ¨ highway networks. arXiv preprint arXiv:1607.03474, 2016. ",
+        "bbox": [
+            169,
+            102,
+            826,
+            412
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            313,
+            121
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A MODEL AND TRAINING DETAILS ",
+        "bbox": [
+            174,
+            169,
+            485,
+            185
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We begin training with a learning rate of 1 and start decaying it with a constant rate after a certain epoch. This is 5, 10, and 1 for the small, medium, and large networks respectively. The decay rate is 0.9 for the small and medium networks, and 0.97 for the large network. ",
+        "bbox": [
+            174,
+            218,
+            825,
+            260
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "For both PTB and Wikitext-2 datasets, we unroll the network for 35 steps for backpropagation. ",
+        "bbox": [
+            173,
+            267,
+            794,
+            281
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We use gradient clipping (Pascanu et al., 2013b); i.e. we rescale the gradients using the global norm if it exceeds a certain value. For both datasets, this is 5 for the small and the medium network, and 6 for the large network. ",
+        "bbox": [
+            176,
+            287,
+            818,
+            330
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We use the dropout method introduced in Gal (2015); particularly, we use the same dropout mask for each example through the unrolled network. Differently from what was proposed in Gal (2015), we tie the dropout weights for hidden states further, and we use the same mask when they are propagated as states in the current layer and when they are used as inputs for the next layer. We don’t use dropout in the input embedding layer, and we use the same dropout probability for inputs and hidden states. For PTB, dropout probabilities are 0.7, 0.5 and 0.35 for small, medium and large networks respectively. For Wikitext-2, probabilities are 0.8 for the small and 0.6 for the medium networks. ",
+        "bbox": [
+            173,
+            337,
+            825,
+            449
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "When training the networks with the augmented loss (AL), we use a temperature $\\tau = 2 0$ . We have empirically observed that setting $\\alpha$ , the weight of the augmented loss, according to $\\alpha = \\gamma \\tau$ for all the networks works satisfactorily. We set $\\gamma$ to values between 0.5 and 0.8 for the PTB dataset, and between 1.0 and 1.5 for the Wikitext-2 dataset. We would like to note that we have not observed sudden deteriorations in the performance with respect to moderate variations in either $\\tau$ or $\\alpha$ . ",
+        "bbox": [
+            174,
+            455,
+            825,
+            526
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B METRIC FOR CALCULATING SUBSPACE DISTANCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            574,
+            635,
+            592
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "In this section, we detail the metric used for computing the subspace distance between two matrices. The computed metric is closely related with the principle angles between subspaces, first defined in Jordan (1875). ",
+        "bbox": [
+            174,
+            623,
+            825,
+            665
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Our aim is to compute a metric distance between two given matrices, $X$ and $Y$ . We do this in three steps: ",
+        "bbox": [
+            176,
+            672,
+            823,
+            702
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(1) Obtain two matrices with orthonormal columns, $U$ and $V$ , such that s $\\scriptstyle \\operatorname { \\mathtt { p a n } } ( U ) = \\operatorname { \\mathtt { s p a n } } ( X )$ and span $\\scriptstyle 1 ( V ) = \\operatorname { s p a n } ( Y )$ . $U$ and $V$ could be obtained with a QR decomposition.   \n(2) Calculate the projection of either one of $U$ and $V$ onto the other; e.g. do $S = U U ^ { T } V$ , where $S$ is the projection of $V$ onto $U$ . Then calculate the residual matrix as $R = V - S$ .   \n(3) Let $\\| . \\| _ { F r }$ denote the frobenious norm, and let $C$ be the number of columns of $R$ . Then the distance metric is found as $d$ where $\\begin{array} { r } { d ^ { 2 } = \\frac { 1 } { C } \\| R \\| _ { F r } ^ { 2 } = \\frac { 1 } { C } \\mathrm { T r a c e } ( R ^ { T } R ) } \\end{array}$ . ",
+        "bbox": [
+            204,
+            724,
+            825,
+            845
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We note that $d$ as calculated above is a valid metric up to the equivalence set of matrices which span the same column space, although we are not going to show it. Instead, we will mention some metric properties of $d$ , and relate it to the principal angles between the subspaces. We first work out an expression for $d$ : ",
+        "bbox": [
+            174,
+            867,
+            823,
+            922
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c33db8382eb0f878d7dddc50ca69dd6a70e49712cefc474c1d5513423536148c.jpg",
+        "text": "$$\n\\begin{array} { r l } { C d ^ { 2 } = \\operatorname { T a c e } ( R ^ { T } R ) = \\operatorname { T r a c e } \\left( ( V - U U ^ { T } V ) ^ { T } ( V - U U ^ { T } V ) \\right) } \\\\ & { = \\operatorname { T a c e } \\left( V ^ { T } ( I - U U ^ { T } ) ( I - U U ^ { T } V ) V \\right) } \\\\ & { = \\operatorname { T a c e } \\left( V ^ { T } ( I - U U ^ { T } ) V \\right) } \\\\ & { = \\operatorname { T a c e } \\left( ( I - U U ^ { T } ) V V ^ { T } \\right) } \\\\ & { = \\operatorname { T a c e } \\left( V ^ { T } V \\right) - \\operatorname { T a c e } \\left( U U ^ { T } V V ^ { T } \\right) } \\\\ & { = C - \\operatorname { T a c e } \\left( U U ^ { T } V V ^ { T } \\right) } \\\\ & { = C - \\operatorname { T a c e } \\left( ( U ^ { T } V ) ^ { T } ( U ^ { T } V ) \\right) } \\\\ & { = C - \\operatorname { T a c e } \\left( ( U ^ { T } V ) ^ { T } ( U ^ { T } V ) \\right) } \\\\ & { = C - \\operatorname { \\alpha c e } \\left( 1 6 ^ { T } V \\right) } \\\\ & { = \\frac { C } { \\lambda - 1 } ^ { 1 } - \\rho _ { i } ^ { 2 } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            289,
+            123,
+            704,
+            332
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "where $\\rho _ { i }$ is the $i ^ { \\mathrm { { t h } } }$ singular value of $U ^ { T } V$ , commonly referred to as the $i ^ { \\mathrm { { t h } } }$ principle angle between the subspaces of $X$ and $Y , \\theta _ { i }$ . In above, we used the cyclic permutation property of the trace in the third and the fourth lines. ",
+        "bbox": [
+            173,
+            338,
+            825,
+            382
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Since $d ^ { 2 }$ is $\\scriptstyle { \\frac { 1 } { C } } \\mathrm { T r a c e } ( R ^ { T } R )$ , it is always nonnegative, and it is only zero when the residual is zero, which is the case whenthe form of (B.1) (singu $\\operatorname { s p a n } ( X ) = \\operatorname { s p a n } ( \\mathrm { Y } )$ .d er, it is symmetric bare the same). Also, $U$ $V$ , $V ^ { T } U$ $V ^ { T } U$ $\\begin{array} { r } { d ^ { 2 } = \\frac { 1 } { C } \\sum _ { i = 1 } ^ { C } \\sin ^ { 2 } ( \\theta _ { i } ) . } \\end{array}$ namely the average of the sines of the principle angles, which is a quantity between 0 and 1. ",
+        "bbox": [
+            173,
+            387,
+            825,
+            449
+        ],
+        "page_idx": 12
+    }
+]