Add files using upload-large-folder tool

parse/train/B1xmOgrFPS/B1xmOgrFPS.md

@@ -0,0 +1,249 @@
+# META-RCNN: META LEARNING FOR FEW-SHOT OBJECT DETECTION
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Despite significant advances in object detection in recent years, training effective detectors in a small data regime remains an open challenge. Labelling training data for object detection is extremely expensive, and there is a need to develop techniques that can generalize well from small amounts of labelled data. We investigate this problem of few-shot object detection, where a detector has access to only limited amounts of annotated data. Based on the recently evolving meta-learning principle, we propose a novel meta-learning framework for object detection named “Meta-RCNN”, which learns the ability to perform few-shot detection via meta-learning. Specifically, Meta-RCNN learns an object detector in an episodic learning paradigm on the (meta) training data. This learning scheme helps acquire a prior which enables Meta-RCNN to do few-shot detection on novel tasks. Built on top of the Faster RCNN model, in Meta-RCNN, both the Region Proposal Network (RPN) and the object classification branch are meta-learned. The meta-trained RPN learns to provide class-specific proposals, while the object classifier learns to do few-shot classification. The novel loss objectives and learning strategy of Meta-RCNN can be trained in an end-to-end manner. We demonstrate the effectiveness of Meta-RCNN in addressing few-shot detection on Pascal VOC dataset and achieve promising results.
+
+# 1 INTRODUCTION
+
+Object detection is the task of identifying various objects in a given image, and localizing them with a bounding box. It is a widely studied problem in computer vision, and following the success deep convolutional neural networks (DCNN) in image classification (Karpathy et al., 2014; Krizhevsky et al., 2012), recent years have witnessed remarkable progress made in object detection based on deep learning. A series of detection algorithms based on DCNNs have been proposed which achieve state-of-the-art results on public detection benchmark datasets (Gidaris & Komodakis, 2015; Girshick et al., 2014; Ren et al., 2015; Lin et al., 2017a;b; Liu et al., 2016; Redmon & Farhadi, 2016). However, all these methods are data hungry, and require large amounts of annotated data to learn an immense number of parameters. For object detection, annotating the data is every expensive (much more than image classification), as it requires not only identifying the categorical labels for every object in the image, but also providing accurate localization information through bounding box coordinates. Moreover, in some applications, such as medical research, it’s often impossible to even collect sufficient data to annotate. This warrants a need for effective detectors that can generalize well from small amounts of annotated data. We refer to the problem of learning detectors from limited labeled data as few-shot detection. For example, in one-shot detection, only one image is available with objects of interest annotated, and a detector needs to train on just this image and generalize. When presented with such small amounts of annotated data, traditional detectors tend to suffer from overfitting. Inspired by the fact that humans can learn a new concepts from little annotated data, we aim to develop a new few-shot detection algorithm.
+
+There have been several efforts exploring few-shot learning (Vinyals et al., 2016; Finn et al., 2017; Snell et al., 2017). Many of them follow the principle of meta learning. In meta learning, a set of tasks in a few-shot setting is simulated from a large corpus of annotated data, and the model is optimized to perform well over these few shot tasks. This trains the model to learn how to solve few-shot tasks. However, most existing efforts of meta learning are mainly focused on classification. Adapting few-shot classification algorithms directly for few-shot detection (e.g. by replacing the region classification branch of detector with a meta-learner) is non-trivial because of two major concerns: i). Detection algorithms not only require classifying objects but also need to correctly localize objects in cluttered backgrounds by using a Region Proposal Network (RPN) and bounding box (bbox) regressors. It is thus also desirable that both RPN and bbox regressors should also be capable enough to adapt to few-shot settings. ii). For a given task with one (or few) annotated image(s), the annotated image may contain objects from several classes. But only a few objects of interest are annotated. The goal of the few-shot detector is to detect only these objects of interest. Unfortunately, a naively trained meta-detector’s RPN would detect all objects (even objects from classes not of interest) and try to classify them as one of the classes of interest rather than background images (See Figure 1 for an example).
+
+![](images/7f5f879399d45be9afc799e08fc70cd081a33c773abb9d01cdfd53f0f02dc64e.jpg)  
+Figure 1: Few-Shot object detection in the meta-learning setting. From the meta-train dataset, a Kway-Nshot support set and a query set are sampled to create a task. The meta detector makes predictions on the query set by using the knowledge from the support set, and updates the detector based on the loss on the query set. In the example above, there are many objects (person, dog and truck), but it is annotated with the goal of detecting only a person. At test time, a single annotated image from a novel class (bear) is available for the detector to learn a model that can generalize.
+
+We aim to address these challenges by proposing a novel method for solving few-shot detection using the meta-learning paradigm. We develop Meta-RCNN, an end to end trainable meta object detector. The proposed Meta-RCNN follows the episodic learning paradigm of meta-learning (Vinyals et al., 2016), where based on a give meta-train dataset, multiple few-shot tasks are simulated. For a given task, we first construct a class prototype for each of the annotated object categories in the support set. Using these prototypes, a class-specific feature map of the entire image is constructed, i.e., we obtain a feature map of the entire image for each of the class prototypes. These feature maps are tailored to detect only objects of the class of the prototype, by giving higher attention to appropriate regions in the image containing that object. Finally, all feature maps are merged to produce a combined feature map, followed by an RPN, and then classification and bbox regression layers.
+
+Meta-RCNN learns few-shot detector where the whole framework can be trained via meta-learning in an end-to-end manner. In contrast to the naive adaptation of meta-learning for classification into an object detection framework, Meta-RCNN learns the few-shot classifier, the RPN, and the bbox regressor in the meta-learning setting, thus making all three components suitable for handling fewshot scenarios. Moreover, Meta-RCNN learns a class-specific feature map for a given class prototype enabling easier distinction between classes of interest and backgrounds (where other objects in the image from classes not of interest are considered as backgrounds). We demonstrate the effectiveness of Meta-RCNN on two few-shot detection benchmarks: Pascal VOC and animal subset of ImageNet, and show that Meta-RCNN significantly improves the detection result in few shot settings.
+
+# 2 RELATED WORK
+
+Generic Object Detection. Object detection based on deep learning can be broadly divided into two families: two-stage detectors and one-stage detectors. Two-stage detectors such as RCNN (Girshick et al., 2014), Fast RCNN (Gidaris & Komodakis, 2015) and Faster RCNN (Ren et al., 2015), first generate a sparse set of proposal candidates, and a fixed-length feature vector is extracted from each of these candidates, followed by a categorical classifier and a bounding box regressor. Twostage detection algorithms have achieved state-of-the-art results on many public benchmarks (He et al., 2016; Lin et al., 2017a), but are relatively slower than one-stage detectors. One-stage detectors such as SSD (Liu et al., 2016), Yolo (Redmon et al., 2016; Redmon & Farhadi, 2016) and RefineDet (Zhang et al., 2018) directly generate categorical proposals from the feature map and thus avoid cascaded region classifiers. One-stage detectors can achieve real-time inference speed but the detection accuracy is often inferior to two-stage detection algorithms. Both detection families assume access to a large set of annotated data, and are not suitable for scenarios where the model has access to small amounts of annotated training data. In contrast, our proposed Meta-RCNN method addresses detection problem of few-shot setting, and achieves promising results.
+
+Meta Learning for few-shot classification. Few-shot learning has been widely explored in image classification, and currently the most promising methods are mainly based on meta learning. Ravi & Larochelle (2016) optimized the base-model via an LSTM-based meta-learner which simulates traditional SGD optimization method. Finn et al. (Finn et al., 2017) proposed MAML which learns a good feature initialization which can adapt to a new task in only one gradient step udpate. Based on MAML, Li et al. (2017) proposed Meta-SGD which learns a set of learnable parameters to control gradient step of different tasks. Learning initialization is potentially a very general idea for few-shot learning however, the training process can be unstable (Antoniou et al., 2018) especially for complex problems such as detection. Vinyals et al. (Vinyals et al., 2016; Snell et al., 2017) proposed a matching network which followed a non-parametric principle by learning a differentiable K-Nearest Neighbour model. Ren et al. (Ren et al., 2018) extended this idea to semi-supervised learning by self-learning from the unlabeled data. Sung et al. (Sung et al., 2018) proposed a relation network to automatically define the optimal distance metric. These metric-learning based methods are easy to train and effective in addressing few-shot classification. However, directly adapting these techniques for detection is very challenging as just replacing the object classification branch of a detector with a meta-learner is not sufficient, and training the RPN under a meta-learning paradigm is non-trivial.
+
+Few-shot Object Detection. Few-shot detection has received considerably less interest from the community. Dong et al. (Dong et al., 2018) addressed few-shot detection using large scale unlabeled data. Their model is based on a semi-supervised method which extracts knowledge from unlabeled dataset to enrich training dataset by self-paced learning and multi-modal learning. However, their method may be misled by the incorrect predictions from initial model and also requires re-training the model for every new task. Chen et al. (Chen et al., 2018) propose a Low-shot Transfer Detector (LSTD) using regularization to transfer the knowledge from source domain to target domain by minimizing the gap between these two domains. RepMet (Schwartz et al., 2019) is a few-shot detection algorithm based on meta learning. It replaces the fully connected classification layer of a standard detector with modified prototypical network. However, they suffer from the two limitations of the RPN and bbox regression not being able to handle few-shot settings, and difficulties in distinguishing object classes of interest from background (including object classes not of interest). Our proposed method is also based on meta learning but can be optimized end-to-end and addresses these limitations to do effective few-shot detection.
+
+# 3 PRELIMINARIES
+
+# 3.1 PROBLEM SETTING
+
+In this section we present the formal problem setting of few-shot detection investigated in our paper. Assume we have two datasets $L$ and $S$ , where $L$ is a large scale annotated dataset with $L _ { c }$ categories and $S$ is a dataset with only a few annotated images with $S _ { c }$ categories. There is no category overlap between two datasets: $L _ { c } \cap S _ { c } = \phi$ . Our goal is to learn a robust detector based on the annotated data in $L$ and $S$ to detect unlabeled objects of $S$ .
+
+The proposed Meta-RCNN aims to learn a general detection framework which can be quickly adapted to different detection tasks which have only a few labeled samples. We follow the standard training scheme of meta learning, which splits the whole learning stage into two parts: meta-training and meta-testing, and the model is optimized over multiple few-shot tasks simulated from the metatraining data. Specifically, during meta-training, few-shot detection tasks are sampled from $L$ , and each task contains a support set and a query set. For the $i$ -th task, $K$ ways (or categories) and $N$ images per category are randomly selected from $L _ { c }$ to build support set: $\mathrm { T } _ { i } ^ { \mathrm { L } , \mathrm { s } }$ . Similarly, $Q$ images per category are randomly selected to build query set $\mathrm { T } _ { i } ^ { \mathrm { L , q } }$ . Support set $\mathrm { T } _ { i } ^ { \mathrm { L } , \mathrm { s } }$ and query set $\mathrm { T } _ { i } ^ { \mathrm { L , q } }$ construct a complete task extracted from $L$ (See Figure 1):
+
+$$
+\begin{array} { r } { \mathrm { T } _ { i } ^ { L } = \left\{ \mathrm { T } _ { i } ^ { \mathrm { L } , \mathrm { s } } , \mathrm { T } _ { i } ^ { \mathrm { L } , \mathrm { q } } \right\} } \end{array}
+$$
+
+where both the support set and query set are used to train the meta-model. The meta-model optimizes the base-model with respect to the support set and makes predictions on query set. Finally the loss suffered on the query set is used to update the model. In the meta-testing stage, similar to metatraining stage, a set of few-shot tasks are sampled from $S$ :
+
+$$
+\begin{array} { r } { \mathrm { T } _ { i } ^ { S } = \left\{ \mathrm { T } _ { i } ^ { { \mathrm { S } } , { \mathrm { s } } } , \mathrm { T } _ { i } ^ { { \mathrm { S } } , { \mathrm { q } } } \right\} } \end{array}
+$$
+
+where $\mathrm { T } _ { i } ^ { \mathrm { S , s } }$ is support set and $\mathrm { T } _ { i } ^ { \mathrm { S , q } }$ is query set. The model makes predictions on the query set, and these results are averaged across several few-shot tasks to evaluate the expected performance of the few-shot detector over a variety of novel few-shot detection tasks.
+
+# 3.2 OVERVIEW OF FASTER RCNN
+
+Meta-RCNN is based on two-stage region based object detection algorithms. In this paper, we use the state-of-the-art detection algorithm Faster RCNN (Ren et al., 2015) as our base model, which is widely used in the computer vision community. Faster RCNN consists of two components, an RPN (Region Proposal Network) for proposal generation and Fast RCNN for region classification. RPN generates a sparse set of proposals which are classified into different categories by the region classifiers. Specifically, RPN extracts a feature vector from each region by scanning the whole image using sliding windows. This is followed by a binary classifier (objects vs backgrounds) and a bounding box regressor, where easy negatives are filtered. For each proposal, a fixed-length feature vector is extracted by using ROI Pooling layers. This vector is then fed into a sequence of dense connected layers branching into two outputs. One output is responsible for representing softmax probability over $K + 1$ classes( $K$ target classes and one background class), and the other one encodes four real-values for refining bounding box position. We denoted $u$ and $v$ as the category and bounding box label respectively, $p$ as the predicted probability distribution over C classes, and $t _ { u }$ as the predicted bounding box prediction of class $u$ , and $\lambda$ as the trade-off parameter. $L _ { \mathrm { c l s } }$ represents softmax loss and $L _ { \mathrm { l o c } }$ represents SmoothL1 loss function. The entire network can be optimized in an end-to-end manner by minimizing loss $L ( p , u , t ^ { u } , v )$ :
+
+$$
+\begin{array} { r } { L ( p , u , t ^ { u } , v ) = L _ { \mathrm { c l s } } ( p , u ) + \lambda [ u \geq 1 ] L _ { \mathrm { l o c } } ( t ^ { u } , v ) , } \end{array}
+$$
+
+However, two-stage detectors require a lot of training samples to obtain a good performance. In the next section, we present the proposed Meta-RCNN which builds over Faster RCNN and is specifically designed to address few-shot detection.
+
+# 4 META-RCNN
+
+# 4.1 OVERVIEW
+
+We now present our proposed method Meta-RCNN for few-shot detection (See Figure 2 for an overview). Meta-RCNN is trained with multiple few-shot tasks simulated from the meta-train dataset. For each episode, a few object categories of interest are assumed to be annotated (Support set). During meta-training, a prototype is computed for each object category. For each of these category prototypes, a class-specific feature map is generated by using a class-attention module which combines the prototype information with the feature map of the entire image. This feature map only highlights the signals of the class of interest, and suppresses information from other classes. Finally, feature maps of all target categories are combined, followed by RPN and RCNN branches to make predictions on the query set. Based on the loss on the query set, the model is updated.
+
+![](images/b52f0023c1f0af218431b36fa3102c84b153a96259a644df2e977b5e1d5cb980.jpg)  
+Figure 2: The Meta-RCNN workflow. A set of prototypes of different categories are extracted from the support set. For each class, conditioned on these prototypes, a class-specific feature map from query set is generated by applying the class attention module to the feature map of the entire image. The new class-specific feature map is tailored to detecting objects of that specific class. The classspecific feature maps are concatenated together and finally, an RPN is applied followed with region classification layer and bounding box regressors. The whole network is optimized via meta learning and can be trained end-to-end.
+
+Meta-RCNN is general paradigm to train few-shot detector via by meta-learning. For each task, irrelevant categories and background can be filtered by attention module, and the final generated feature map learns a general representation for the given few-shot detection task. Compared to other variants (Schwartz et al., 2019) which directly replaces the FC classification branch with a metalearning branch, Meta-RCNN is more general and the whole framework can be optimized including RPN and bbox regressors, making all the components few-shot capable. Next, we present the details of the model.
+
+# 4.2 META-TRAINING
+
+During Meta-Training, multiple Kway-Nshot tasks are simulated from the annotated dataset $L$ . To fit memory size, in Meta-Training stage we train the model using 5way-1shot tasks, and only 5 query images (1 query image per class). This results in a total of 10 images for one task. With this, implementing the meta-training is not too difficult. For each task $T _ { i } ^ { L }$ , images of support set $T _ { i } ^ { L , s }$ are fed into Faster RCNN to generate region features. For each of the object categories of interest (those assumed to be annotated in the support image), a prototype $P _ { c }$ is generated based on the corresponding region features:
+
+$$
+P _ { c } = \frac { 1 } { N _ { c } } \sum _ { i } ^ { N _ { c } } { r _ { c } ^ { i } }
+$$
+
+where $P _ { c }$ denotes prototype of class $c$ , and $r _ { c } ^ { i }$ denotes $i$ -th region features of all annotated objects from class $c$ . Based on these generated prototypes, images of query set $T _ { i } ^ { L , q }$ are fed into the same Faster RCNN model and we obtain the image feature map before RPN and ROI Pooling. For each category, a class-specific feature map is learned based on the input query image and its corresponding prototype. We use a learnable class attention module here to highlight the signals of target class and suppress signals of other categories. The class attention module is based on basic channel-wise multiplication. The prototype $P _ { c }$ is encoded by a FC layer $\phi$ , which is later combined with feature map $f$ by element-wise multiplication:
+
+$$
+F _ { c } = f \odot \phi ( P _ { c } )
+$$
+
+For each category $c$ , one new feature map $F _ { c }$ is generated which aims to highlight the objects of class $c$ . Next, all these new feature maps are combined into one feature map $F$ :
+
+$$
+F = { \mathrm { c o n c a t e } } \{ F _ { 1 } , F _ { 2 } , . . . , F _ { k } \}
+$$
+
+$F$ learns a general representation of $\mathbf { K }$ -classes, where each sub-channel contains information of different classes of interest. Based on the new feature map $F$ , 1x1 conv layer is used to reduce computation cost, followed by RPN to produce region proposals. In order to recover the information lost in attention module, we finally combine the new generated feature map with original feature map by element-wise summation, and crop region features based on the new generated map. Finally, a $\mathrm { K } { + } 1$ region classifier and a bbox regressors are optimized w.r.t the label info from query set $T _ { i } ^ { L , q }$ :
+
+$$
+L ( T _ { i } ^ { L , q } ; T _ { i } ^ { L , s } , \theta ) = L _ { \mathrm { l o c } } + L _ { \mathrm { c l s } } + L _ { \mathrm { R P N } }
+$$
+
+where $\theta$ represents the parameters of Meta-RCNN.
+
+# 4.3 META-TESTING
+
+During meta-testing, we sample few-shot detection tasks from $S$ . The annotations of support set are available and we make predictions on the query set to evaluate the performance of Meta-RCNN. For each task $T _ { i } ^ { S }$ , prototypes are generated from support set $\boldsymbol { T } _ { i } ^ { S , q }$ , which are later used to generate new class-specific feature maps of images from query set model based on the labeled images of support set. Th $\boldsymbol { T } _ { i } ^ { S , q }$ . In this stage, we need to finetune theetuning operation addresses the learning limitation of non-parametric method when more labeled images are provided. Finally, we evaluate the output from the query set as traditional detection problem:
+
+$$
+p , u = \mathbf { M e t a R C N N } ( T _ { i } ^ { S , q } ; T _ { i } ^ { S , s } , \theta )
+$$
+
+where $p$ is class probability vector and $u$ is location set of bounding boxes.
+
+# 5 EXPERIMENTS
+
+# 5.1 DATASETS AND IMPLEMENTATION DETAILS
+
+Table 1: Two few-shot object detection benchmark testbeds for performance evaluation   
+
+<table><tr><td rowspan=1 colspan=1>DATASET</td><td rowspan=1 colspan=1>Train</td><td rowspan=1 colspan=1>#Img</td><td rowspan=1 colspan=1>#cls</td><td rowspan=1 colspan=1>Test</td><td rowspan=1 colspan=1>#Img</td><td rowspan=1 colspan=1>#cls</td></tr><tr><td rowspan=1 colspan=1>VOC-FSOD</td><td rowspan=1 colspan=1>VOC2007trainval</td><td rowspan=1 colspan=1>~4.9k</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>VOC2007test</td><td rowspan=1 colspan=1>~2.2k</td><td rowspan=1 colspan=1>10</td></tr><tr><td rowspan=1 colspan=1>IMAGENET-FSOD</td><td rowspan=1 colspan=1>ImageNet-LOC</td><td rowspan=1 colspan=1>~ 53k</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>ImageNet-LOC</td><td rowspan=1 colspan=1>~117k</td><td rowspan=1 colspan=1>214</td></tr></table>
+
+Benchmark Datasets: We construct two benchmark testbeds to facilitate the performance evaluation for few-shot object detection in meta-learning settings. The first is on Pascal VOC2007, and the second is on the animal subset of ImageNet-LOC dataset. Table 1 gives details of these datasets. Pascal VOC2007 has 20 categories with 5k images in trainval set and $5 \mathrm { k }$ images in test set. A subset of 10 categories are randomly from selected for VOC2007 trainval set for Meta-Training and the remaining 10-category subset of VOC2007 test set is used for Meta-Testing. Images without target object categories are removed. For ImageNet-FSOD benchmark, we use the subset of first 100 animal classes of ImageNet in Meta-Training stage and the subset of remaining 214 animal species in ImageNet-LOC in Meta-Testing stage. The model used in VOC-FSOD benchmark is pre-trained on ImageNet, while in ImageNet-FSOD benchmark, the model is pre-trained on MSCOCO dataset with $1 1 5 \mathrm { k }$ images in 80 categories.
+
+Task Generation: For each benchmark, Meta-RCNN is evaluated on multiple tasks with different $K$ way- $N$ shot few-shot settings $N$ annotated images per category). For VOC-FSOD benchmark, we have 3 few-shot settings to evaluate Meta-RCNN: 5way-1shot, 5way-3shot and 5way-5shot. In detection, a single image has more than one object, and proposal generation will automatically increase the number of training samples, so the real number of training samples is about 5 times larger than $N$ . On ImageNet-FSOD benchmark, we mainly follow (Chen et al., 2018) and (Schwartz et al., 2019) with two settings: 50way-1shot and 50way-5shot.
+
+Meta-model Parameter Setting: In Meta-Training stage, totally 1000 distinct tasks and 5000 tasks are generated in VOC-FSOD benchmark and ImageNet-FSOD benchmark respectively. There are 10 images per class in query set to update the model weights for 10 epochs. The initial learning rate is set to 1e-3 and is reduced to 1e-4 every 600 tasks and 3500 tasks in VOC-FSOD benchmark and ImageNet-FSOD benchmark. We set the batch size as 5 during query update.
+
+Basic Detection Parameter Setting: The parameter settings in Meta-RCNN is identical to vanilla Faster RCNN. Proposal overlap with objects larger than 0.5 are considered positive and less than 0.3 are negative. During Meta-Training the top 128 confident proposals are selected for training and during evaluation, 300 proposals with largest confidence score are selected. we build our MetaRCNN based on Faster RCNN with VGG16 (Simonyan & Zisserman, 2014) and ResNet50 (He et al., 2016) model which is pretrained on ImageNet.
+
+Model Evaluation: We evaluate Meta-RCNN based on multiple tasks of few-shot settings, which follows the evaluation metric of standard meta learning. More specifically, in evaluation stage, 200 $K$ shot-N shot tasks are sampled from dataset $S$ and images in query set will be evaluated. Mean average precision(mAP) over selected $K$ categories is used as evaluation metric.
+
+# 5.2 RESULTS ON VOC-FSOD BENCHMARK
+
+We validate the effectiveness of Meta-RCNN on VOC-FSOD benchmark where subset of 10 VOC categories are selected for Meta-Training and the other ten categories are used for Meta-Testing. For fair comparison, these two subsets are split as similar as possible. For example, we keep animal categories on both sides since they share similar semantic information (see appendix for details). Here we set up three baselines on VOC-FSOD benchmark to compete with proposed Meta-RCNN.
+
+• vanilla FRCN (Ren et al., 2015): the vanilla Faster RCNN which is the most popular object detection algorithm with competitive performance on many benchmarks. The vanilla FRCN is not designed for few-shot detection problem, but we try to include this baseline by fine-tuning the detector on the few-shot training data. LSTD (Chen et al., 2018) is a few-shot detection algorithm based on Faster RCNN. LSTD uses categorical regularization items which transfers knowledge of $L$ dataset to $S$ dataset. FRCN-PN is a modified version of Faster RCNN using meta-learning, which replaces final FC classification layer with non-parametric prototypical network (PN), sharing the same principle of RepMet (Schwartz et al., 2019).
+
+All three baselines as well as the proposed Meta-RCNN are based on VGG16 (Simonyan & Zisserman, 2014) backbone. For Regular FRCN and LSTD, we first train a global Faster RCNN during Meta-Training. Then the pretrained detector models are adapted to different tasks during MetaTesting. During Meta-Testing, Meta-RCNN and vanilla FRCN are finetuned for 4 epochs while LSTD requires longer finetuning period (10 epochs). For FRCN-PN, prototypes of different categories are extracted as Meta-RCNN, and metric distances are learned to assign correct labels to each proposal. We report the results on Table 2 based on three different settings.
+
+From Table 2, the performances of all four methods improve with training shot increasing. Notably, FRCN-PN obtains much less improvement because the non-parametric property of PN layer limits its learning capacity from increased training samples. Benefit from the finetuning operation as well as FC layer in final classification and regression, Meta-RCNN can still maintain consistent improvement when trained with more samples. Furthermore, it’s interesting that Regular FRCN outperforms FRCN-PN even in very few-shot cases (5way-1shot), where non-parametric property does not help PN obtain better performance. We argue this is because few-shot detection problem is more difficult than few-shot classification problem, as we discussed in introduction section. FRCNPN cannot learn a representative prototype of background classes and the whole framework cannot be optimized by meta learning style (e.g., RPN and bbox regressors). The failure of FRCN-PN indicates naively attach components from few-shot classification framework cannot address few-shot detection problem. Finally, our Meta-RCNN achieves better results than all three baselines.
+
+Performance of RPN: Here, we present the performance of RPN to validate our concerns of the negative impact of irrelevant categories. We use regular FRCN and FRCN-PN as our baseline. The models are optimized in the same manner as before but during Meta-Testing, we evaluate the recall on each task instead of mAP. From Table 3, Regular FRCN baseline outperform the FRCNPN significantly. This is because objects of irrelevant categories in the same image hurt the training process of RPN. And our proposed Meta-RCNN outperforms these two baseline significantly. Meta
+
+Table 2: mAP Performance Evaluation on the VOC-FSOD BENCHMARK   
+
+<table><tr><td>Method</td><td>5way-1shot</td><td>5way-3shot</td><td>5way-5shot</td></tr><tr><td>vanilla FRCN (Ren et al., 2015)</td><td>14.78% ± 1.02%</td><td>20.34% ±1.26%</td><td>26.89% ± 1.23%</td></tr><tr><td>LSTD (Chen et al., 2018)</td><td>17.66% ± 1.65%</td><td>22.37% ± 0.81%</td><td>29.00% ±1.28%</td></tr><tr><td>FRCN-PN</td><td>12.71% ± 0.70%</td><td>13.91% ± 0.70%</td><td>14.33% ± 0.61%</td></tr><tr><td>Meta-RCNN (ours)</td><td>19.22% ± 1.01%</td><td>24.45% ± 1.20%</td><td>31.11% ± 0.88%</td></tr></table>
+
+RCNN learns a general feature map for all Kway-Nshot detection problem and optimize RPN by meta learning scheme, which proves more effective in few-shot settings. Notably, the results are surprising since the recall of RPN in few-shot scenario is significantly lower $( > 9 0 \%$ with enough training data on VOC dataset).
+
+<table><tr><td>Model</td><td>Backbone</td><td>5way-1shot</td><td>5way-3shot</td><td>5way-5shot</td></tr><tr><td>vanilla FRCN (Ren et al., 2015)</td><td>VGG16</td><td>24.9%</td><td>26.5%</td><td>28.4%</td></tr><tr><td>FRCN-PN</td><td>VGG16</td><td>24.7%</td><td>24.9%</td><td>26.1%</td></tr><tr><td>Meta-RCNN (ours)</td><td>VGG16</td><td>26.1%</td><td>27.9%</td><td>33.7%</td></tr></table>
+
+Table 3: Recall evaluation of Meta-RCNN on VOC-FSOD BENCHMARK test set.
+
+# 5.3 RESULTS ON IMAGENET-FSOD BENCHMARK
+
+On ImageNet-FSOD benchmark, we adapt weights of detector pretrained on MSCOCO trainval set, and then optimize Meta-RCNN based on this starting point. The Meta-RCNN is evaluated on animal subset of ImageNet-LOC. Animal subset of ImageNet-LOC only contains single animal category per image, so there are no irrelevant classes during training and it’s simpler than the situation we discussed. In addition to FRCN and LSTD, we also include another latest baseline RepMet (Schwartz et al., 2019), which replaces FC classification layers in FRCN with more careful design of PN layers, as well as much more stronger backbone architecture (DCN (Dai et al., 2017) and FPN (Lin et al., 2017a)). In this benchmark, we have 50 categories per task, so we attach a 1x1 convolution layer before class-specific feature map generation to reduce computation cost. We report the results in Tab. 4. In 50way-1shot and 50way-5shot, Meta-RCNN is better than other methods.
+
+<table><tr><td>Model</td><td>Backbone</td><td>50way-1shot</td><td>50way-5shot</td></tr><tr><td>vanilla FRCN (Ren et al., 2015)</td><td>VGG16</td><td>16.5%</td><td>34.3%</td></tr><tr><td>LSTD (Chen et al., 2018)</td><td>VGG16</td><td>19.2%</td><td>37.4%</td></tr><tr><td>RepMet (Schwartz et al.,2019)</td><td>DCN+FPN</td><td>24.1%</td><td>39.6%</td></tr><tr><td>Meta-RCNN (ours)</td><td>VGG16</td><td>24.6%</td><td>40.1%</td></tr><tr><td>Meta-RCNN (ours)</td><td>ResNet50</td><td>25.1%</td><td>40.3%</td></tr></table>
+
+Table 4: mAP performance evaluation on IMAGENET-FSOD BENCHMARK.
+
+# 5.4 DISCUSSIONS
+
+Extension to other Meta-Learning Methods: Beyond prototypical networks, other meta-learning methods such as MAML (Finn et al., 2017) in principle can also be applied, e.g., we can apply MAML for vanilla FRCN framework, which updates the base model with the average gradient step of multiple tasks. However, in our experiments, the training process of MAML was unstable. This may be because few-shot detection is generally more difficult than few-shot classification, due to multiple dependent loss objectives (FRCN relies on RPN and regression loss etc.) and more complicated noisy contexts. In future, we plan to explore extensions to other meta-learning methods.
+
+# 6 CONCLUSION
+
+Object detection has been widely explored but little attention has been given to learning detectors under a few-shot regime. In this paper we propose a meta learning based detection algorithm MetaRCNN, which is robust to few-shot learning, and the proposed training strategies make it more suitable in detection scenario. Specifically it adapts the Faster RCNN method and enables meta-learning of the object classifier, the RPN and the bounding box regressor. The RPN is meta-trained through a novel class-specific attention module. We conduct several experiments and obtain promising results.
+
+# REFERENCES
+
+Antreas Antoniou, Harrison Edwards, and Amos Storkey. How to train your maml. arXiv preprint arXiv:1810.09502, 2018.
+
+Hao Chen, Yali Wang, Guoyou Wang, and Yu Qiao. Lstd: A low-shot transfer detector for object detection. In AAAI, 2018.
+
+Jifeng Dai, Haozhi Qi, Yuwen Xiong, Yi Li, Guodong Zhang, Han Hu, and Yichen Wei. Deformable convolutional networks. In ICCV, 2017.
+
+Xuanyi Dong, Liang Zheng, Fan Ma, Yi Yang, and Deyu Meng. Few-example object detection with model communication. In TPAMI, 2018.
+
+Chelsea Finn, Pieter Abbeel, and Sergey Levine. Model-agnostic meta-learning for fast adaptation of deep networks. In International Conference on Machine Learning, ICML, 2017.
+
+Spyros Gidaris and Nikos Komodakis. Object detection via a multi-region and semantic segmentation-aware cnn model. In ICCV, 2015.
+
+Ross Girshick, Jeff Donahue, Trevor Darrell, and Jitendra Malik. Rich feature hierarchies for accurate object detection and semantic segmentation. In CVPR, 2014.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016.
+
+Andrej Karpathy, George Toderici, Sanketh Shetty, Thomas Leung, Rahul Sukthankar, and Li FeiFei. Large-scale video classification with convolutional neural networks. In CVPR, 2014.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In NeurIPS, 2012.
+
+Zhenguo Li, Fengwei Zhou, Fei Chen, and Hang Li. Meta-sgd: Learning to learn quickly for fewshot learning. arXiv preprint arXiv:1707.09835, 2017.
+
+Tsung-Yi Lin, Piotr Dollar, Ross Girshick, Kaiming He, Bharath Hariharan, and Serge Belongie. ´ Feature pyramid networks for object detection. In CVPR, 2017a.
+
+Tsung-Yi Lin, Priya Goyal, Ross Girshick, Kaiming He, and Piotr Dollar. Focal loss for dense object ´ detection. In ICCV, 2017b.
+
+Wei Liu, Dragomir Anguelov, Dumitru Erhan, Christian Szegedy, Scott Reed, Cheng-Yang Fu, and Alexander C Berg. SSD: Single shot multibox detector. In ECCV, 2016.
+
+Sachin Ravi and Hugo Larochelle. Optimization as a model for few-shot learning. ICLR, 2016.
+
+Joseph Redmon and Ali Farhadi. Yolo9000: Better, faster, stronger. In arXiv preprint arXiv:1612.08242, 2016.
+
+Joseph Redmon, Santosh Divvala, Ross Girshick, and Ali Farhadi. You only look once: Unified, real-time object detection. In CVPR, 2016.
+
+Mengye Ren, Eleni Triantafillou, Sachin Ravi, Jake Snell, Kevin Swersky, Joshua B Tenenbaum, Hugo Larochelle, and Richard S Zemel. Meta-learning for semi-supervised few-shot classification. arXiv preprint arXiv:1803.00676, 2018.
+
+Shaoqing Ren, Kaiming He, Ross Girshick, and Jian Sun. Faster r-cnn: Towards real-time object detection with region proposal networks. In NeurIPS, 2015.
+
+Eli Schwartz, Leonid Karlinsky, Joseph Shtok, Sivan Harary, Mattias Marder, Sharathchandra Pankanti, Rogerio Feris, Abhishek Kumar, Raja Giries, and Alex M Bronstein. Repmet: Representative-based metric learning for classification and one-shot object detection. In CVPR, 2019.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. In arXiv preprint arXiv:1409.1556, 2014.
+
+Jake Snell, Kevin Swersky, and Richard Zemel. Prototypical networks for few-shot learning. In Advances in Neural Information Processing Systems, 2017.
+
+Flood Sung, Yongxin Yang, Li Zhang, Tao Xiang, Philip HS Torr, and Timothy M Hospedales. Learning to compare: Relation network for few-shot learning. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2018.
+
+Oriol Vinyals, Charles Blundell, Timothy Lillicrap, Daan Wierstra, et al. Matching networks for one shot learning. In Advances in neural information processing systems, 2016.
+
+Shifeng Zhang, Longyin Wen, Xiao Bian, Zhen Lei, and Stan Z Li. Single-shot refinement neural network for object detection. In CVPR, 2018.
+
+# A APPENDIX
+
+# A.1 CATEGORY SPLIT IN VOC-FSOD BENCHMARK AND 2
+
+Here we describe the category splits ( $\ b { L _ { c } }$ and $S _ { c }$ ) of VOC-FSOD benchmark and ImageNet-FSOD benchmark. These splits are used in all our paper.
+
+# VOC-FSOD benchmark:
+
+$$
+L _ { c } =
+$$
+
+aeroplane, bicycle, ’bird, car, cat, chair, cow, person, pottedplant, tvmonitor
+
+$$
+S _ { c } = 
+$$
+
+bus, motorbike, train, dog, sheep, bottle, sofa, diningtable, horse, boat
+
+# ImageNet-FSOD benchmark:
+
+$$
+L _ { c } =
+$$
+
+kit fox, English setter, Siberian husky, Australian terrier, English springer, grey whale, lesser panda, Egyptian cat, ibex, Persian cat, cougar, gazelle, porcupine, sea lion, malamute, badger, Great Dane, Walker hound, Welsh springer spaniel, whippet, Scottish deerhound, killer whale, mink, African elephant, Weimaraner, soft-coated wheaten terrier, Dandie Dinmont, red wolf, Old English sheepdog, jaguar, otterhound, bloodhound, Airedale, hyena, meerkat, giant schnauzer, titi, three-toed sloth, sorrel, black-footed ferret, dalmatian, black-and-tan coonhound, papillon, skunk, polecat, Staffordshire bullterrier, Mexican hairless, Bouvier des Flandres, weasel, miniature poodle, malinois, bighorn, fox squirrel, colobus, tiger cat, Lhasa, impala, coyote, Yorkshire terrier, Newfoundland, brown bear, red fox, Norwegian elkhound, Rottweiler, hartebeest, Saluki, grey fox, schipperke, Pekinese, Brabancon griffon, West Highland white terrier, Sealyham terrier, guenon, mongoose, indri, tiger, Irish wolfhound, wild boar, EntleBucher, zebra, ram, French bulldog, orangutan, basenji, leopard, Bernese mountain dog, Maltese dog, Norfolk terrier toy terrier vizsla, cairn, squirrel monkey, groenendael, clumber, Siamese cat, chimpanzee, komondor, Afghan hound, Japanese spaniel, proboscis monkey, guinea pig
+
+$$
+S _ { c } = 
+$$
+
+Pomeranian, wombat, hare, snow leopard, Arctic fox, Sussex spaniel, lynx, wood rabbit, Saint Bernard, redbone, chow, collie, German shepherd, affenpinscher, dingo, golden retriever, American Staffordshire terrier, briard, kelpie, Tibetan terrier, cocker spaniel, sloth bear, standard poodle, wire-haired fox terrier, Border terrier, American black bear, Bedlington terrier, banded gecko, wallaby, Tibetan mastiff, flat-coated retriever, koala, toy poodle, Border collie, Chesapeake Bay retriever, German short-haired pointer, great grey owl, Doberman, Lakeland terrier, miniature pinscher, timber wolf, hog, marmot, Irish setter, bull mastiff, Irish terrier, Shetland sheepdog, keeshond, miniature schnauzer, llama, Pembroke, ice bear, standard schnauzer, white wolf, Boston bull, Gordon setter, Great Pyrenees, Irish water spaniel, warthog, Scotch terrier, Chihuahua, Norwich terrier, Rhodesian ridgeback, borzoi, gibbon, Samoyed, tabby, Kerry blue terrier, Labrador retriever, thunder snake, Ibizan hound, beagle, curly-coated retriever, African hunting dog, boxer, common newt, giant panda, ringneck snake, Angora, beaver, lion, bluetick, basset, alligator lizard, armadillo, pug, Greater Swiss Mountain dog, hognose snake, dhole, echidna, sidewinder, Komodo dragon, silky terrier, Brittany spaniel, patas, European fire salamander, Madagascar cat, macaque, boa constrictor, gorilla, polecat, howler monkey, Appenzeller, Blenheim spaniel, Indian cobra, Shih-Tzu, baboon, kuvasz, horned viper, rhinoceros beetle, tailed frog, Eskimo dog, Gila monster, mud turtle, capuchin, spider monkey, Leonberg, garter snake, African chameleon, barracouta, bullfrog, spotted salamander, leatherback turtle, rock python, marmoset, otter, Arabian camel, gar, tarantula, langur, tench, platypus, Italian greyhound, box turtle, cheetah, hippopotamus, English foxhound, eft, admiral, night snake, whiptail, siamang, agama, bittern, terrapin, axolotl, African grey, African crocodile, frilled lizard, quail, water ouzel, sulphur-crested cockatoo, bison, bustard, bulbul, cock, prairie chicken, ruffed grouse, jay, partridge, tusker, spoonbill, green snake, junco, black grouse, crane, water buffalo, toucan, redshank, hornbill, ostrich, vine snake, hummingbird, Indian elephant, magpie, albatross, king snake, little blue heron, bald eagle, peacock, limpkin, hamster, ruddy turnstone, jacamar, green mamba, kite, indigo bunting, American egret, American coot, coucal, house finch, ptarmigan, black stork, robin, white stork, brambling, red-backed sandpiper, king penguin, goldfinch, lorikeet, water snake, macaw, drake, vulture, bee eater, hen, dowitcher, red-breasted merganser, ox, diamondback, oystercatcher, goose, pelican, black swan,

parse/train/B1xmOgrFPS/B1xmOgrFPS_content_list.json

@@ -0,0 +1,1297 @@
+[
+    {
+        "type": "text",
+        "text": "META-RCNN: META LEARNING FOR FEW-SHOT OBJECT DETECTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            759,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            171,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            236,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Despite significant advances in object detection in recent years, training effective detectors in a small data regime remains an open challenge. Labelling training data for object detection is extremely expensive, and there is a need to develop techniques that can generalize well from small amounts of labelled data. We investigate this problem of few-shot object detection, where a detector has access to only limited amounts of annotated data. Based on the recently evolving meta-learning principle, we propose a novel meta-learning framework for object detection named “Meta-RCNN”, which learns the ability to perform few-shot detection via meta-learning. Specifically, Meta-RCNN learns an object detector in an episodic learning paradigm on the (meta) training data. This learning scheme helps acquire a prior which enables Meta-RCNN to do few-shot detection on novel tasks. Built on top of the Faster RCNN model, in Meta-RCNN, both the Region Proposal Network (RPN) and the object classification branch are meta-learned. The meta-trained RPN learns to provide class-specific proposals, while the object classifier learns to do few-shot classification. The novel loss objectives and learning strategy of Meta-RCNN can be trained in an end-to-end manner. We demonstrate the effectiveness of Meta-RCNN in addressing few-shot detection on Pascal VOC dataset and achieve promising results. ",
+        "bbox": [
+            233,
+            263,
+            764,
+            513
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            539,
+            336,
+            554
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Object detection is the task of identifying various objects in a given image, and localizing them with a bounding box. It is a widely studied problem in computer vision, and following the success deep convolutional neural networks (DCNN) in image classification (Karpathy et al., 2014; Krizhevsky et al., 2012), recent years have witnessed remarkable progress made in object detection based on deep learning. A series of detection algorithms based on DCNNs have been proposed which achieve state-of-the-art results on public detection benchmark datasets (Gidaris & Komodakis, 2015; Girshick et al., 2014; Ren et al., 2015; Lin et al., 2017a;b; Liu et al., 2016; Redmon & Farhadi, 2016). However, all these methods are data hungry, and require large amounts of annotated data to learn an immense number of parameters. For object detection, annotating the data is every expensive (much more than image classification), as it requires not only identifying the categorical labels for every object in the image, but also providing accurate localization information through bounding box coordinates. Moreover, in some applications, such as medical research, it’s often impossible to even collect sufficient data to annotate. This warrants a need for effective detectors that can generalize well from small amounts of annotated data. We refer to the problem of learning detectors from limited labeled data as few-shot detection. For example, in one-shot detection, only one image is available with objects of interest annotated, and a detector needs to train on just this image and generalize. When presented with such small amounts of annotated data, traditional detectors tend to suffer from overfitting. Inspired by the fact that humans can learn a new concepts from little annotated data, we aim to develop a new few-shot detection algorithm. ",
+        "bbox": [
+            174,
+            569,
+            825,
+            833
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "There have been several efforts exploring few-shot learning (Vinyals et al., 2016; Finn et al., 2017; Snell et al., 2017). Many of them follow the principle of meta learning. In meta learning, a set of tasks in a few-shot setting is simulated from a large corpus of annotated data, and the model is optimized to perform well over these few shot tasks. This trains the model to learn how to solve few-shot tasks. However, most existing efforts of meta learning are mainly focused on classification. Adapting few-shot classification algorithms directly for few-shot detection (e.g. by replacing the region classification branch of detector with a meta-learner) is non-trivial because of two major concerns: i). Detection algorithms not only require classifying objects but also need to correctly localize objects in cluttered backgrounds by using a Region Proposal Network (RPN) and bounding box (bbox) regressors. It is thus also desirable that both RPN and bbox regressors should also be capable enough to adapt to few-shot settings. ii). For a given task with one (or few) annotated image(s), the annotated image may contain objects from several classes. But only a few objects of interest are annotated. The goal of the few-shot detector is to detect only these objects of interest. Unfortunately, a naively trained meta-detector’s RPN would detect all objects (even objects from classes not of interest) and try to classify them as one of the classes of interest rather than background images (See Figure 1 for an example). ",
+        "bbox": [
+            174,
+            840,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/7f5f879399d45be9afc799e08fc70cd081a33c773abb9d01cdfd53f0f02dc64e.jpg",
+        "image_caption": [
+            "Figure 1: Few-Shot object detection in the meta-learning setting. From the meta-train dataset, a Kway-Nshot support set and a query set are sampled to create a task. The meta detector makes predictions on the query set by using the knowledge from the support set, and updates the detector based on the loss on the query set. In the example above, there are many objects (person, dog and truck), but it is annotated with the goal of detecting only a person. At test time, a single annotated image from a novel class (bear) is available for the detector to learn a model that can generalize. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            241,
+            69,
+            751,
+            333
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            507,
+            825,
+            646
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We aim to address these challenges by proposing a novel method for solving few-shot detection using the meta-learning paradigm. We develop Meta-RCNN, an end to end trainable meta object detector. The proposed Meta-RCNN follows the episodic learning paradigm of meta-learning (Vinyals et al., 2016), where based on a give meta-train dataset, multiple few-shot tasks are simulated. For a given task, we first construct a class prototype for each of the annotated object categories in the support set. Using these prototypes, a class-specific feature map of the entire image is constructed, i.e., we obtain a feature map of the entire image for each of the class prototypes. These feature maps are tailored to detect only objects of the class of the prototype, by giving higher attention to appropriate regions in the image containing that object. Finally, all feature maps are merged to produce a combined feature map, followed by an RPN, and then classification and bbox regression layers. ",
+        "bbox": [
+            173,
+            654,
+            825,
+            791
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Meta-RCNN learns few-shot detector where the whole framework can be trained via meta-learning in an end-to-end manner. In contrast to the naive adaptation of meta-learning for classification into an object detection framework, Meta-RCNN learns the few-shot classifier, the RPN, and the bbox regressor in the meta-learning setting, thus making all three components suitable for handling fewshot scenarios. Moreover, Meta-RCNN learns a class-specific feature map for a given class prototype enabling easier distinction between classes of interest and backgrounds (where other objects in the image from classes not of interest are considered as backgrounds). We demonstrate the effectiveness of Meta-RCNN on two few-shot detection benchmarks: Pascal VOC and animal subset of ImageNet, and show that Meta-RCNN significantly improves the detection result in few shot settings. ",
+        "bbox": [
+            174,
+            799,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            343,
+            117
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Generic Object Detection. Object detection based on deep learning can be broadly divided into two families: two-stage detectors and one-stage detectors. Two-stage detectors such as RCNN (Girshick et al., 2014), Fast RCNN (Gidaris & Komodakis, 2015) and Faster RCNN (Ren et al., 2015), first generate a sparse set of proposal candidates, and a fixed-length feature vector is extracted from each of these candidates, followed by a categorical classifier and a bounding box regressor. Twostage detection algorithms have achieved state-of-the-art results on many public benchmarks (He et al., 2016; Lin et al., 2017a), but are relatively slower than one-stage detectors. One-stage detectors such as SSD (Liu et al., 2016), Yolo (Redmon et al., 2016; Redmon & Farhadi, 2016) and RefineDet (Zhang et al., 2018) directly generate categorical proposals from the feature map and thus avoid cascaded region classifiers. One-stage detectors can achieve real-time inference speed but the detection accuracy is often inferior to two-stage detection algorithms. Both detection families assume access to a large set of annotated data, and are not suitable for scenarios where the model has access to small amounts of annotated training data. In contrast, our proposed Meta-RCNN method addresses detection problem of few-shot setting, and achieves promising results. ",
+        "bbox": [
+            174,
+            137,
+            825,
+            332
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Meta Learning for few-shot classification. Few-shot learning has been widely explored in image classification, and currently the most promising methods are mainly based on meta learning. Ravi & Larochelle (2016) optimized the base-model via an LSTM-based meta-learner which simulates traditional SGD optimization method. Finn et al. (Finn et al., 2017) proposed MAML which learns a good feature initialization which can adapt to a new task in only one gradient step udpate. Based on MAML, Li et al. (2017) proposed Meta-SGD which learns a set of learnable parameters to control gradient step of different tasks. Learning initialization is potentially a very general idea for few-shot learning however, the training process can be unstable (Antoniou et al., 2018) especially for complex problems such as detection. Vinyals et al. (Vinyals et al., 2016; Snell et al., 2017) proposed a matching network which followed a non-parametric principle by learning a differentiable K-Nearest Neighbour model. Ren et al. (Ren et al., 2018) extended this idea to semi-supervised learning by self-learning from the unlabeled data. Sung et al. (Sung et al., 2018) proposed a relation network to automatically define the optimal distance metric. These metric-learning based methods are easy to train and effective in addressing few-shot classification. However, directly adapting these techniques for detection is very challenging as just replacing the object classification branch of a detector with a meta-learner is not sufficient, and training the RPN under a meta-learning paradigm is non-trivial. ",
+        "bbox": [
+            174,
+            339,
+            825,
+            560
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Few-shot Object Detection. Few-shot detection has received considerably less interest from the community. Dong et al. (Dong et al., 2018) addressed few-shot detection using large scale unlabeled data. Their model is based on a semi-supervised method which extracts knowledge from unlabeled dataset to enrich training dataset by self-paced learning and multi-modal learning. However, their method may be misled by the incorrect predictions from initial model and also requires re-training the model for every new task. Chen et al. (Chen et al., 2018) propose a Low-shot Transfer Detector (LSTD) using regularization to transfer the knowledge from source domain to target domain by minimizing the gap between these two domains. RepMet (Schwartz et al., 2019) is a few-shot detection algorithm based on meta learning. It replaces the fully connected classification layer of a standard detector with modified prototypical network. However, they suffer from the two limitations of the RPN and bbox regression not being able to handle few-shot settings, and difficulties in distinguishing object classes of interest from background (including object classes not of interest). Our proposed method is also based on meta learning but can be optimized end-to-end and addresses these limitations to do effective few-shot detection. ",
+        "bbox": [
+            174,
+            568,
+            825,
+            762
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 PRELIMINARIES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            790,
+            338,
+            806
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 PROBLEM SETTING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            825,
+            349,
+            839
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section we present the formal problem setting of few-shot detection investigated in our paper. Assume we have two datasets $L$ and $S$ , where $L$ is a large scale annotated dataset with $L _ { c }$ categories and $S$ is a dataset with only a few annotated images with $S _ { c }$ categories. There is no category overlap between two datasets: $L _ { c } \\cap S _ { c } = \\phi$ . Our goal is to learn a robust detector based on the annotated data in $L$ and $S$ to detect unlabeled objects of $S$ . ",
+        "bbox": [
+            174,
+            853,
+            823,
+            922
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The proposed Meta-RCNN aims to learn a general detection framework which can be quickly adapted to different detection tasks which have only a few labeled samples. We follow the standard training scheme of meta learning, which splits the whole learning stage into two parts: meta-training and meta-testing, and the model is optimized over multiple few-shot tasks simulated from the metatraining data. Specifically, during meta-training, few-shot detection tasks are sampled from $L$ , and each task contains a support set and a query set. For the $i$ -th task, $K$ ways (or categories) and $N$ images per category are randomly selected from $L _ { c }$ to build support set: $\\mathrm { T } _ { i } ^ { \\mathrm { L } , \\mathrm { s } }$ . Similarly, $Q$ images per category are randomly selected to build query set $\\mathrm { T } _ { i } ^ { \\mathrm { L , q } }$ . Support set $\\mathrm { T } _ { i } ^ { \\mathrm { L } , \\mathrm { s } }$ and query set $\\mathrm { T } _ { i } ^ { \\mathrm { L , q } }$ construct a complete task extracted from $L$ (See Figure 1): ",
+        "bbox": [
+            173,
+            103,
+            825,
+            234
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bef4df5998da5c8456b7a74d96489595fc61a5eb93ff03b5ade34f674a082760.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathrm { T } _ { i } ^ { L } = \\left\\{ \\mathrm { T } _ { i } ^ { \\mathrm { L } , \\mathrm { s } } , \\mathrm { T } _ { i } ^ { \\mathrm { L } , \\mathrm { q } } \\right\\} } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            436,
+            239,
+            562,
+            267
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where both the support set and query set are used to train the meta-model. The meta-model optimizes the base-model with respect to the support set and makes predictions on query set. Finally the loss suffered on the query set is used to update the model. In the meta-testing stage, similar to metatraining stage, a set of few-shot tasks are sampled from $S$ : ",
+        "bbox": [
+            174,
+            272,
+            823,
+            328
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f9bdb5146409745f73dcb1313ef370fb4432d135257d07516216fdfb16c38864.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathrm { T } _ { i } ^ { S } = \\left\\{ \\mathrm { T } _ { i } ^ { { \\mathrm { S } } , { \\mathrm { s } } } , \\mathrm { T } _ { i } ^ { { \\mathrm { S } } , { \\mathrm { q } } } \\right\\} } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            436,
+            333,
+            560,
+            361
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathrm { T } _ { i } ^ { \\mathrm { S , s } }$ is support set and $\\mathrm { T } _ { i } ^ { \\mathrm { S , q } }$ is query set. The model makes predictions on the query set, and these results are averaged across several few-shot tasks to evaluate the expected performance of the few-shot detector over a variety of novel few-shot detection tasks. ",
+        "bbox": [
+            176,
+            368,
+            825,
+            412
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 OVERVIEW OF FASTER RCNN ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            429,
+            423,
+            443
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Meta-RCNN is based on two-stage region based object detection algorithms. In this paper, we use the state-of-the-art detection algorithm Faster RCNN (Ren et al., 2015) as our base model, which is widely used in the computer vision community. Faster RCNN consists of two components, an RPN (Region Proposal Network) for proposal generation and Fast RCNN for region classification. RPN generates a sparse set of proposals which are classified into different categories by the region classifiers. Specifically, RPN extracts a feature vector from each region by scanning the whole image using sliding windows. This is followed by a binary classifier (objects vs backgrounds) and a bounding box regressor, where easy negatives are filtered. For each proposal, a fixed-length feature vector is extracted by using ROI Pooling layers. This vector is then fed into a sequence of dense connected layers branching into two outputs. One output is responsible for representing softmax probability over $K + 1$ classes( $K$ target classes and one background class), and the other one encodes four real-values for refining bounding box position. We denoted $u$ and $v$ as the category and bounding box label respectively, $p$ as the predicted probability distribution over C classes, and $t _ { u }$ as the predicted bounding box prediction of class $u$ , and $\\lambda$ as the trade-off parameter. $L _ { \\mathrm { c l s } }$ represents softmax loss and $L _ { \\mathrm { l o c } }$ represents SmoothL1 loss function. The entire network can be optimized in an end-to-end manner by minimizing loss $L ( p , u , t ^ { u } , v )$ : ",
+        "bbox": [
+            174,
+            455,
+            825,
+            676
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cea4fb8dd1bd5a12af57fe124096caf1803ec82fac307cb0a1d04aa4f6493946.jpg",
+        "text": "$$\n\\begin{array} { r } { L ( p , u , t ^ { u } , v ) = L _ { \\mathrm { c l s } } ( p , u ) + \\lambda [ u \\geq 1 ] L _ { \\mathrm { l o c } } ( t ^ { u } , v ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            336,
+            683,
+            660,
+            700
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "However, two-stage detectors require a lot of training samples to obtain a good performance. In the next section, we present the proposed Meta-RCNN which builds over Faster RCNN and is specifically designed to address few-shot detection. ",
+        "bbox": [
+            174,
+            707,
+            823,
+            748
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 META-RCNN ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            768,
+            321,
+            785
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 OVERVIEW ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            800,
+            290,
+            814
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We now present our proposed method Meta-RCNN for few-shot detection (See Figure 2 for an overview). Meta-RCNN is trained with multiple few-shot tasks simulated from the meta-train dataset. For each episode, a few object categories of interest are assumed to be annotated (Support set). During meta-training, a prototype is computed for each object category. For each of these category prototypes, a class-specific feature map is generated by using a class-attention module which combines the prototype information with the feature map of the entire image. This feature map only highlights the signals of the class of interest, and suppresses information from other classes. Finally, feature maps of all target categories are combined, followed by RPN and RCNN branches to make predictions on the query set. Based on the loss on the query set, the model is updated. ",
+        "bbox": [
+            173,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/b52f0023c1f0af218431b36fa3102c84b153a96259a644df2e977b5e1d5cb980.jpg",
+        "image_caption": [
+            "Figure 2: The Meta-RCNN workflow. A set of prototypes of different categories are extracted from the support set. For each class, conditioned on these prototypes, a class-specific feature map from query set is generated by applying the class attention module to the feature map of the entire image. The new class-specific feature map is tailored to detecting objects of that specific class. The classspecific feature maps are concatenated together and finally, an RPN is applied followed with region classification layer and bounding box regressors. The whole network is optimized via meta learning and can be trained end-to-end. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            87,
+            825,
+            287
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            435,
+            823,
+            464
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Meta-RCNN is general paradigm to train few-shot detector via by meta-learning. For each task, irrelevant categories and background can be filtered by attention module, and the final generated feature map learns a general representation for the given few-shot detection task. Compared to other variants (Schwartz et al., 2019) which directly replaces the FC classification branch with a metalearning branch, Meta-RCNN is more general and the whole framework can be optimized including RPN and bbox regressors, making all the components few-shot capable. Next, we present the details of the model. ",
+        "bbox": [
+            174,
+            470,
+            825,
+            569
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 META-TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            588,
+            334,
+            603
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "During Meta-Training, multiple Kway-Nshot tasks are simulated from the annotated dataset $L$ . To fit memory size, in Meta-Training stage we train the model using 5way-1shot tasks, and only 5 query images (1 query image per class). This results in a total of 10 images for one task. With this, implementing the meta-training is not too difficult. For each task $T _ { i } ^ { L }$ , images of support set $T _ { i } ^ { L , s }$ are fed into Faster RCNN to generate region features. For each of the object categories of interest (those assumed to be annotated in the support image), a prototype $P _ { c }$ is generated based on the corresponding region features: ",
+        "bbox": [
+            173,
+            616,
+            825,
+            717
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/acd94cf03febb7c82ca884f4f476cf20874fa9496aaa3d6a6b78f329ee2b0c87.jpg",
+        "text": "$$\nP _ { c } = \\frac { 1 } { N _ { c } } \\sum _ { i } ^ { N _ { c } } { r _ { c } ^ { i } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            444,
+            726,
+            553,
+            768
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $P _ { c }$ denotes prototype of class $c$ , and $r _ { c } ^ { i }$ denotes $i$ -th region features of all annotated objects from class $c$ . Based on these generated prototypes, images of query set $T _ { i } ^ { L , q }$ are fed into the same Faster RCNN model and we obtain the image feature map before RPN and ROI Pooling. For each category, a class-specific feature map is learned based on the input query image and its corresponding prototype. We use a learnable class attention module here to highlight the signals of target class and suppress signals of other categories. The class attention module is based on basic channel-wise multiplication. The prototype $P _ { c }$ is encoded by a FC layer $\\phi$ , which is later combined with feature map $f$ by element-wise multiplication: ",
+        "bbox": [
+            173,
+            779,
+            825,
+            895
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f147f9c5bec7372698881fff6b76a58c9b6ccc1b21d65f644da4a5dc9888dff2.jpg",
+        "text": "$$\nF _ { c } = f \\odot \\phi ( P _ { c } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            442,
+            904,
+            555,
+            921
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For each category $c$ , one new feature map $F _ { c }$ is generated which aims to highlight the objects of class $c$ . Next, all these new feature maps are combined into one feature map $F$ : ",
+        "bbox": [
+            169,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/45ebe753b474dc93ce17a0f6c264f20a2a75bd9f232374787c3cf7e10361a773.jpg",
+        "text": "$$\nF = { \\mathrm { c o n c a t e } } \\{ F _ { 1 } , F _ { 2 } , . . . , F _ { k } \\}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            401,
+            140,
+            596,
+            156
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "$F$ learns a general representation of $\\mathbf { K }$ -classes, where each sub-channel contains information of different classes of interest. Based on the new feature map $F$ , 1x1 conv layer is used to reduce computation cost, followed by RPN to produce region proposals. In order to recover the information lost in attention module, we finally combine the new generated feature map with original feature map by element-wise summation, and crop region features based on the new generated map. Finally, a $\\mathrm { K } { + } 1$ region classifier and a bbox regressors are optimized w.r.t the label info from query set $T _ { i } ^ { L , q }$ : ",
+        "bbox": [
+            173,
+            164,
+            825,
+            251
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/48b091d1de4118bb4890f1586dbbe841eeb47835b011d03d566f301b1f1e455a.jpg",
+        "text": "$$\nL ( T _ { i } ^ { L , q } ; T _ { i } ^ { L , s } , \\theta ) = L _ { \\mathrm { l o c } } + L _ { \\mathrm { c l s } } + L _ { \\mathrm { R P N } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            369,
+            257,
+            629,
+            277
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\theta$ represents the parameters of Meta-RCNN. ",
+        "bbox": [
+            174,
+            285,
+            508,
+            299
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 META-TESTING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            316,
+            326,
+            332
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "During meta-testing, we sample few-shot detection tasks from $S$ . The annotations of support set are available and we make predictions on the query set to evaluate the performance of Meta-RCNN. For each task $T _ { i } ^ { S }$ , prototypes are generated from support set $\\boldsymbol { T } _ { i } ^ { S , q }$ , which are later used to generate new class-specific feature maps of images from query set model based on the labeled images of support set. Th $\\boldsymbol { T } _ { i } ^ { S , q }$ . In this stage, we need to finetune theetuning operation addresses the learning limitation of non-parametric method when more labeled images are provided. Finally, we evaluate the output from the query set as traditional detection problem: ",
+        "bbox": [
+            173,
+            342,
+            825,
+            446
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ce5235cdac64e21e3d419791565cf04f01285630482061e7a6a9c752cedd806c.jpg",
+        "text": "$$\np , u = \\mathbf { M e t a R C N N } ( T _ { i } ^ { S , q } ; T _ { i } ^ { S , s } , \\theta )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            385,
+            453,
+            612,
+            473
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $p$ is class probability vector and $u$ is location set of bounding boxes. ",
+        "bbox": [
+            174,
+            481,
+            663,
+            496
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            515,
+            326,
+            531
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.1 DATASETS AND IMPLEMENTATION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            547,
+            517,
+            563
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/9891916d4b79950cc1dd7dc327bc2cf7765ef49f128d7dc4df557640f3a36143.jpg",
+        "table_caption": [
+            "Table 1: Two few-shot object detection benchmark testbeds for performance evaluation "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>DATASET</td><td rowspan=1 colspan=1>Train</td><td rowspan=1 colspan=1>#Img</td><td rowspan=1 colspan=1>#cls</td><td rowspan=1 colspan=1>Test</td><td rowspan=1 colspan=1>#Img</td><td rowspan=1 colspan=1>#cls</td></tr><tr><td rowspan=1 colspan=1>VOC-FSOD</td><td rowspan=1 colspan=1>VOC2007trainval</td><td rowspan=1 colspan=1>~4.9k</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>VOC2007test</td><td rowspan=1 colspan=1>~2.2k</td><td rowspan=1 colspan=1>10</td></tr><tr><td rowspan=1 colspan=1>IMAGENET-FSOD</td><td rowspan=1 colspan=1>ImageNet-LOC</td><td rowspan=1 colspan=1>~ 53k</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>ImageNet-LOC</td><td rowspan=1 colspan=1>~117k</td><td rowspan=1 colspan=1>214</td></tr></table>",
+        "bbox": [
+            178,
+            578,
+            820,
+            625
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Benchmark Datasets: We construct two benchmark testbeds to facilitate the performance evaluation for few-shot object detection in meta-learning settings. The first is on Pascal VOC2007, and the second is on the animal subset of ImageNet-LOC dataset. Table 1 gives details of these datasets. Pascal VOC2007 has 20 categories with 5k images in trainval set and $5 \\mathrm { k }$ images in test set. A subset of 10 categories are randomly from selected for VOC2007 trainval set for Meta-Training and the remaining 10-category subset of VOC2007 test set is used for Meta-Testing. Images without target object categories are removed. For ImageNet-FSOD benchmark, we use the subset of first 100 animal classes of ImageNet in Meta-Training stage and the subset of remaining 214 animal species in ImageNet-LOC in Meta-Testing stage. The model used in VOC-FSOD benchmark is pre-trained on ImageNet, while in ImageNet-FSOD benchmark, the model is pre-trained on MSCOCO dataset with $1 1 5 \\mathrm { k }$ images in 80 categories. ",
+        "bbox": [
+            173,
+            665,
+            825,
+            819
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Task Generation: For each benchmark, Meta-RCNN is evaluated on multiple tasks with different $K$ way- $N$ shot few-shot settings $N$ annotated images per category). For VOC-FSOD benchmark, we have 3 few-shot settings to evaluate Meta-RCNN: 5way-1shot, 5way-3shot and 5way-5shot. In detection, a single image has more than one object, and proposal generation will automatically increase the number of training samples, so the real number of training samples is about 5 times larger than $N$ . On ImageNet-FSOD benchmark, we mainly follow (Chen et al., 2018) and (Schwartz et al., 2019) with two settings: 50way-1shot and 50way-5shot. ",
+        "bbox": [
+            173,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Meta-model Parameter Setting: In Meta-Training stage, totally 1000 distinct tasks and 5000 tasks are generated in VOC-FSOD benchmark and ImageNet-FSOD benchmark respectively. There are 10 images per class in query set to update the model weights for 10 epochs. The initial learning rate is set to 1e-3 and is reduced to 1e-4 every 600 tasks and 3500 tasks in VOC-FSOD benchmark and ImageNet-FSOD benchmark. We set the batch size as 5 during query update. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            172
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Basic Detection Parameter Setting: The parameter settings in Meta-RCNN is identical to vanilla Faster RCNN. Proposal overlap with objects larger than 0.5 are considered positive and less than 0.3 are negative. During Meta-Training the top 128 confident proposals are selected for training and during evaluation, 300 proposals with largest confidence score are selected. we build our MetaRCNN based on Faster RCNN with VGG16 (Simonyan & Zisserman, 2014) and ResNet50 (He et al., 2016) model which is pretrained on ImageNet. ",
+        "bbox": [
+            174,
+            174,
+            823,
+            257
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Model Evaluation: We evaluate Meta-RCNN based on multiple tasks of few-shot settings, which follows the evaluation metric of standard meta learning. More specifically, in evaluation stage, 200 $K$ shot-N shot tasks are sampled from dataset $S$ and images in query set will be evaluated. Mean average precision(mAP) over selected $K$ categories is used as evaluation metric. ",
+        "bbox": [
+            176,
+            257,
+            823,
+            313
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 RESULTS ON VOC-FSOD BENCHMARK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            323,
+            490,
+            337
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We validate the effectiveness of Meta-RCNN on VOC-FSOD benchmark where subset of 10 VOC categories are selected for Meta-Training and the other ten categories are used for Meta-Testing. For fair comparison, these two subsets are split as similar as possible. For example, we keep animal categories on both sides since they share similar semantic information (see appendix for details). Here we set up three baselines on VOC-FSOD benchmark to compete with proposed Meta-RCNN. ",
+        "bbox": [
+            176,
+            342,
+            825,
+            411
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "• vanilla FRCN (Ren et al., 2015): the vanilla Faster RCNN which is the most popular object detection algorithm with competitive performance on many benchmarks. The vanilla FRCN is not designed for few-shot detection problem, but we try to include this baseline by fine-tuning the detector on the few-shot training data. LSTD (Chen et al., 2018) is a few-shot detection algorithm based on Faster RCNN. LSTD uses categorical regularization items which transfers knowledge of $L$ dataset to $S$ dataset. FRCN-PN is a modified version of Faster RCNN using meta-learning, which replaces final FC classification layer with non-parametric prototypical network (PN), sharing the same principle of RepMet (Schwartz et al., 2019). ",
+        "bbox": [
+            215,
+            417,
+            825,
+            555
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "All three baselines as well as the proposed Meta-RCNN are based on VGG16 (Simonyan & Zisserman, 2014) backbone. For Regular FRCN and LSTD, we first train a global Faster RCNN during Meta-Training. Then the pretrained detector models are adapted to different tasks during MetaTesting. During Meta-Testing, Meta-RCNN and vanilla FRCN are finetuned for 4 epochs while LSTD requires longer finetuning period (10 epochs). For FRCN-PN, prototypes of different categories are extracted as Meta-RCNN, and metric distances are learned to assign correct labels to each proposal. We report the results on Table 2 based on three different settings. ",
+        "bbox": [
+            174,
+            563,
+            825,
+            660
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "From Table 2, the performances of all four methods improve with training shot increasing. Notably, FRCN-PN obtains much less improvement because the non-parametric property of PN layer limits its learning capacity from increased training samples. Benefit from the finetuning operation as well as FC layer in final classification and regression, Meta-RCNN can still maintain consistent improvement when trained with more samples. Furthermore, it’s interesting that Regular FRCN outperforms FRCN-PN even in very few-shot cases (5way-1shot), where non-parametric property does not help PN obtain better performance. We argue this is because few-shot detection problem is more difficult than few-shot classification problem, as we discussed in introduction section. FRCNPN cannot learn a representative prototype of background classes and the whole framework cannot be optimized by meta learning style (e.g., RPN and bbox regressors). The failure of FRCN-PN indicates naively attach components from few-shot classification framework cannot address few-shot detection problem. Finally, our Meta-RCNN achieves better results than all three baselines. ",
+        "bbox": [
+            174,
+            666,
+            825,
+            833
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Performance of RPN: Here, we present the performance of RPN to validate our concerns of the negative impact of irrelevant categories. We use regular FRCN and FRCN-PN as our baseline. The models are optimized in the same manner as before but during Meta-Testing, we evaluate the recall on each task instead of mAP. From Table 3, Regular FRCN baseline outperform the FRCNPN significantly. This is because objects of irrelevant categories in the same image hurt the training process of RPN. And our proposed Meta-RCNN outperforms these two baseline significantly. Meta",
+        "bbox": [
+            174,
+            840,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/a8f273a0c72f4197bcfb6698066c5b9d623d920f552e7fc4281c347c93c0a2d9.jpg",
+        "table_caption": [
+            "Table 2: mAP Performance Evaluation on the VOC-FSOD BENCHMARK "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>5way-1shot</td><td>5way-3shot</td><td>5way-5shot</td></tr><tr><td>vanilla FRCN (Ren et al., 2015)</td><td>14.78% ± 1.02%</td><td>20.34% ±1.26%</td><td>26.89% ± 1.23%</td></tr><tr><td>LSTD (Chen et al., 2018)</td><td>17.66% ± 1.65%</td><td>22.37% ± 0.81%</td><td>29.00% ±1.28%</td></tr><tr><td>FRCN-PN</td><td>12.71% ± 0.70%</td><td>13.91% ± 0.70%</td><td>14.33% ± 0.61%</td></tr><tr><td>Meta-RCNN (ours)</td><td>19.22% ± 1.01%</td><td>24.45% ± 1.20%</td><td>31.11% ± 0.88%</td></tr></table>",
+        "bbox": [
+            179,
+            99,
+            818,
+            174
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "RCNN learns a general feature map for all Kway-Nshot detection problem and optimize RPN by meta learning scheme, which proves more effective in few-shot settings. Notably, the results are surprising since the recall of RPN in few-shot scenario is significantly lower $( > 9 0 \\%$ with enough training data on VOC dataset). ",
+        "bbox": [
+            176,
+            207,
+            823,
+            263
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/dc116c896ab5087ae13934c00b1756d54209a056f5f67ede5a3508c6b148fa45.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 3: Recall evaluation of Meta-RCNN on VOC-FSOD BENCHMARK test set. "
+        ],
+        "table_body": "<table><tr><td>Model</td><td>Backbone</td><td>5way-1shot</td><td>5way-3shot</td><td>5way-5shot</td></tr><tr><td>vanilla FRCN (Ren et al., 2015)</td><td>VGG16</td><td>24.9%</td><td>26.5%</td><td>28.4%</td></tr><tr><td>FRCN-PN</td><td>VGG16</td><td>24.7%</td><td>24.9%</td><td>26.1%</td></tr><tr><td>Meta-RCNN (ours)</td><td>VGG16</td><td>26.1%</td><td>27.9%</td><td>33.7%</td></tr></table>",
+        "bbox": [
+            196,
+            273,
+            800,
+            335
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.3 RESULTS ON IMAGENET-FSOD BENCHMARK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            367,
+            531,
+            382
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "On ImageNet-FSOD benchmark, we adapt weights of detector pretrained on MSCOCO trainval set, and then optimize Meta-RCNN based on this starting point. The Meta-RCNN is evaluated on animal subset of ImageNet-LOC. Animal subset of ImageNet-LOC only contains single animal category per image, so there are no irrelevant classes during training and it’s simpler than the situation we discussed. In addition to FRCN and LSTD, we also include another latest baseline RepMet (Schwartz et al., 2019), which replaces FC classification layers in FRCN with more careful design of PN layers, as well as much more stronger backbone architecture (DCN (Dai et al., 2017) and FPN (Lin et al., 2017a)). In this benchmark, we have 50 categories per task, so we attach a 1x1 convolution layer before class-specific feature map generation to reduce computation cost. We report the results in Tab. 4. In 50way-1shot and 50way-5shot, Meta-RCNN is better than other methods. ",
+        "bbox": [
+            173,
+            392,
+            825,
+            532
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/6cb03606ba1747f15927189dcc80dd32c49d636bec8808736be11811b02ce4f3.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 4: mAP performance evaluation on IMAGENET-FSOD BENCHMARK. "
+        ],
+        "table_body": "<table><tr><td>Model</td><td>Backbone</td><td>50way-1shot</td><td>50way-5shot</td></tr><tr><td>vanilla FRCN (Ren et al., 2015)</td><td>VGG16</td><td>16.5%</td><td>34.3%</td></tr><tr><td>LSTD (Chen et al., 2018)</td><td>VGG16</td><td>19.2%</td><td>37.4%</td></tr><tr><td>RepMet (Schwartz et al.,2019)</td><td>DCN+FPN</td><td>24.1%</td><td>39.6%</td></tr><tr><td>Meta-RCNN (ours)</td><td>VGG16</td><td>24.6%</td><td>40.1%</td></tr><tr><td>Meta-RCNN (ours)</td><td>ResNet50</td><td>25.1%</td><td>40.3%</td></tr></table>",
+        "bbox": [
+            223,
+            542,
+            774,
+            632
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.4 DISCUSSIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            665,
+            310,
+            680
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Extension to other Meta-Learning Methods: Beyond prototypical networks, other meta-learning methods such as MAML (Finn et al., 2017) in principle can also be applied, e.g., we can apply MAML for vanilla FRCN framework, which updates the base model with the average gradient step of multiple tasks. However, in our experiments, the training process of MAML was unstable. This may be because few-shot detection is generally more difficult than few-shot classification, due to multiple dependent loss objectives (FRCN relies on RPN and regression loss etc.) and more complicated noisy contexts. In future, we plan to explore extensions to other meta-learning methods. ",
+        "bbox": [
+            173,
+            691,
+            825,
+            790
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            809,
+            318,
+            825
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Object detection has been widely explored but little attention has been given to learning detectors under a few-shot regime. In this paper we propose a meta learning based detection algorithm MetaRCNN, which is robust to few-shot learning, and the proposed training strategies make it more suitable in detection scenario. Specifically it adapts the Faster RCNN method and enables meta-learning of the object classifier, the RPN and the bounding box regressor. The RPN is meta-trained through a novel class-specific attention module. We conduct several experiments and obtain promising results. ",
+        "bbox": [
+            174,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            287,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Antreas Antoniou, Harrison Edwards, and Amos Storkey. How to train your maml. arXiv preprint arXiv:1810.09502, 2018. ",
+        "bbox": [
+            174,
+            126,
+            823,
+            155
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Hao Chen, Yali Wang, Guoyou Wang, and Yu Qiao. Lstd: A low-shot transfer detector for object detection. In AAAI, 2018. ",
+        "bbox": [
+            173,
+            161,
+            821,
+            191
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jifeng Dai, Haozhi Qi, Yuwen Xiong, Yi Li, Guodong Zhang, Han Hu, and Yichen Wei. Deformable convolutional networks. In ICCV, 2017. ",
+        "bbox": [
+            173,
+            199,
+            821,
+            228
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Xuanyi Dong, Liang Zheng, Fan Ma, Yi Yang, and Deyu Meng. Few-example object detection with model communication. In TPAMI, 2018. ",
+        "bbox": [
+            174,
+            236,
+            823,
+            266
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Chelsea Finn, Pieter Abbeel, and Sergey Levine. Model-agnostic meta-learning for fast adaptation of deep networks. In International Conference on Machine Learning, ICML, 2017. ",
+        "bbox": [
+            174,
+            273,
+            823,
+            304
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Spyros Gidaris and Nikos Komodakis. Object detection via a multi-region and semantic segmentation-aware cnn model. In ICCV, 2015. ",
+        "bbox": [
+            174,
+            310,
+            823,
+            340
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ross Girshick, Jeff Donahue, Trevor Darrell, and Jitendra Malik. Rich feature hierarchies for accurate object detection and semantic segmentation. In CVPR, 2014. ",
+        "bbox": [
+            174,
+            347,
+            821,
+            377
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016. ",
+        "bbox": [
+            174,
+            385,
+            821,
+            414
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Andrej Karpathy, George Toderici, Sanketh Shetty, Thomas Leung, Rahul Sukthankar, and Li FeiFei. Large-scale video classification with convolutional neural networks. In CVPR, 2014. ",
+        "bbox": [
+            173,
+            421,
+            820,
+            450
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In NeurIPS, 2012. ",
+        "bbox": [
+            174,
+            458,
+            820,
+            488
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Zhenguo Li, Fengwei Zhou, Fei Chen, and Hang Li. Meta-sgd: Learning to learn quickly for fewshot learning. arXiv preprint arXiv:1707.09835, 2017. ",
+        "bbox": [
+            173,
+            496,
+            821,
+            525
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Tsung-Yi Lin, Piotr Dollar, Ross Girshick, Kaiming He, Bharath Hariharan, and Serge Belongie. ´ Feature pyramid networks for object detection. In CVPR, 2017a. ",
+        "bbox": [
+            176,
+            532,
+            821,
+            563
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Tsung-Yi Lin, Priya Goyal, Ross Girshick, Kaiming He, and Piotr Dollar. Focal loss for dense object ´ detection. In ICCV, 2017b. ",
+        "bbox": [
+            174,
+            570,
+            821,
+            599
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Wei Liu, Dragomir Anguelov, Dumitru Erhan, Christian Szegedy, Scott Reed, Cheng-Yang Fu, and Alexander C Berg. SSD: Single shot multibox detector. In ECCV, 2016. ",
+        "bbox": [
+            176,
+            607,
+            820,
+            637
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sachin Ravi and Hugo Larochelle. Optimization as a model for few-shot learning. ICLR, 2016. ",
+        "bbox": [
+            174,
+            645,
+            797,
+            660
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Joseph Redmon and Ali Farhadi. Yolo9000: Better, faster, stronger. In arXiv preprint arXiv:1612.08242, 2016. ",
+        "bbox": [
+            173,
+            667,
+            823,
+            696
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Joseph Redmon, Santosh Divvala, Ross Girshick, and Ali Farhadi. You only look once: Unified, real-time object detection. In CVPR, 2016. ",
+        "bbox": [
+            173,
+            704,
+            823,
+            734
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mengye Ren, Eleni Triantafillou, Sachin Ravi, Jake Snell, Kevin Swersky, Joshua B Tenenbaum, Hugo Larochelle, and Richard S Zemel. Meta-learning for semi-supervised few-shot classification. arXiv preprint arXiv:1803.00676, 2018. ",
+        "bbox": [
+            176,
+            742,
+            823,
+            785
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Shaoqing Ren, Kaiming He, Ross Girshick, and Jian Sun. Faster r-cnn: Towards real-time object detection with region proposal networks. In NeurIPS, 2015. ",
+        "bbox": [
+            171,
+            792,
+            823,
+            821
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Eli Schwartz, Leonid Karlinsky, Joseph Shtok, Sivan Harary, Mattias Marder, Sharathchandra Pankanti, Rogerio Feris, Abhishek Kumar, Raja Giries, and Alex M Bronstein. Repmet: Representative-based metric learning for classification and one-shot object detection. In CVPR, 2019. ",
+        "bbox": [
+            174,
+            830,
+            825,
+            886
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. In arXiv preprint arXiv:1409.1556, 2014. ",
+        "bbox": [
+            176,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jake Snell, Kevin Swersky, and Richard Zemel. Prototypical networks for few-shot learning. In Advances in Neural Information Processing Systems, 2017. ",
+        "bbox": [
+            169,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Flood Sung, Yongxin Yang, Li Zhang, Tao Xiang, Philip HS Torr, and Timothy M Hospedales. Learning to compare: Relation network for few-shot learning. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2018. ",
+        "bbox": [
+            176,
+            140,
+            821,
+            184
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Oriol Vinyals, Charles Blundell, Timothy Lillicrap, Daan Wierstra, et al. Matching networks for one shot learning. In Advances in neural information processing systems, 2016. ",
+        "bbox": [
+            173,
+            193,
+            823,
+            223
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Shifeng Zhang, Longyin Wen, Xiao Bian, Zhen Lei, and Stan Z Li. Single-shot refinement neural network for object detection. In CVPR, 2018. ",
+        "bbox": [
+            176,
+            231,
+            823,
+            260
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            286,
+            297,
+            303
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A.1 CATEGORY SPLIT IN VOC-FSOD BENCHMARK AND 2 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            318,
+            594,
+            333
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Here we describe the category splits ( $\\ b { L _ { c } }$ and $S _ { c }$ ) of VOC-FSOD benchmark and ImageNet-FSOD benchmark. These splits are used in all our paper. ",
+        "bbox": [
+            174,
+            343,
+            820,
+            373
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "VOC-FSOD benchmark: ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            380,
+            349,
+            395
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "equation",
+        "img_path": "images/abead6cbf6037ff03fbba08583bfcef14d197a5d3343318072d4ceb21bb1162f.jpg",
+        "text": "$$\nL _ { c } =\n$$",
+        "text_format": "latex",
+        "bbox": [
+            478,
+            393,
+            521,
+            410
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "aeroplane, bicycle, ’bird, car, cat, chair, cow, person, pottedplant, tvmonitor ",
+        "bbox": [
+            173,
+            412,
+            669,
+            428
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "equation",
+        "img_path": "images/47eca61fa699841df8c2b7f3bb8a1a9450a821c999342f4442c1ac38a4a6806b.jpg",
+        "text": "$$\nS _ { c } = \n$$",
+        "text_format": "latex",
+        "bbox": [
+            478,
+            446,
+            521,
+            464
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "bus, motorbike, train, dog, sheep, bottle, sofa, diningtable, horse, boat ",
+        "bbox": [
+            173,
+            468,
+            632,
+            483
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "ImageNet-FSOD benchmark: ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            502,
+            382,
+            517
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e62a195157c127fba9ab3e9e5a24e7a53526ab4b3a700d6498fbf62bf6b1f484.jpg",
+        "text": "$$\nL _ { c } =\n$$",
+        "text_format": "latex",
+        "bbox": [
+            478,
+            517,
+            521,
+            532
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "kit fox, English setter, Siberian husky, Australian terrier, English springer, grey whale, lesser panda, Egyptian cat, ibex, Persian cat, cougar, gazelle, porcupine, sea lion, malamute, badger, Great Dane, Walker hound, Welsh springer spaniel, whippet, Scottish deerhound, killer whale, mink, African elephant, Weimaraner, soft-coated wheaten terrier, Dandie Dinmont, red wolf, Old English sheepdog, jaguar, otterhound, bloodhound, Airedale, hyena, meerkat, giant schnauzer, titi, three-toed sloth, sorrel, black-footed ferret, dalmatian, black-and-tan coonhound, papillon, skunk, polecat, Staffordshire bullterrier, Mexican hairless, Bouvier des Flandres, weasel, miniature poodle, malinois, bighorn, fox squirrel, colobus, tiger cat, Lhasa, impala, coyote, Yorkshire terrier, Newfoundland, brown bear, red fox, Norwegian elkhound, Rottweiler, hartebeest, Saluki, grey fox, schipperke, Pekinese, Brabancon griffon, West Highland white terrier, Sealyham terrier, guenon, mongoose, indri, tiger, Irish wolfhound, wild boar, EntleBucher, zebra, ram, French bulldog, orangutan, basenji, leopard, Bernese mountain dog, Maltese dog, Norfolk terrier toy terrier vizsla, cairn, squirrel monkey, groenendael, clumber, Siamese cat, chimpanzee, komondor, Afghan hound, Japanese spaniel, proboscis monkey, guinea pig ",
+        "bbox": [
+            173,
+            536,
+            826,
+            731
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0e0bef7691b113c1c2c3fb22f57a1e24c513399b8a0571160cd085a690bb194e.jpg",
+        "text": "$$\nS _ { c } = \n$$",
+        "text_format": "latex",
+        "bbox": [
+            480,
+            751,
+            519,
+            767
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Pomeranian, wombat, hare, snow leopard, Arctic fox, Sussex spaniel, lynx, wood rabbit, Saint Bernard, redbone, chow, collie, German shepherd, affenpinscher, dingo, golden retriever, American Staffordshire terrier, briard, kelpie, Tibetan terrier, cocker spaniel, sloth bear, standard poodle, wire-haired fox terrier, Border terrier, American black bear, Bedlington terrier, banded gecko, wallaby, Tibetan mastiff, flat-coated retriever, koala, toy poodle, Border collie, Chesapeake Bay retriever, German short-haired pointer, great grey owl, Doberman, Lakeland terrier, miniature pinscher, timber wolf, hog, marmot, Irish setter, bull mastiff, Irish terrier, Shetland sheepdog, keeshond, miniature schnauzer, llama, Pembroke, ice bear, standard schnauzer, white wolf, Boston bull, Gordon setter, Great Pyrenees, Irish water spaniel, warthog, Scotch terrier, Chihuahua, Norwich terrier, Rhodesian ridgeback, borzoi, gibbon, Samoyed, tabby, Kerry blue terrier, Labrador retriever, thunder snake, Ibizan hound, beagle, curly-coated retriever, African hunting dog, boxer, common newt, giant panda, ringneck snake, Angora, beaver, lion, bluetick, basset, alligator lizard, armadillo, pug, Greater Swiss Mountain dog, hognose snake, dhole, echidna, sidewinder, Komodo dragon, silky terrier, Brittany spaniel, patas, European fire salamander, Madagascar cat, macaque, boa constrictor, gorilla, polecat, howler monkey, Appenzeller, Blenheim spaniel, Indian cobra, Shih-Tzu, baboon, kuvasz, horned viper, rhinoceros beetle, tailed frog, Eskimo dog, Gila monster, mud turtle, capuchin, spider monkey, Leonberg, garter snake, African chameleon, barracouta, bullfrog, spotted salamander, leatherback turtle, rock python, marmoset, otter, Arabian camel, gar, tarantula, langur, tench, platypus, Italian greyhound, box turtle, cheetah, hippopotamus, English foxhound, eft, admiral, night snake, whiptail, siamang, agama, bittern, terrapin, axolotl, African grey, African crocodile, frilled lizard, quail, water ouzel, sulphur-crested cockatoo, bison, bustard, bulbul, cock, prairie chicken, ruffed grouse, jay, partridge, tusker, spoonbill, green snake, junco, black grouse, crane, water buffalo, toucan, redshank, hornbill, ostrich, vine snake, hummingbird, Indian elephant, magpie, albatross, king snake, little blue heron, bald eagle, peacock, limpkin, hamster, ruddy turnstone, jacamar, green mamba, kite, indigo bunting, American egret, American coot, coucal, house finch, ptarmigan, black stork, robin, white stork, brambling, red-backed sandpiper, king penguin, goldfinch, lorikeet, water snake, macaw, drake, vulture, bee eater, hen, dowitcher, red-breasted merganser, ox, diamondback, oystercatcher, goose, pelican, black swan, ",
+        "bbox": [
+            173,
+            770,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            104,
+            825,
+            339
+        ],
+        "page_idx": 10
+    }
+]

parse/train/I-VfjSBzi36/I-VfjSBzi36.md

@@ -0,0 +1,236 @@
+# EARLYBERT: EFFICIENT BERT TRAINING VIA EARLY-BIRD LOTTERY TICKETS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Deep, heavily overparameterized language models such as BERT, XLNet and T5 have achieved impressive success in many natural language processing (NLP) tasks. However, their high model complexity requires enormous computation resources and extremely long training time for both pre-training and fine-tuning. Many works have studied model compression on large NLP models, but only focusing on reducing inference time while still requiring expensive training process. Other works use extremely large batch sizes to shorten the pre-training time, at the expense of higher computational resource demands. In this paper, inspired by the Early-Bird Lottery Tickets recently studied for computer vision tasks, we propose EarlyBERT, a general computationally-efficient training algorithm applicable to both pre-training and fine-tuning of large-scale language models. By slimming the self-attention and fully-connected sub-layers inside a transformer, we are the first to identify structured winning tickets in the early stage of BERT training. We apply those tickets towards efficient BERT training, and conduct comprehensive pre-training and fine-tuning experiments on GLUE and SQuAD downstream tasks. Our results show that EarlyBERT achieves comparable performance to standard BERT, with $3 5 \sim 4 5 \%$ less training time.
+
+# 1 INTRODUCTION
+
+Large-scale pre-trained language models (e.g., BERT (Devlin et al., 2018), XLNet (Yang et al., 2019), T5 (Raffel et al., 2019)) have significantly advanced the state of the art in the NLP field. Despite impressive empirical success, their computational inefficiency has become an acute drawback in practice. As more and more transformer layers are stacked with larger self-attention blocks, model complexity increases rapidly. For example, compared to BERT-Large model with 340 million parameters, T5 has more than 10 billion to learn. Such high model complexity calls for expensive computational resources and extremely long training time.
+
+Model compression is one approach to alleviating this issue. Recently, many methods propose to encode large NLP models compactly (Sun et al., 2019; Sanh et al., 2019; Sun et al., 2020). However, the focus is solely on reducing computational resources or inference time, leaving the process of searching for the right compact model ever more costly. Furthermore, almost all model compression methods start with a large pre-trained model, which in practice may not exist. Recent work (You et al., 2020b) proposes to use large training batches, which significantly shortens pre-training time of BERT-Large model but demands daunting computing resources (1,024 TPUv3 chips).
+
+In contrast, our quest is to find a general resource-efficient training algorithm for large NLP models, which can be applied to both pre-training and fine-tuning stages. Our goal is to trim down the training time, but also avoiding more costs of the total training resources (e.g., taking large-batch or distributed training). To meet this challenge demand, we draw inspirations from a recent work (You et al., 2020a) that explores the use of Lottery Ticket Hypothesis (LTH) for efficient training of computer vision models. LTH was first proposed in Frankle & Carbin (2019) as an exploration to understand the training process of deep networks. The original LTH substantiates a trainable sparse sub-network at initialization, but it cannot be directly utilized for efficient training, since the subnetwork itself has to be searched through a tedious iterative process. In addition, most LTH works discussed only unstructured sparsity. The study of You et al. (2020a) presents new discoveries that structured lottery tickets can emerge in early stage of training (i.e., Early-Bird Ticket), and therefore a structurally sparse sub-network can be identified with much lower costs, leading to practical efficient training algorithms.
+
+Inspired by the success of LTH and Early-Bird Ticket, we propose EarlyBERT, a general efficient training algorithm based on structured Early-Bird Tickets. Due to the vast differences between the architectures and building blocks of computer vision models and BERT, directly extending the method of (You et al., 2020a) is not applicable to our work. By instead using network slimming (Liu et al., 2017) on the self-attention and fully-connected sub-layers inside a transformer, we are the first to introduce an effective approach that can identify structured winning tickets in the early stage of BERT training, that are successfully applied for efficient language modeling pre-training and finetuning. Extensive experiments on BERT demonstrate that EarlyBERT can save $3 5 \sim 4 5 \%$ training time without sacrificing accuracy, when evaluated on GLUE and SQuAD benchmarks.
+
+# 2 RELATED WORK
+
+Efficient NLP Models It is well believed that BERT and other large NLP models are considerably overparameterized (McCarley, 2019; Sun et al., 2019). This explains the emergence of many model compression works, which can be roughly categorized into quantization (Shen et al., 2020; Zafrir et al., 2019), knowledge distillation (Sun et al., 2019; Jiao et al., 2019; Sanh et al., 2019; Sun et al., 2020), dynamic routing (Fan et al., 2019; Xin et al., 2020), and pruning (Li et al., 2020; Wang et al., 2019; McCarley, 2019; Michel et al., 2019). Almost all model compression methods focus on reducing inference time, while their common drawback is the reliance on fully-trained and heavilyengineered dense models, before proceeding to their compact, sparse versions - which essentially transplants the resource burden from the inference to the training stage
+
+Pruning is the mainstream approach for compressing BERT so far. McCarley (2019) proposed to greedily and iteratively prune away attention heads contributing less to the model. Wang et al. (2019) proposed to structurally prune BERT models using low-rank factorization and augmented Lagrangian $\ell _ { 0 }$ norm regularization. McCarley (2019) pruned less important self-attention heads and slices of MLP layers by applying $\ell _ { 0 }$ regularization to the coefficient corresponding to each head/MLP layer. Another line of works aim to reduce the training time of transformer-based models via large-batch training and GPU model parallelism (You et al., 2020b; Shoeybi et al., 2019). Our work is orthogonal to those works, and can be readily combined for further efficiency boost.
+
+Lottery Ticket Hypothesis in Computer Vision Lottery Ticket Hypothesis (LTH) was firstly proposed in Frankle & Carbin (2019), which shed light on the existence of sparse sub-networks (i.e., winning tickets) at initialization with non-trivial sparsity ratio that can achieve almost the same performance (compared to the full model) when trained alone. The winning tickets are identified by pruning fully trained networks using the so-called Iterative Magnitude-based Pruning (IMP). However, IMP is expensive due to its iterative nature. Moreover, IMP leads to unstructured sparsity, which is known to be insufficient in reducing training cost or accelerating training speed practically. Those barriers prevent LTH from becoming immediately helpful towards efficient training. Morcos et al. (2019) studies the transferability of winning tickets between datasets and optimizers. Zhou et al. (2019) investigates different components in LTH and observes the existence of super-masks in winning tickets. Lately, You et al. (2020a) pioneers to identify Early-Bird Tickets, which emerge at the early stage of the training process, and contain structured sparsity when pruned with Network Slimming (Liu et al., 2017). Early-bird tickets mitigate the two limitations of IMP aforementioned, and renders it possible to training deep models efficiently, by drawing such tickets early in the training and then focusing on training this compact subnetwork only.
+
+Lottery Ticket Hypothesis in NLP All above works evaluate their methods on computer vision models. For NLP models, previous work has also found that matching subnetworks exist in training on Transformers and LSTMs (Yu et al., 2019; Renda et al., 2020). Evci et al. (2020) derived an algorithm for training sparse neural networks according to LTH and applied it to a character-level language modeling on WikiText-103. For BERT models, a latest work (Chen et al., 2020) found that the pre-trained BERT models contain sparse subnetworks, found by unstructured IMP at $40 \%$ to $90 \%$ sparsity, that are independently trainable and transferable to a range of downstream tasks with no performance degradation. Another concurrent work (Prasanna et al., 2020) aims to find structurally sparse lottery tickets for BERT, by pruning entire attention heads and MLP layers. Their experiments turn out that all subnetworks (“good” and “bad”) have “comparable performance” when fined-tuned on downstream tasks, leading to their “all tickets are winning” conclusion.
+
+Nevertheless, both works (Chen et al., 2020; Prasanna et al., 2020) examine only the pre-trained BERT model, i.e., finding tickets with regard to the fine-tuning stage on downstream tasks. To our best knowledge, no existing study analyzes the LTH at the pre-training stage of BERT; nor has any work discussed the efficient BERT training using LTH, for either pre-training or fine-tuning stage. In comparision, our work represents the first attempt of introducing LTH to both efficient pre-training and efficient fine-tuning of BERT. Our results also provide positive evidence that LTH and Early-Bird Tickets in NLP models are amendable to structured pruning too.
+
+# 3 THE EARLYBERT FRAMEWORK
+
+In this section, we first revisit the original Lottery Ticket Hypothesis (LTH) (Frankle & Carbin, 2019) and its variant Early-Bird Ticket (You et al., 2020a), then describe our proposed EarlyBERT.
+
+# 3.1 REVISITING LOTTERY TICKET HYPOTHESIS
+
+Denote $f ( x ; \theta )$ as a deep network parameterized by $\theta$ and $x$ as its input. A sub-network of $f$ can be characterized by a binary mask $m$ , which has exactly the same dimension as $\theta$ . When applying the mask $m$ to the network, we obtain the sub-network $f ( x ; \theta \odot m )$ , where $\odot$ is the Hadamard product operator. LTH states that, for a network initialized with $\theta _ { 0 }$ , an algorithm called Iterative Magnitude Pruning (IMP) can identify a mask $m$ such that the sub-network $f ( x ; \theta _ { 0 } \odot m )$ can be trained to have no worse performance than the full model $f$ following the same training protocol. Such a sub-network $f ( x ; \bar { \theta } _ { 0 } \odot m )$ , including both the mask $m$ and initial parameters $\theta _ { 0 }$ , is called a winning ticket. The IMP algorithm works as follows: (1) initialize $m$ as an all-one mask; (2) fully train $f ( x ; \theta _ { 0 } \odot m )$ to obtain a well-trained $\theta$ ; (3) remove a small portion of weights with the smallest magnitudes from $\theta \odot m$ and update $m$ ; (4) repeat (2)-(3) until a certain sparsity ratio is achieved.
+
+Two obstacles prevent LTH from being directly applied to efficient training. First, the iterative process in IMP is essential to preserve the performance of LTH; however, this is computationally expensive, especially when the number of iterations is high. Second, the original LTH does not pursue any structured sparsity in the winning tickets. In practice, unstructured sparsity is difficult to be utilized for computation acceleration even when the sparsity ratio is high (Wen et al., 2016).
+
+To mitigate these gaps, Early-Bird Tickets are proposed by You et al. (2020a), who discovers that when using structured mask $m$ and a properly selected learning rate, the mask $m$ quickly converges and the corresponding mask emerges as the winning ticket in the early stage of training. The early emergence of winning tickets and the structured sparsity are both helpful in reducing computational cost in the training that follows. You et al. (2020a) focuses on computer vision tasks with convolutional networks such as VGG (Simonyan & Zisserman, 2014) and ResNet (He et al., 2016). Inspired by this, we set out to explore whether there are structured winning tickets in the early stage of BERT training that can significantly accelerate language model pre-training and fine-tuning.
+
+# 3.2 DISCOVERING EARLYBERT
+
+The proposed EarlyBERT1 training framework consists of three steps: (i) Searching Stage: jointly train BERT and the sparsity-inducing coefficients to be used to draw the winning ticket; (ii) Ticketdrawing Stage: draw the winning ticket using the learned coefficients; and (iii) Efficient-training Stage: train EarlyBERT for pre-training or downstream fine-tuning.
+
+Searching Stage To search for the key sub-structure in BERT, we follow the main idea of Network Slimming (NS) (Liu et al., 2017). However, pruning in NS is based on the scaling factor $\gamma$ in batch normalization, which is not used in most NLP models such as BERT. Therefore, we make necessary modifications to the original NS so that it can be adapted to pruning BERT. Specifically, we propose to associate attention heads and intermediate layers of the fully-connected sub-layers in a transformer with learnable coefficients, which will be jointly trained with BERT but with an additional $\ell _ { 1 }$ regularization to promote sparsity.
+
+Some studies (Michel et al., 2019; Voita et al., 2019) find that the multi-head self-attention module of transformer can be redundant sometimes, presenting the possibility of pruning some heads from each layer of BERT without hurting model capacity. A multi-head attention module (Vaswani et al., 2017) is formulated as:
+
+$$
+\begin{array} { r } { \begin{array} { r l } & { \mathrm { M u l t i H e a d } ( Q , K , V ) = \mathrm { C o n c a t } ( \mathrm { h e a d } _ { 1 } , \dots , \mathrm { h e a d } _ { h } ) W ^ { O } } \\ & { ~ \mathrm { w h e r e ~ h e a d } _ { i } = \mathrm { A t t e n t i o n } ( Q W _ { i } ^ { Q } , K W _ { i } ^ { K } , V W _ { i } ^ { V } ) , } \end{array} } \end{array}
+$$
+
+where the projections $W ^ { O } , W _ { i } ^ { Q } , W _ { i } ^ { K } , W _ { i } ^ { V }$ are used for output, query, key and value. Inspired by Liu et al. (2017), we introduce a set of scalar coefficients $c _ { i } ^ { h }$ ( $_ i$ is the index of attention heads and $h$ means “head”) inside ${ \mathrm { h e a d } } _ { i }$ :
+
+$$
+\mathrm { h e a d } _ { i } = c _ { i } ^ { h } \cdot \mathrm { A t t e n t i o n } ( Q W _ { i } ^ { Q } , K W _ { i } ^ { K } , V W _ { i } ^ { V } ) .
+$$
+
+After the self-attention sub-layer in each transformer layer, the output $\mathrm { M u l t i H e a d } ( Q , K , V )$ will be fed into a two-layer fully-connected network, in which the first layer increases the dimension of the embedding by 4 times and then reduces it back to the hidden size (768 for BERTBASE and 1,024 for BERTLARGE). We multiply learnable coefficients to the intermediate neurons:
+
+$$
+\mathrm { F F N } ( x ) = c ^ { f } \cdot \operatorname* { m a x } ( 0 , x W _ { 1 } + b _ { 1 } ) W _ { 2 } + b _ { 2 } .
+$$
+
+These modifications allow us to jointly train BERT with the coefficients, using the following loss:
+
+$$
+\mathcal { L } ( f ( \cdot ; \theta ) , c ) = \mathcal { L } _ { 0 } ( f ( \cdot ; \theta ) , c ) + \lambda \| c \| _ { 1 } ,
+$$
+
+where $\mathcal { L } _ { 0 }$ is the original loss function used in pre-training or fine-tuning, $c$ is the concatenation of all the coefficients in the model including those for attention heads and intermediate neurons, and $\lambda$ is the hyper-parameter that controls the strength of regularization.
+
+Note that in this step, the joint training of BERT and the coefficients are still as expensive as normal BERT training. However, the winning strategy of EarlyBERT is that we only need to perform this joint training for a few steps, before the winning ticket emerges, which is much shorter than the full training process of pre-training or fine-tuning. In other words, we can identify the winning tickets at a very low cost compared to the full training. Then, we draw the ticket (i.e., the EarlyBERT), reset the parameters and train EarlyBERT that is computationally efficient thanks to its structured sparsity. Next, we introduce how we draw EarlyBERT from the learned coefficients.
+
+Ticket-drawing Stage After training BERT and coefficients $c$ jointly, we draw EarlyBERT using the learned coefficients with a magnitude-based metric. Note that we prune attention heads and intermediate neurons separately, as they play different roles in BERT.
+
+We prune the attention heads whose coefficients have the smallest magnitudes, and remove them from the computation graph. We also prune the rows in $W ^ { O }$ (see Eqn. (1)) that correspond to the removed heads. Note that this presents a design choice: should we prune the heads globally or layer-wisely? In this paper, we use layer-wise pruning for attention heads, because the number of heads in each layer is very small (12 for BERTBASE and 16 for BERTLARGE). We observe empirically that if pruned globally, the attention heads in some layers may be completely removed, making the network un-trainable. Furthermore, Ramsauer et al. (2020) observes that attention heads in different layers exhibit different behaviors. This also motivates us to only compare importance of attention heads within each layer.
+
+Similar to pruning attention heads, we prune intermediate neurons in the fully-connected sub-layers. Pruning neurons is equivalent to reducing the size of intermediate layers, which leads to a reduced size of the weight matrices $W _ { 1 }$ and $W _ { 2 }$ in Eqn. (4). Between global and layer-wise pruning, empirical analysis shows that global pruning works better. We also observe that our algorithm naturally prunes more neurons for the later layers than earlier ones, which coincides with many pruning works on vision tasks. We leave the analysis of this phenomenon as future work.
+
+Efficient-training Stage We then train EarlyBERT that we have drawn for pre-training or finetuning depending on the target task. If we apply EarlyBERT to pre-training, the initialization $\theta _ { 0 }$ of BERT will be a random initialization, the same setting as the original LTH (Frankle & Carbin, 2019)
+
+and Early-Bird Tickets (You et al., 2020a). If we apply EarlyBERT to fine-tuning, then $\theta _ { 0 }$ can be any pre-trained model. We can also moderately reduce the training steps in this stage without sacrificing performance, which is empirically supported by the findings in Frankle & Carbin (2019); You et al. (2020a) that the winning tickets can be trained more effectively than the full model. In practice, the learning rate can also be increased to speed up training, in addition to reducing training steps.
+
+Different from unstructured pruning used in LTH and many other compression works (Frankle & Carbin, 2019; Chen et al., 2020), structurally pruning attention heads and intermediate neurons in fully-connected layers can directly reduce the number of computations required in the transformer layer, and shrink the matrix size of the corresponding operations, yielding a direct reduction in computation and memory costs.
+
+# 3.3 VALIDATION OF EARLYBERT
+
+Early Emergence Following a similar manner in You et al. (2020a), we visualize the normalized mask distance between different training steps, to validate the early emergence of winning tickets. In Figure 1, the axes in the plots are the number of training steps finished. We only use one fullyconnected sub-layer to plot Figure 1(b),1(d) due to high dimensionality. In both pre-training and fine-tuning, the mask converges in a very early stage of the whole training process. Although we observe an increase of mask distance in fully-connected layers during pre-training (in Figure 1(b)), this can be easily eliminated by early stopping and using mask distance as the exit criterion.
+
+Non-trivial Sub-network Here, by non-trivial we mean that with the same sparsity ratio as in EarlyBERT, randomly pruned model suffers from significant performance drop. The performance drop happens even if we only prune attention heads. We verify this by running fine-tuning experiments on BERTBASE. Specifically, we prune 4 heads from each transformer layer in BERTBASE and EarlyBERT. We finetune BERTBASE for 3 epochs with an ini
+
+Table 1: Comparison between randomly-pruned models and EarlyBERT on 4 GLUE tasks. We prune 4 heads in each layer.   
+
+<table><tr><td>Methods</td><td>MNLI</td><td>QNLI</td><td>QQP</td><td>SST-2</td></tr><tr><td>BERTBASE</td><td>83.16</td><td>90.59</td><td>90.34</td><td>91.70</td></tr><tr><td>EarlyBERTBASE</td><td>83.58</td><td>90.33</td><td>90.41</td><td>92.09</td></tr><tr><td>Random</td><td>82.26</td><td>88.87</td><td>90.12</td><td>91.17</td></tr></table>
+
+tial learning rate $2 \times \mathrm { i 0 ^ { - 5 } }$ . We run the searching stage for 0.2 epochs with $\lambda = 1 \times 1 0 ^ { - 4 }$ , draw EarlyBERT with pruning ratio $\rho = 1 / 3$ , and then fine-tune EarlyBERT for 2 epochs with doubled initial learning rate. For the randomly pruned models, we randomly prune 4 heads in each layer and follow the same fine-tuning protocol as EarlyBERT. The reported results of randomly pruned models are the average of 5 trials with different seeds for pruning. The results on three tasks from GLUE benchmark (Wang et al., 2018) presented in Table 1 show that randomly pruned model consistently under-performs EarlyBERT with a significant gap, supporting our claim that EarlyBERT indeed identifies non-trivial sub-structures.
+
+# 4 EXPERIMENTS
+
+# 4.1 EXPERIMENTAL SETTING
+
+Backbone Models Following the official BERT implementation (Devlin et al., 2018; Wolf et al., 2019), we use both BERTBASE (12 transformer layers, hidden size 768, 3,072 intermediate neurons, 12 self-attention heads per layer, 110M parameters in total) and BERTLARGE (24 transformer layers, hidden size 1,024, 4,096 intermediate neurons, 16 self-attention heads per layer, 340M parameters in total) for experiments.
+
+Datasets We use English Wikipedia (2,500M words) as the pre-training data. For fine-tuning experiments and evaluation of models in the pre-training experiments, we use tasks from GLUE benchmark (Wang et al., 2018) and a question-answering dataset SQuAD v1.1 (Rajpurkar et al., 2016). Note that as our goal is efficient pre-training and fine-tuning, we focus on larger datasets from GLUE (MNLI, QNLI, QQP and SST-2), as it is less meaningful to discuss efficient training on very small datasets. We use the default training settings for pre-training and fine-tuning on both models. To evaluate model performance, we use Matthew’s correlation score for CoLA, matched accuracy for MNLI, F1-score for SQuAD v1.1, and accuracy in percentage for other tasks on GLUE. We omit $\%$ symbols in all the tables on accuracy results.
+
+![](images/1ce7350e9d25cc7c12f257190fb0e0b767d241696732391e5ea24cf192a1a54a.jpg)  
+Figure 1: Illustration of Mask Distance. Top: mask distance observed in pre-training. Bottom: mask distance observed in fine-tuning. The color represents the normalized mask distance between different training steps. The darker the color, the smaller the mask distance.
+
+Implementation Details For the vanilla BERT, we fine-tune on GLUE datasets for 3 epochs with initial learning rate $2 \times 1 0 ^ { - 5 }$ , and for 2 epochs on SQuAD with initial learning rate $\mathrm { { \bar { 3 } } \times 1 0 ^ { - 5 } }$ ; we use AdamW (Loshchilov & Hutter, 2017) optimizer for both cases. For pre-training, we adopt LAMB optimization technique (You et al., 2020b), which involves two phases of training: the first 9/10 of the total training steps uses a sequence length of 128, while the last 1/10 uses a sequence length of 512. Pre-training by default has 8,601 training steps and uses $6 4 \mathrm { k } / 3 2 \mathrm { k }$ batch sizes and $6 \times \mathrm { { 1 0 ^ { - 3 } } / 4 \times 1 0 ^ { - 3 } }$ initial learning rates for the two phases, respectively. All experiments are run on 16 NVIDIA V100 GPUs.
+
+# 4.2 EXPERIMENTS ON FINE-TUNING
+
+The main results of EarlyBERT in fine-tuning are presented in Table 2. When drawing EarlyBERT, we prune 4 heads in each layer from BERTBASE and 6 heads from BERTLARGE, and globally prune $40 \%$ intermediate neurons in fully-connected sub-layers in both models. We reduce the training epochs to two on GLUE benchmark and scale up the learning rate by 2 to buffer the effect of reduced epochs. For SQuAD dataset, we keep the default setting, as we find SQuAD is more sensitive to the number of training epochs. Ablation studies on the effects of the number of training epochs and learning rate are included in the following section.
+
+Several observations can be drawn from Table 2. Firstly, in most tasks, EarlyBERT saves over $40 \%$ of the total training time without inducing much performance degradation. It can also outperform another strong baseline LayerDrop (Fan et al., 2019), which drops one third of the layers so that the number of remaining parameters are comparable to ours. Note that LayerDrop models are fine-tuned for three full epochs, yet EarlyBERT is still competitive in most cases. Secondly, we consistently observe obvious performance advantage of EarlyBERT over randomly pruned models, which provides another strong evidence that EarlyBERT does discover nontrivial key sparse structures. Even though there still exists a margin between EarlyBERT and the baseline (like (You et al., 2020a) also observed similarly in their tasks), the existence of structured winning tickets and its potential for efficient training is highly promising. We leave as future work to discover winning tickets of higher sparsity but better quality.
+
+Table 2: Performance of EarlyBERT (fine-tuning) compared with different baselines.   
+
+<table><tr><td>Methods</td><td>MNLI</td><td>QNLI</td><td>QQP</td><td>SST-2</td><td>SQuAD</td><td>Time Saved2</td></tr><tr><td>BERTBASE</td><td>83.16</td><td>90.59</td><td>90.34</td><td>91.70</td><td>87.50</td><td>1</td></tr><tr><td>EarlyBERTBASE</td><td>81.81</td><td>89.18</td><td>90.06</td><td>90.71</td><td>86.13</td><td>40~45%</td></tr><tr><td>RandomBASE</td><td>79.92</td><td>84.46</td><td>89.42</td><td>89.68</td><td>84.47</td><td>45~50%</td></tr><tr><td>LayerDrop (Fan et al., 2019)</td><td>81.27</td><td>88.91</td><td>88.06</td><td>89.89</td><td>84.25</td><td>~33%</td></tr><tr><td>BERTLARGE</td><td>86.59</td><td>92.29</td><td>91.59</td><td>92.21</td><td>90.76</td><td>1</td></tr><tr><td>EarlyBERTLARGE</td><td>85.13</td><td>89.22</td><td>90.64</td><td>90.94</td><td>89.45</td><td>35~40%</td></tr><tr><td>RandomLARGE</td><td>78.45</td><td>84.46</td><td>89.89</td><td>88.65</td><td>88.79</td><td>40~45%</td></tr><tr><td>LayerDrop (Fan et al., 2019)</td><td>85.12</td><td>91.12</td><td>88.88</td><td>89.97</td><td>89.44</td><td>~33%</td></tr></table>
+
+Ablation Studies on Fine-tuning We perform extensive ablation studies to investigate important hyperparameter settings in EarlyBERT, using EarlyBERTBASE as our testing bed. For all experiments, we use the average accuracy on the larger datasets from GLUE benchmark (MNLI, QNLI, QQP and SST-2) as the evaluation metric.
+
+• Number of training epochs and learning rate. We first investigate whether we can properly reduce the number of training epochs, and if scaling the learning rate can help compliment the negative effect caused by reducing training steps. Results in Figure 2 show that when we fine-tune EarlyBERT for fewer epochs on GLUE benchmark, up-scaling learning rate first helps to recover performance, and then causes decrease again. We will use two epochs and $4 \times 1 0 ^ { - 5 }$ as learning rate for EarlyBERT on GLUE experiments.
+
+• Regularization strength $\lambda .$ . A proper selection of the regularization strength $\lambda$ decides the quality of the winning ticket, consequently the performance of EarlyBERT after pre-training/finetuning. Results on different strength settings in Table 3 show that the regularization strength $\lambda$ has marginal influence on EarlyBERT performance. We use $\lambda = 1 0 ^ { - 4 }$ that achieves the best performance in following experiments.
+
+• Pruning ratios $\rho$ . We further investigate the effects of different pruning ratios as well as layerwise/global pruning on the performance of EarlyBERT. As discussed in Sec. 3.2, we only consider layer-wise pruning for self-attention heads. Table 4 shows that the performance monotonically decreases when we prune more self-attention heads from BERT; however, we see a slight increase and then a sharp decrease in accuracy, when the pruning ratio is raised for intermediate neurons in fully-connected sub-layers $4 0 \%$ pruning ratio seems to be the sweet spot). We also observe consistent superiority of global pruning over layer-wise pruning for intermediate neurons.
+
+# 4.3 EXPERIMENTS ON PRE-TRAINING
+
+We also conduct pre-training experiments and present the main results in Table 5. Similar to the settings in fine-tuning experiments, we prune 4 heads in each layer from BERTBASE and 6 heads from BERTLARGE; however, we prune slightly fewer $( 3 0 \% )$ intermediate neurons in fully-connected sublayers in both models, since we empirically observe that pre-training is more sensitive to aggressive intermediate neuron pruning. In both phases of pre-training, we reduce the training steps to $80 \%$ of the default setting when training EarlyBERT (based on the ablation study shown in Figure 3). Other hyperparameters for pre-training follow the default setting described in Sec. 4.1. All models are fine-tuned and evaluated on GLUE (Wang et al., 2018) and SQuAD v1.1 datasets (Rajpurkar et al., 2016) with the default setting. Since we observe that the randomly pruned models do not competitive performance in fine-tuning experiment for all downstream tasks, in this section we focus on comparing the achievable performance EarlyBERT with full BERT baseline.
+
+![](images/53de4ee25232c6cf199cce8940f110e70ffbc7fd00618b608cf818901a60568a.jpg)  
+Figure 2: Effect of reducing training epochs and up-scaling learning rate for EarlyBERT in fine-tuning.
+
+Table 3: Ablation of regularization strength $\lambda$ .   
+
+<table><tr><td>入</td><td>10-4</td><td>10-3</td><td>10-2</td></tr><tr><td>Avg. Acc.</td><td>89.10</td><td>88.81</td><td>88.93</td></tr></table>
+
+Table 4: Ablation of pruning ratios on self-attention heads and intermediate neurons.   
+
+<table><tr><td>#Pruned Heads</td><td>4</td><td>5</td><td>6</td></tr><tr><td>Layer-wise pruning</td><td>89.10</td><td>88.69</td><td>88.26</td></tr><tr><td># Pruned Neurons</td><td>30%</td><td>40%</td><td>50%</td></tr><tr><td> Layer-wise pruning</td><td>88.33</td><td>88.48</td><td>87.91</td></tr><tr><td>Global pruning</td><td>88.54</td><td>88.70</td><td>88.01</td></tr></table>
+
+Table 5: Performance of EarlyBERT (pre-training) compared with BERT baselines.   
+
+<table><tr><td>Methods</td><td>CoLA</td><td>MNLI</td><td>MRPC</td><td>QNLI</td><td>QQP</td><td>RTE</td><td>SST-2</td><td>SQuAD</td></tr><tr><td>BERTBASE</td><td>0.45</td><td>81.40</td><td>84.07</td><td>89.86</td><td>89.80</td><td>60.29</td><td>90.48</td><td>87.60</td></tr><tr><td>EarlyBERTBASE</td><td>0.41</td><td>79.97</td><td>80.39</td><td>89.86</td><td>89.44</td><td>61.01</td><td>90.94</td><td>85.48</td></tr><tr><td>BERTLARGE</td><td>0.50</td><td>83.56</td><td>85.90</td><td>90.44</td><td>90.45</td><td>59.93</td><td>92.55</td><td>90.43</td></tr><tr><td>EarlyBERTLARGE</td><td>0.47</td><td>82.54</td><td>85.54</td><td>90.46</td><td>90.38</td><td>61.73</td><td>91.51</td><td>89.36</td></tr></table>
+
+From the results presented in Table 5, we can see that on downstream tasks with larger datasets such as QNLI, QQP and SST-2 we can achieve accuracies that are close to BERT baseline (within $1 \%$ accuracy gaps except for EarlyBERTBASE on MNLI and SQuAD). However, on downstream tasks with smaller learning rate, the patterns are not consistent: we observe big drops on CoLA and MRPC but improvement on RTE. Overall, EarlyBERT achieves comparable performance while saving $30 \sim 3 5 \%$ training time thanks to its structured sparsity and reduction in training steps.
+
+Reducing Training Steps in Pre-training We investigate whether EarlyBERT, when non-essential heads and/or intermediate neurons are pruned, can train more efficiently, and whether we can reduce the number of training steps in pre-training. This can further help reduce training cost in addition to the efficiency gain from pruning. We use EarlyBERTBASESelf (only self-attention heads are pruned when drawing the winning ticket) as the testing bed. Figure 3 shows the performance decreases more when we reduce the number of training steps to $60 \%$ or less. Reducing it to $80 \%$ seems to be a sweet point with the best balance between performance and efficiency.
+
+![](images/f570bb768b9f42cfb8a25f43111639181bd1f083ab4afa9f6e087c5007461b5e.jpg)  
+Figure 3: Effect of reducing training steps in pre-training on EarlyBERTBASE.
+
+# 5 CONCLUSION
+
+In this paper, we present EarlyBERT, an efficient training framework for large-scale language model pre-training and fine-tuning. Based on Lottery Ticket Hypothesis, EarlyBERT identifies structured winning tickets in an early stage, then uses the pruned network for efficient training. Experimental results on GLUE and SQuAD demonstrate that the proposed method is able to achieve comparable performance to standard BERT with much less training time. Future work includes applying EarlyBERT to other pre-trained language models and exploring more data-efficient strategies to enhance the current training pipeline.
+
+# REFERENCES
+
+Tianlong Chen, Jonathan Frankle, Shiyu Chang, Sijia Liu, Yang Zhang, Zhangyang Wang, and Michael Carbin. The lottery ticket hypothesis for pre-trained bert networks, 2020.
+
+Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. arXiv preprint arXiv:1810.04805, 2018.
+
+Utku Evci, Trevor Gale, Jacob Menick, Pablo Samuel Castro, and Erich Elsen. Rigging the lottery: Making all tickets winners. In MLSys, pp. 471–481. 2020.
+
+Angela Fan, Edouard Grave, and Armand Joulin. Reducing transformer depth on demand with structured dropout. arXiv preprint arXiv:1909.11556, 2019.
+
+Jonathan Frankle and Michael Carbin. The lottery ticket hypothesis: Finding sparse, trainable neural networks. In ICLR, 2019.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, pp. 770–778, 2016.
+
+Xiaoqi Jiao, Yichun Yin, Lifeng Shang, Xin Jiang, Xiao Chen, Linlin Li, Fang Wang, and Qun Liu. Tinybert: Distilling bert for natural language understanding. arXiv preprint arXiv:1909.10351, 2019.
+
+Zhuohan Li, Eric Wallace, Sheng Shen, Kevin Lin, Kurt Keutzer, Dan Klein, and Joseph E. Gonzalez. Train large, then compress: Rethinking model size for efficient training and inference of transformers, 2020.
+
+Zhuang Liu, Jianguo Li, Zhiqiang Shen, Gao Huang, Shoumeng Yan, and Changshui Zhang. Learning efficient convolutional networks through network slimming. In ICCV, 2017.
+
+Ilya Loshchilov and Frank Hutter. Decoupled weight decay regularization. arXiv preprint arXiv:1711.05101, 2017.
+
+J Scott McCarley. Pruning a bert-based question answering model. arXiv preprint arXiv:1910.06360, 2019.
+
+Paul Michel, Omer Levy, and Graham Neubig. Are sixteen heads really better than one? In NeurIPS, 2019.
+
+Ari Morcos, Haonan Yu, Michela Paganini, and Yuandong Tian. One ticket to win them all: generalizing lottery ticket initializations across datasets and optimizers. In NeurIPS, pp. 4932–4942, 2019.
+
+Sai Prasanna, Anna Rogers, and Anna Rumshisky. When bert plays the lottery, all tickets are winning. arXiv preprint arXiv:2005.00561, 2020.
+
+Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, and Peter J Liu. Exploring the limits of transfer learning with a unified text-to-text transformer. arXiv preprint arXiv:1910.10683, 2019.
+
+Pranav Rajpurkar, Jian Zhang, Konstantin Lopyrev, and Percy Liang. Squad: $1 0 0 { , } 0 0 0 { + }$ questions for machine comprehension of text, 2016.
+
+Hubert Ramsauer, Bernhard Schafl, Johannes Lehner, Philipp Seidl, Michael Widrich, Lukas Gru- ¨ ber, Markus Holzleitner, Milena Pavlovic, Geir Kjetil Sandve, Victor Greiff, et al. Hopfield ´ networks is all you need. arXiv preprint arXiv:2008.02217, 2020.
+
+Alex Renda, Jonathan Frankle, and Michael Carbin. Comparing rewinding and fine-tuning in neural network pruning. arXiv preprint arXiv:2003.02389, 2020.
+
+Victor Sanh, Lysandre Debut, Julien Chaumond, and Thomas Wolf. Distilbert, a distilled version of bert: smaller, faster, cheaper and lighter. arXiv preprint arXiv:1910.01108, 2019.
+
+Sheng Shen, Zhen Dong, Jiayu Ye, Linjian Ma, Zhewei Yao, Amir Gholami, Michael W Mahoney, and Kurt Keutzer. Q-bert: Hessian based ultra low precision quantization of bert. In AAAI, pp. 8815–8821, 2020.
+
+M. Shoeybi, M. Patwary, R. Puri, P. LeGresley, J. Casper, and Bryan Catanzaro. Megatron-lm: Training multi-billion parameter language models using model parallelism. arXiv, 2019.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014.
+
+S. Sun, Yu Cheng, Zhe Gan, and Jingjing Liu. Patient knowledge distillation for bert model compression. In EMNLP, 2019.
+
+Zhiqing Sun, Hongkun Yu, Xiaodan Song, Renjie Liu, Yiming Yang, and Denny Zhou. MobileBERT: a compact task-agnostic BERT for resource-limited devices. In ACL, 2020.
+
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In NeurIPS, pp. 5998–6008, 2017.
+
+Elena Voita, David Talbot, Fedor Moiseev, Rico Sennrich, and Ivan Titov. Analyzing multi-head self-attention: Specialized heads do the heavy lifting, the rest can be pruned. arXiv preprint arXiv:1905.09418, 2019.
+
+Alex Wang, Amanpreet Singh, Julian Michael, Felix Hill, Omer Levy, and Samuel R Bowman. Glue: A multi-task benchmark and analysis platform for natural language understanding. arXiv preprint arXiv:1804.07461, 2018.
+
+Ziheng Wang, Jeremy Wohlwend, and Tao Lei. Structured pruning of large language models. arXiv preprint arXiv:1910.04732, 2019.
+
+Wei Wen, Chunpeng Wu, Yandan Wang, Yiran Chen, and Hai Li. Learning structured sparsity in deep neural networks. In NeurIPS, pp. 2074–2082, 2016.
+
+Thomas Wolf, Lysandre Debut, Victor Sanh, Julien Chaumond, Clement Delangue, Anthony Moi, Pierric Cistac, Tim Rault, Remi Louf, Morgan Funtowicz, et al. Huggingface’s transformers: ´ State-of-the-art natural language processing. ArXiv, pp. arXiv–1910, 2019.
+
+Ji Xin, Raphael Tang, Jaejun Lee, Yaoliang Yu, and Jimmy Lin. DeeBERT: Dynamic early exiting for accelerating BERT inference. In ACL, pp. 2246–2251, Online, July 2020. Association for Computational Linguistics.
+
+Zhilin Yang, Zihang Dai, Yiming Yang, Jaime Carbonell, Russ R Salakhutdinov, and Quoc V Le. Xlnet: Generalized autoregressive pretraining for language understanding. In NeurIPS, 2019.
+
+Haoran You, Chaojian Li, Pengfei Xu, Yonggan Fu, Yue Wang, Xiaohan Chen, Richard G. Baraniuk, Zhangyang Wang, and Yingyan Lin. Drawing early-bird tickets: Toward more efficient training of deep networks. In ICLR, 2020a.
+
+Yang You, Jing Li, Sashank Reddi, Jonathan Hseu, Sanjiv Kumar, Srinadh Bhojanapalli, Xiaodan Song, James Demmel, Kurt Keutzer, and Cho-Jui Hsieh. Large batch optimization for deep learning: Training bert in 76 minutes. In ICLR, 2020b.
+
+Haonan Yu, Sergey Edunov, Yuandong Tian, and Ari S Morcos. Playing the lottery with rewards and multiple languages: lottery tickets in rl and nlp. In ICLR, 2019.
+
+Ofir Zafrir, Guy Boudoukh, Peter Izsak, and Moshe Wasserblat. Q8bert: Quantized 8bit bert. arXiv preprint arXiv:1910.06188, 2019.
+
+Hattie Zhou, Janice Lan, Rosanne Liu, and Jason Yosinski. Deconstructing lottery tickets: Zeros, signs, and the supermask. In NeurIPS, pp. 3597–3607, 2019.

parse/train/I-VfjSBzi36/I-VfjSBzi36_content_list.json

@@ -0,0 +1,1282 @@
+[
+    {
+        "type": "text",
+        "text": "EARLYBERT: EFFICIENT BERT TRAINING VIA EARLY-BIRD LOTTERY TICKETS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            740,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            184,
+            170,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep, heavily overparameterized language models such as BERT, XLNet and T5 have achieved impressive success in many natural language processing (NLP) tasks. However, their high model complexity requires enormous computation resources and extremely long training time for both pre-training and fine-tuning. Many works have studied model compression on large NLP models, but only focusing on reducing inference time while still requiring expensive training process. Other works use extremely large batch sizes to shorten the pre-training time, at the expense of higher computational resource demands. In this paper, inspired by the Early-Bird Lottery Tickets recently studied for computer vision tasks, we propose EarlyBERT, a general computationally-efficient training algorithm applicable to both pre-training and fine-tuning of large-scale language models. By slimming the self-attention and fully-connected sub-layers inside a transformer, we are the first to identify structured winning tickets in the early stage of BERT training. We apply those tickets towards efficient BERT training, and conduct comprehensive pre-training and fine-tuning experiments on GLUE and SQuAD downstream tasks. Our results show that EarlyBERT achieves comparable performance to standard BERT, with $3 5 \\sim 4 5 \\%$ less training time. ",
+        "bbox": [
+            232,
+            266,
+            764,
+            502
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            530,
+            334,
+            546
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Large-scale pre-trained language models (e.g., BERT (Devlin et al., 2018), XLNet (Yang et al., 2019), T5 (Raffel et al., 2019)) have significantly advanced the state of the art in the NLP field. Despite impressive empirical success, their computational inefficiency has become an acute drawback in practice. As more and more transformer layers are stacked with larger self-attention blocks, model complexity increases rapidly. For example, compared to BERT-Large model with 340 million parameters, T5 has more than 10 billion to learn. Such high model complexity calls for expensive computational resources and extremely long training time. ",
+        "bbox": [
+            174,
+            563,
+            823,
+            660
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Model compression is one approach to alleviating this issue. Recently, many methods propose to encode large NLP models compactly (Sun et al., 2019; Sanh et al., 2019; Sun et al., 2020). However, the focus is solely on reducing computational resources or inference time, leaving the process of searching for the right compact model ever more costly. Furthermore, almost all model compression methods start with a large pre-trained model, which in practice may not exist. Recent work (You et al., 2020b) proposes to use large training batches, which significantly shortens pre-training time of BERT-Large model but demands daunting computing resources (1,024 TPUv3 chips). ",
+        "bbox": [
+            174,
+            666,
+            825,
+            763
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In contrast, our quest is to find a general resource-efficient training algorithm for large NLP models, which can be applied to both pre-training and fine-tuning stages. Our goal is to trim down the training time, but also avoiding more costs of the total training resources (e.g., taking large-batch or distributed training). To meet this challenge demand, we draw inspirations from a recent work (You et al., 2020a) that explores the use of Lottery Ticket Hypothesis (LTH) for efficient training of computer vision models. LTH was first proposed in Frankle & Carbin (2019) as an exploration to understand the training process of deep networks. The original LTH substantiates a trainable sparse sub-network at initialization, but it cannot be directly utilized for efficient training, since the subnetwork itself has to be searched through a tedious iterative process. In addition, most LTH works discussed only unstructured sparsity. The study of You et al. (2020a) presents new discoveries that structured lottery tickets can emerge in early stage of training (i.e., Early-Bird Ticket), and therefore a structurally sparse sub-network can be identified with much lower costs, leading to practical efficient training algorithms. ",
+        "bbox": [
+            174,
+            771,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Inspired by the success of LTH and Early-Bird Ticket, we propose EarlyBERT, a general efficient training algorithm based on structured Early-Bird Tickets. Due to the vast differences between the architectures and building blocks of computer vision models and BERT, directly extending the method of (You et al., 2020a) is not applicable to our work. By instead using network slimming (Liu et al., 2017) on the self-attention and fully-connected sub-layers inside a transformer, we are the first to introduce an effective approach that can identify structured winning tickets in the early stage of BERT training, that are successfully applied for efficient language modeling pre-training and finetuning. Extensive experiments on BERT demonstrate that EarlyBERT can save $3 5 \\sim 4 5 \\%$ training time without sacrificing accuracy, when evaluated on GLUE and SQuAD benchmarks. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            263
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            284,
+            344,
+            300
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Efficient NLP Models It is well believed that BERT and other large NLP models are considerably overparameterized (McCarley, 2019; Sun et al., 2019). This explains the emergence of many model compression works, which can be roughly categorized into quantization (Shen et al., 2020; Zafrir et al., 2019), knowledge distillation (Sun et al., 2019; Jiao et al., 2019; Sanh et al., 2019; Sun et al., 2020), dynamic routing (Fan et al., 2019; Xin et al., 2020), and pruning (Li et al., 2020; Wang et al., 2019; McCarley, 2019; Michel et al., 2019). Almost all model compression methods focus on reducing inference time, while their common drawback is the reliance on fully-trained and heavilyengineered dense models, before proceeding to their compact, sparse versions - which essentially transplants the resource burden from the inference to the training stage ",
+        "bbox": [
+            174,
+            309,
+            825,
+            434
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Pruning is the mainstream approach for compressing BERT so far. McCarley (2019) proposed to greedily and iteratively prune away attention heads contributing less to the model. Wang et al. (2019) proposed to structurally prune BERT models using low-rank factorization and augmented Lagrangian $\\ell _ { 0 }$ norm regularization. McCarley (2019) pruned less important self-attention heads and slices of MLP layers by applying $\\ell _ { 0 }$ regularization to the coefficient corresponding to each head/MLP layer. Another line of works aim to reduce the training time of transformer-based models via large-batch training and GPU model parallelism (You et al., 2020b; Shoeybi et al., 2019). Our work is orthogonal to those works, and can be readily combined for further efficiency boost. ",
+        "bbox": [
+            174,
+            440,
+            825,
+            553
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Lottery Ticket Hypothesis in Computer Vision Lottery Ticket Hypothesis (LTH) was firstly proposed in Frankle & Carbin (2019), which shed light on the existence of sparse sub-networks (i.e., winning tickets) at initialization with non-trivial sparsity ratio that can achieve almost the same performance (compared to the full model) when trained alone. The winning tickets are identified by pruning fully trained networks using the so-called Iterative Magnitude-based Pruning (IMP). However, IMP is expensive due to its iterative nature. Moreover, IMP leads to unstructured sparsity, which is known to be insufficient in reducing training cost or accelerating training speed practically. Those barriers prevent LTH from becoming immediately helpful towards efficient training. Morcos et al. (2019) studies the transferability of winning tickets between datasets and optimizers. Zhou et al. (2019) investigates different components in LTH and observes the existence of super-masks in winning tickets. Lately, You et al. (2020a) pioneers to identify Early-Bird Tickets, which emerge at the early stage of the training process, and contain structured sparsity when pruned with Network Slimming (Liu et al., 2017). Early-bird tickets mitigate the two limitations of IMP aforementioned, and renders it possible to training deep models efficiently, by drawing such tickets early in the training and then focusing on training this compact subnetwork only. ",
+        "bbox": [
+            173,
+            558,
+            825,
+            766
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Lottery Ticket Hypothesis in NLP All above works evaluate their methods on computer vision models. For NLP models, previous work has also found that matching subnetworks exist in training on Transformers and LSTMs (Yu et al., 2019; Renda et al., 2020). Evci et al. (2020) derived an algorithm for training sparse neural networks according to LTH and applied it to a character-level language modeling on WikiText-103. For BERT models, a latest work (Chen et al., 2020) found that the pre-trained BERT models contain sparse subnetworks, found by unstructured IMP at $40 \\%$ to $90 \\%$ sparsity, that are independently trainable and transferable to a range of downstream tasks with no performance degradation. Another concurrent work (Prasanna et al., 2020) aims to find structurally sparse lottery tickets for BERT, by pruning entire attention heads and MLP layers. Their experiments turn out that all subnetworks (“good” and “bad”) have “comparable performance” when fined-tuned on downstream tasks, leading to their “all tickets are winning” conclusion. ",
+        "bbox": [
+            174,
+            771,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Nevertheless, both works (Chen et al., 2020; Prasanna et al., 2020) examine only the pre-trained BERT model, i.e., finding tickets with regard to the fine-tuning stage on downstream tasks. To our best knowledge, no existing study analyzes the LTH at the pre-training stage of BERT; nor has any work discussed the efficient BERT training using LTH, for either pre-training or fine-tuning stage. In comparision, our work represents the first attempt of introducing LTH to both efficient pre-training and efficient fine-tuning of BERT. Our results also provide positive evidence that LTH and Early-Bird Tickets in NLP models are amendable to structured pruning too. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            200
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 THE EARLYBERT FRAMEWORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            222,
+            473,
+            238
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we first revisit the original Lottery Ticket Hypothesis (LTH) (Frankle & Carbin, 2019) and its variant Early-Bird Ticket (You et al., 2020a), then describe our proposed EarlyBERT. ",
+        "bbox": [
+            173,
+            253,
+            823,
+            282
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 REVISITING LOTTERY TICKET HYPOTHESIS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            299,
+            517,
+            314
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Denote $f ( x ; \\theta )$ as a deep network parameterized by $\\theta$ and $x$ as its input. A sub-network of $f$ can be characterized by a binary mask $m$ , which has exactly the same dimension as $\\theta$ . When applying the mask $m$ to the network, we obtain the sub-network $f ( x ; \\theta \\odot m )$ , where $\\odot$ is the Hadamard product operator. LTH states that, for a network initialized with $\\theta _ { 0 }$ , an algorithm called Iterative Magnitude Pruning (IMP) can identify a mask $m$ such that the sub-network $f ( x ; \\theta _ { 0 } \\odot m )$ can be trained to have no worse performance than the full model $f$ following the same training protocol. Such a sub-network $f ( x ; \\bar { \\theta } _ { 0 } \\odot m )$ , including both the mask $m$ and initial parameters $\\theta _ { 0 }$ , is called a winning ticket. The IMP algorithm works as follows: (1) initialize $m$ as an all-one mask; (2) fully train $f ( x ; \\theta _ { 0 } \\odot m )$ to obtain a well-trained $\\theta$ ; (3) remove a small portion of weights with the smallest magnitudes from $\\theta \\odot m$ and update $m$ ; (4) repeat (2)-(3) until a certain sparsity ratio is achieved. ",
+        "bbox": [
+            174,
+            325,
+            825,
+            465
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Two obstacles prevent LTH from being directly applied to efficient training. First, the iterative process in IMP is essential to preserve the performance of LTH; however, this is computationally expensive, especially when the number of iterations is high. Second, the original LTH does not pursue any structured sparsity in the winning tickets. In practice, unstructured sparsity is difficult to be utilized for computation acceleration even when the sparsity ratio is high (Wen et al., 2016). ",
+        "bbox": [
+            174,
+            472,
+            823,
+            541
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To mitigate these gaps, Early-Bird Tickets are proposed by You et al. (2020a), who discovers that when using structured mask $m$ and a properly selected learning rate, the mask $m$ quickly converges and the corresponding mask emerges as the winning ticket in the early stage of training. The early emergence of winning tickets and the structured sparsity are both helpful in reducing computational cost in the training that follows. You et al. (2020a) focuses on computer vision tasks with convolutional networks such as VGG (Simonyan & Zisserman, 2014) and ResNet (He et al., 2016). Inspired by this, we set out to explore whether there are structured winning tickets in the early stage of BERT training that can significantly accelerate language model pre-training and fine-tuning. ",
+        "bbox": [
+            174,
+            547,
+            825,
+            660
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 DISCOVERING EARLYBERT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            678,
+            408,
+            691
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The proposed EarlyBERT1 training framework consists of three steps: (i) Searching Stage: jointly train BERT and the sparsity-inducing coefficients to be used to draw the winning ticket; (ii) Ticketdrawing Stage: draw the winning ticket using the learned coefficients; and (iii) Efficient-training Stage: train EarlyBERT for pre-training or downstream fine-tuning. ",
+        "bbox": [
+            174,
+            704,
+            823,
+            760
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Searching Stage To search for the key sub-structure in BERT, we follow the main idea of Network Slimming (NS) (Liu et al., 2017). However, pruning in NS is based on the scaling factor $\\gamma$ in batch normalization, which is not used in most NLP models such as BERT. Therefore, we make necessary modifications to the original NS so that it can be adapted to pruning BERT. Specifically, we propose to associate attention heads and intermediate layers of the fully-connected sub-layers in a transformer with learnable coefficients, which will be jointly trained with BERT but with an additional $\\ell _ { 1 }$ regularization to promote sparsity. ",
+        "bbox": [
+            174,
+            775,
+            825,
+            873
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Some studies (Michel et al., 2019; Voita et al., 2019) find that the multi-head self-attention module of transformer can be redundant sometimes, presenting the possibility of pruning some heads from each layer of BERT without hurting model capacity. A multi-head attention module (Vaswani et al., 2017) is formulated as: ",
+        "bbox": [
+            176,
+            102,
+            823,
+            159
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a35b133c3a1d9c0ebf94e074c1c0623edb99f2100f2b85e26aa165f546e97ebf.jpg",
+        "text": "$$\n\\begin{array} { r } { \\begin{array} { r l } & { \\mathrm { M u l t i H e a d } ( Q , K , V ) = \\mathrm { C o n c a t } ( \\mathrm { h e a d } _ { 1 } , \\dots , \\mathrm { h e a d } _ { h } ) W ^ { O } } \\\\ & { ~ \\mathrm { w h e r e ~ h e a d } _ { i } = \\mathrm { A t t e n t i o n } ( Q W _ { i } ^ { Q } , K W _ { i } ^ { K } , V W _ { i } ^ { V } ) , } \\end{array} } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            299,
+            165,
+            697,
+            207
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where the projections $W ^ { O } , W _ { i } ^ { Q } , W _ { i } ^ { K } , W _ { i } ^ { V }$ are used for output, query, key and value. Inspired by Liu et al. (2017), we introduce a set of scalar coefficients $c _ { i } ^ { h }$ ( $_ i$ is the index of attention heads and $h$ means “head”) inside ${ \\mathrm { h e a d } } _ { i }$ : ",
+        "bbox": [
+            174,
+            212,
+            823,
+            258
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0686bd7592ace8448db1e874696f97cd51c5f399cc14fcf348875e9a10c45b54.jpg",
+        "text": "$$\n\\mathrm { h e a d } _ { i } = c _ { i } ^ { h } \\cdot \\mathrm { A t t e n t i o n } ( Q W _ { i } ^ { Q } , K W _ { i } ^ { K } , V W _ { i } ^ { V } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            336,
+            265,
+            658,
+            285
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "After the self-attention sub-layer in each transformer layer, the output $\\mathrm { M u l t i H e a d } ( Q , K , V )$ will be fed into a two-layer fully-connected network, in which the first layer increases the dimension of the embedding by 4 times and then reduces it back to the hidden size (768 for BERTBASE and 1,024 for BERTLARGE). We multiply learnable coefficients to the intermediate neurons: ",
+        "bbox": [
+            174,
+            297,
+            825,
+            356
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ffade6a2c9d53a95e768e6b600c3dc6398515184978cf8b755bff17f1128b5b0.jpg",
+        "text": "$$\n\\mathrm { F F N } ( x ) = c ^ { f } \\cdot \\operatorname* { m a x } ( 0 , x W _ { 1 } + b _ { 1 } ) W _ { 2 } + b _ { 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            351,
+            361,
+            647,
+            381
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "These modifications allow us to jointly train BERT with the coefficients, using the following loss: ",
+        "bbox": [
+            173,
+            393,
+            810,
+            410
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9589a58b99007c0ecbdc2f2f4ed9868e1290c3269f33f985f6b1613912ffcaa3.jpg",
+        "text": "$$\n\\mathcal { L } ( f ( \\cdot ; \\theta ) , c ) = \\mathcal { L } _ { 0 } ( f ( \\cdot ; \\theta ) , c ) + \\lambda \\| c \\| _ { 1 } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            369,
+            415,
+            627,
+            433
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathcal { L } _ { 0 }$ is the original loss function used in pre-training or fine-tuning, $c$ is the concatenation of all the coefficients in the model including those for attention heads and intermediate neurons, and $\\lambda$ is the hyper-parameter that controls the strength of regularization. ",
+        "bbox": [
+            176,
+            439,
+            823,
+            482
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note that in this step, the joint training of BERT and the coefficients are still as expensive as normal BERT training. However, the winning strategy of EarlyBERT is that we only need to perform this joint training for a few steps, before the winning ticket emerges, which is much shorter than the full training process of pre-training or fine-tuning. In other words, we can identify the winning tickets at a very low cost compared to the full training. Then, we draw the ticket (i.e., the EarlyBERT), reset the parameters and train EarlyBERT that is computationally efficient thanks to its structured sparsity. Next, we introduce how we draw EarlyBERT from the learned coefficients. ",
+        "bbox": [
+            174,
+            488,
+            825,
+            585
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Ticket-drawing Stage After training BERT and coefficients $c$ jointly, we draw EarlyBERT using the learned coefficients with a magnitude-based metric. Note that we prune attention heads and intermediate neurons separately, as they play different roles in BERT. ",
+        "bbox": [
+            174,
+            601,
+            825,
+            643
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We prune the attention heads whose coefficients have the smallest magnitudes, and remove them from the computation graph. We also prune the rows in $W ^ { O }$ (see Eqn. (1)) that correspond to the removed heads. Note that this presents a design choice: should we prune the heads globally or layer-wisely? In this paper, we use layer-wise pruning for attention heads, because the number of heads in each layer is very small (12 for BERTBASE and 16 for BERTLARGE). We observe empirically that if pruned globally, the attention heads in some layers may be completely removed, making the network un-trainable. Furthermore, Ramsauer et al. (2020) observes that attention heads in different layers exhibit different behaviors. This also motivates us to only compare importance of attention heads within each layer. ",
+        "bbox": [
+            174,
+            650,
+            825,
+            776
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Similar to pruning attention heads, we prune intermediate neurons in the fully-connected sub-layers. Pruning neurons is equivalent to reducing the size of intermediate layers, which leads to a reduced size of the weight matrices $W _ { 1 }$ and $W _ { 2 }$ in Eqn. (4). Between global and layer-wise pruning, empirical analysis shows that global pruning works better. We also observe that our algorithm naturally prunes more neurons for the later layers than earlier ones, which coincides with many pruning works on vision tasks. We leave the analysis of this phenomenon as future work. ",
+        "bbox": [
+            174,
+            782,
+            825,
+            866
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Efficient-training Stage We then train EarlyBERT that we have drawn for pre-training or finetuning depending on the target task. If we apply EarlyBERT to pre-training, the initialization $\\theta _ { 0 }$ of BERT will be a random initialization, the same setting as the original LTH (Frankle & Carbin, 2019) ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "and Early-Bird Tickets (You et al., 2020a). If we apply EarlyBERT to fine-tuning, then $\\theta _ { 0 }$ can be any pre-trained model. We can also moderately reduce the training steps in this stage without sacrificing performance, which is empirically supported by the findings in Frankle & Carbin (2019); You et al. (2020a) that the winning tickets can be trained more effectively than the full model. In practice, the learning rate can also be increased to speed up training, in addition to reducing training steps. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Different from unstructured pruning used in LTH and many other compression works (Frankle & Carbin, 2019; Chen et al., 2020), structurally pruning attention heads and intermediate neurons in fully-connected layers can directly reduce the number of computations required in the transformer layer, and shrink the matrix size of the corresponding operations, yielding a direct reduction in computation and memory costs. ",
+        "bbox": [
+            174,
+            180,
+            825,
+            251
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 VALIDATION OF EARLYBERT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            268,
+            419,
+            282
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Early Emergence Following a similar manner in You et al. (2020a), we visualize the normalized mask distance between different training steps, to validate the early emergence of winning tickets. In Figure 1, the axes in the plots are the number of training steps finished. We only use one fullyconnected sub-layer to plot Figure 1(b),1(d) due to high dimensionality. In both pre-training and fine-tuning, the mask converges in a very early stage of the whole training process. Although we observe an increase of mask distance in fully-connected layers during pre-training (in Figure 1(b)), this can be easily eliminated by early stopping and using mask distance as the exit criterion. ",
+        "bbox": [
+            174,
+            295,
+            825,
+            393
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Non-trivial Sub-network Here, by non-trivial we mean that with the same sparsity ratio as in EarlyBERT, randomly pruned model suffers from significant performance drop. The performance drop happens even if we only prune attention heads. We verify this by running fine-tuning experiments on BERTBASE. Specifically, we prune 4 heads from each transformer layer in BERTBASE and EarlyBERT. We finetune BERTBASE for 3 epochs with an ini",
+        "bbox": [
+            174,
+            410,
+            436,
+            575
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/a62b7474a12d993e929c82a36a5607c9fb4d05b3c43c442ac398999ab35bb7b9.jpg",
+        "table_caption": [
+            "Table 1: Comparison between randomly-pruned models and EarlyBERT on 4 GLUE tasks. We prune 4 heads in each layer. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Methods</td><td>MNLI</td><td>QNLI</td><td>QQP</td><td>SST-2</td></tr><tr><td>BERTBASE</td><td>83.16</td><td>90.59</td><td>90.34</td><td>91.70</td></tr><tr><td>EarlyBERTBASE</td><td>83.58</td><td>90.33</td><td>90.41</td><td>92.09</td></tr><tr><td>Random</td><td>82.26</td><td>88.87</td><td>90.12</td><td>91.17</td></tr></table>",
+        "bbox": [
+            449,
+            479,
+            815,
+            553
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "tial learning rate $2 \\times \\mathrm { i 0 ^ { - 5 } }$ . We run the searching stage for 0.2 epochs with $\\lambda = 1 \\times 1 0 ^ { - 4 }$ , draw EarlyBERT with pruning ratio $\\rho = 1 / 3$ , and then fine-tune EarlyBERT for 2 epochs with doubled initial learning rate. For the randomly pruned models, we randomly prune 4 heads in each layer and follow the same fine-tuning protocol as EarlyBERT. The reported results of randomly pruned models are the average of 5 trials with different seeds for pruning. The results on three tasks from GLUE benchmark (Wang et al., 2018) presented in Table 1 show that randomly pruned model consistently under-performs EarlyBERT with a significant gap, supporting our claim that EarlyBERT indeed identifies non-trivial sub-structures. ",
+        "bbox": [
+            174,
+            575,
+            825,
+            686
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            708,
+            326,
+            724
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 EXPERIMENTAL SETTING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            741,
+            392,
+            755
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Backbone Models Following the official BERT implementation (Devlin et al., 2018; Wolf et al., 2019), we use both BERTBASE (12 transformer layers, hidden size 768, 3,072 intermediate neurons, 12 self-attention heads per layer, 110M parameters in total) and BERTLARGE (24 transformer layers, hidden size 1,024, 4,096 intermediate neurons, 16 self-attention heads per layer, 340M parameters in total) for experiments. ",
+        "bbox": [
+            174,
+            767,
+            825,
+            837
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Datasets We use English Wikipedia (2,500M words) as the pre-training data. For fine-tuning experiments and evaluation of models in the pre-training experiments, we use tasks from GLUE benchmark (Wang et al., 2018) and a question-answering dataset SQuAD v1.1 (Rajpurkar et al., 2016). Note that as our goal is efficient pre-training and fine-tuning, we focus on larger datasets from GLUE (MNLI, QNLI, QQP and SST-2), as it is less meaningful to discuss efficient training on very small datasets. We use the default training settings for pre-training and fine-tuning on both models. To evaluate model performance, we use Matthew’s correlation score for CoLA, matched accuracy for MNLI, F1-score for SQuAD v1.1, and accuracy in percentage for other tasks on GLUE. We omit $\\%$ symbols in all the tables on accuracy results. ",
+        "bbox": [
+            174,
+            853,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/1ce7350e9d25cc7c12f257190fb0e0b767d241696732391e5ea24cf192a1a54a.jpg",
+        "image_caption": [
+            "Figure 1: Illustration of Mask Distance. Top: mask distance observed in pre-training. Bottom: mask distance observed in fine-tuning. The color represents the normalized mask distance between different training steps. The darker the color, the smaller the mask distance. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            254,
+            106,
+            728,
+            415
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            502,
+            825,
+            559
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Implementation Details For the vanilla BERT, we fine-tune on GLUE datasets for 3 epochs with initial learning rate $2 \\times 1 0 ^ { - 5 }$ , and for 2 epochs on SQuAD with initial learning rate $\\mathrm { { \\bar { 3 } } \\times 1 0 ^ { - 5 } }$ ; we use AdamW (Loshchilov & Hutter, 2017) optimizer for both cases. For pre-training, we adopt LAMB optimization technique (You et al., 2020b), which involves two phases of training: the first 9/10 of the total training steps uses a sequence length of 128, while the last 1/10 uses a sequence length of 512. Pre-training by default has 8,601 training steps and uses $6 4 \\mathrm { k } / 3 2 \\mathrm { k }$ batch sizes and $6 \\times \\mathrm { { 1 0 ^ { - 3 } } / 4 \\times 1 0 ^ { - 3 } }$ initial learning rates for the two phases, respectively. All experiments are run on 16 NVIDIA V100 GPUs. ",
+        "bbox": [
+            174,
+            577,
+            825,
+            688
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 EXPERIMENTS ON FINE-TUNING ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            708,
+            437,
+            723
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The main results of EarlyBERT in fine-tuning are presented in Table 2. When drawing EarlyBERT, we prune 4 heads in each layer from BERTBASE and 6 heads from BERTLARGE, and globally prune $40 \\%$ intermediate neurons in fully-connected sub-layers in both models. We reduce the training epochs to two on GLUE benchmark and scale up the learning rate by 2 to buffer the effect of reduced epochs. For SQuAD dataset, we keep the default setting, as we find SQuAD is more sensitive to the number of training epochs. Ablation studies on the effects of the number of training epochs and learning rate are included in the following section. ",
+        "bbox": [
+            174,
+            734,
+            825,
+            833
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Several observations can be drawn from Table 2. Firstly, in most tasks, EarlyBERT saves over $40 \\%$ of the total training time without inducing much performance degradation. It can also outperform another strong baseline LayerDrop (Fan et al., 2019), which drops one third of the layers so that the number of remaining parameters are comparable to ours. Note that LayerDrop models are fine-tuned for three full epochs, yet EarlyBERT is still competitive in most cases. Secondly, we consistently observe obvious performance advantage of EarlyBERT over randomly pruned models, which provides another strong evidence that EarlyBERT does discover nontrivial key sparse structures. Even though there still exists a margin between EarlyBERT and the baseline (like (You et al., 2020a) also observed similarly in their tasks), the existence of structured winning tickets and its potential for efficient training is highly promising. We leave as future work to discover winning tickets of higher sparsity but better quality. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/aee561a7808fd1d4442241d193f773024255fd54639f7d11be2be8dcb6bb2639.jpg",
+        "table_caption": [
+            "Table 2: Performance of EarlyBERT (fine-tuning) compared with different baselines. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Methods</td><td>MNLI</td><td>QNLI</td><td>QQP</td><td>SST-2</td><td>SQuAD</td><td>Time Saved2</td></tr><tr><td>BERTBASE</td><td>83.16</td><td>90.59</td><td>90.34</td><td>91.70</td><td>87.50</td><td>1</td></tr><tr><td>EarlyBERTBASE</td><td>81.81</td><td>89.18</td><td>90.06</td><td>90.71</td><td>86.13</td><td>40~45%</td></tr><tr><td>RandomBASE</td><td>79.92</td><td>84.46</td><td>89.42</td><td>89.68</td><td>84.47</td><td>45~50%</td></tr><tr><td>LayerDrop (Fan et al., 2019)</td><td>81.27</td><td>88.91</td><td>88.06</td><td>89.89</td><td>84.25</td><td>~33%</td></tr><tr><td>BERTLARGE</td><td>86.59</td><td>92.29</td><td>91.59</td><td>92.21</td><td>90.76</td><td>1</td></tr><tr><td>EarlyBERTLARGE</td><td>85.13</td><td>89.22</td><td>90.64</td><td>90.94</td><td>89.45</td><td>35~40%</td></tr><tr><td>RandomLARGE</td><td>78.45</td><td>84.46</td><td>89.89</td><td>88.65</td><td>88.79</td><td>40~45%</td></tr><tr><td>LayerDrop (Fan et al., 2019)</td><td>85.12</td><td>91.12</td><td>88.88</td><td>89.97</td><td>89.44</td><td>~33%</td></tr></table>",
+        "bbox": [
+            187,
+            102,
+            810,
+            251
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            275,
+            825,
+            344
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Ablation Studies on Fine-tuning We perform extensive ablation studies to investigate important hyperparameter settings in EarlyBERT, using EarlyBERTBASE as our testing bed. For all experiments, we use the average accuracy on the larger datasets from GLUE benchmark (MNLI, QNLI, QQP and SST-2) as the evaluation metric. ",
+        "bbox": [
+            174,
+            359,
+            823,
+            416
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "• Number of training epochs and learning rate. We first investigate whether we can properly reduce the number of training epochs, and if scaling the learning rate can help compliment the negative effect caused by reducing training steps. Results in Figure 2 show that when we fine-tune EarlyBERT for fewer epochs on GLUE benchmark, up-scaling learning rate first helps to recover performance, and then causes decrease again. We will use two epochs and $4 \\times 1 0 ^ { - 5 }$ as learning rate for EarlyBERT on GLUE experiments. ",
+        "bbox": [
+            174,
+            428,
+            825,
+            511
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "• Regularization strength $\\lambda .$ . A proper selection of the regularization strength $\\lambda$ decides the quality of the winning ticket, consequently the performance of EarlyBERT after pre-training/finetuning. Results on different strength settings in Table 3 show that the regularization strength $\\lambda$ has marginal influence on EarlyBERT performance. We use $\\lambda = 1 0 ^ { - 4 }$ that achieves the best performance in following experiments. ",
+        "bbox": [
+            174,
+            515,
+            825,
+            585
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "• Pruning ratios $\\rho$ . We further investigate the effects of different pruning ratios as well as layerwise/global pruning on the performance of EarlyBERT. As discussed in Sec. 3.2, we only consider layer-wise pruning for self-attention heads. Table 4 shows that the performance monotonically decreases when we prune more self-attention heads from BERT; however, we see a slight increase and then a sharp decrease in accuracy, when the pruning ratio is raised for intermediate neurons in fully-connected sub-layers $4 0 \\%$ pruning ratio seems to be the sweet spot). We also observe consistent superiority of global pruning over layer-wise pruning for intermediate neurons. ",
+        "bbox": [
+            174,
+            589,
+            825,
+            688
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 EXPERIMENTS ON PRE-TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            708,
+            446,
+            723
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We also conduct pre-training experiments and present the main results in Table 5. Similar to the settings in fine-tuning experiments, we prune 4 heads in each layer from BERTBASE and 6 heads from BERTLARGE; however, we prune slightly fewer $( 3 0 \\% )$ intermediate neurons in fully-connected sublayers in both models, since we empirically observe that pre-training is more sensitive to aggressive intermediate neuron pruning. In both phases of pre-training, we reduce the training steps to $80 \\%$ of the default setting when training EarlyBERT (based on the ablation study shown in Figure 3). Other hyperparameters for pre-training follow the default setting described in Sec. 4.1. All models are fine-tuned and evaluated on GLUE (Wang et al., 2018) and SQuAD v1.1 datasets (Rajpurkar et al., 2016) with the default setting. Since we observe that the randomly pruned models do not competitive performance in fine-tuning experiment for all downstream tasks, in this section we focus on comparing the achievable performance EarlyBERT with full BERT baseline. ",
+        "bbox": [
+            173,
+            734,
+            825,
+            887
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/53de4ee25232c6cf199cce8940f110e70ffbc7fd00618b608cf818901a60568a.jpg",
+        "image_caption": [
+            "Figure 2: Effect of reducing training epochs and up-scaling learning rate for EarlyBERT in fine-tuning. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            103,
+            459,
+            247
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/d763d76b91bea97959860f9ade1812302fa33cf1a65a0ec7b0fdccf428ed02aa.jpg",
+        "table_caption": [
+            "Table 3: Ablation of regularization strength $\\lambda$ . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>入</td><td>10-4</td><td>10-3</td><td>10-2</td></tr><tr><td>Avg. Acc.</td><td>89.10</td><td>88.81</td><td>88.93</td></tr></table>",
+        "bbox": [
+            508,
+            121,
+            766,
+            165
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/72a7fa335f81f15dc03baac19fc143164f46e85fe5348b69aacf8036ee68f225.jpg",
+        "table_caption": [
+            "Table 4: Ablation of pruning ratios on self-attention heads and intermediate neurons. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>#Pruned Heads</td><td>4</td><td>5</td><td>6</td></tr><tr><td>Layer-wise pruning</td><td>89.10</td><td>88.69</td><td>88.26</td></tr><tr><td># Pruned Neurons</td><td>30%</td><td>40%</td><td>50%</td></tr><tr><td> Layer-wise pruning</td><td>88.33</td><td>88.48</td><td>87.91</td></tr><tr><td>Global pruning</td><td>88.54</td><td>88.70</td><td>88.01</td></tr></table>",
+        "bbox": [
+            477,
+            208,
+            799,
+            310
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/6d90d5128f18a4c0fe46d5f81b82933303b50dfecd75802441eed8df9dafc4d5.jpg",
+        "table_caption": [
+            "Table 5: Performance of EarlyBERT (pre-training) compared with BERT baselines. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Methods</td><td>CoLA</td><td>MNLI</td><td>MRPC</td><td>QNLI</td><td>QQP</td><td>RTE</td><td>SST-2</td><td>SQuAD</td></tr><tr><td>BERTBASE</td><td>0.45</td><td>81.40</td><td>84.07</td><td>89.86</td><td>89.80</td><td>60.29</td><td>90.48</td><td>87.60</td></tr><tr><td>EarlyBERTBASE</td><td>0.41</td><td>79.97</td><td>80.39</td><td>89.86</td><td>89.44</td><td>61.01</td><td>90.94</td><td>85.48</td></tr><tr><td>BERTLARGE</td><td>0.50</td><td>83.56</td><td>85.90</td><td>90.44</td><td>90.45</td><td>59.93</td><td>92.55</td><td>90.43</td></tr><tr><td>EarlyBERTLARGE</td><td>0.47</td><td>82.54</td><td>85.54</td><td>90.46</td><td>90.38</td><td>61.73</td><td>91.51</td><td>89.36</td></tr></table>",
+        "bbox": [
+            184,
+            348,
+            812,
+            440
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "From the results presented in Table 5, we can see that on downstream tasks with larger datasets such as QNLI, QQP and SST-2 we can achieve accuracies that are close to BERT baseline (within $1 \\%$ accuracy gaps except for EarlyBERTBASE on MNLI and SQuAD). However, on downstream tasks with smaller learning rate, the patterns are not consistent: we observe big drops on CoLA and MRPC but improvement on RTE. Overall, EarlyBERT achieves comparable performance while saving $30 \\sim 3 5 \\%$ training time thanks to its structured sparsity and reduction in training steps. ",
+        "bbox": [
+            173,
+            467,
+            825,
+            550
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Reducing Training Steps in Pre-training We investigate whether EarlyBERT, when non-essential heads and/or intermediate neurons are pruned, can train more efficiently, and whether we can reduce the number of training steps in pre-training. This can further help reduce training cost in addition to the efficiency gain from pruning. We use EarlyBERTBASESelf (only self-attention heads are pruned when drawing the winning ticket) as the testing bed. Figure 3 shows the performance decreases more when we reduce the number of training steps to $60 \\%$ or less. Reducing it to $80 \\%$ seems to be a sweet point with the best balance between performance and efficiency. ",
+        "bbox": [
+            174,
+            565,
+            529,
+            746
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/f570bb768b9f42cfb8a25f43111639181bd1f083ab4afa9f6e087c5007461b5e.jpg",
+        "image_caption": [
+            "Figure 3: Effect of reducing training steps in pre-training on EarlyBERTBASE. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            545,
+            569,
+            815,
+            709
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            766,
+            318,
+            782
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we present EarlyBERT, an efficient training framework for large-scale language model pre-training and fine-tuning. Based on Lottery Ticket Hypothesis, EarlyBERT identifies structured winning tickets in an early stage, then uses the pruned network for efficient training. Experimental results on GLUE and SQuAD demonstrate that the proposed method is able to achieve comparable performance to standard BERT with much less training time. Future work includes applying EarlyBERT to other pre-trained language models and exploring more data-efficient strategies to enhance the current training pipeline. ",
+        "bbox": [
+            174,
+            797,
+            825,
+            896
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            287,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Tianlong Chen, Jonathan Frankle, Shiyu Chang, Sijia Liu, Yang Zhang, Zhangyang Wang, and Michael Carbin. The lottery ticket hypothesis for pre-trained bert networks, 2020. ",
+        "bbox": [
+            173,
+            126,
+            823,
+            155
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. arXiv preprint arXiv:1810.04805, 2018. ",
+        "bbox": [
+            169,
+            165,
+            823,
+            194
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Utku Evci, Trevor Gale, Jacob Menick, Pablo Samuel Castro, and Erich Elsen. Rigging the lottery: Making all tickets winners. In MLSys, pp. 471–481. 2020. ",
+        "bbox": [
+            171,
+            203,
+            821,
+            233
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Angela Fan, Edouard Grave, and Armand Joulin. Reducing transformer depth on demand with structured dropout. arXiv preprint arXiv:1909.11556, 2019. ",
+        "bbox": [
+            169,
+            242,
+            823,
+            272
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Frankle and Michael Carbin. The lottery ticket hypothesis: Finding sparse, trainable neural networks. In ICLR, 2019. ",
+        "bbox": [
+            173,
+            281,
+            823,
+            310
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, pp. 770–778, 2016. ",
+        "bbox": [
+            173,
+            320,
+            821,
+            349
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Xiaoqi Jiao, Yichun Yin, Lifeng Shang, Xin Jiang, Xiao Chen, Linlin Li, Fang Wang, and Qun Liu. Tinybert: Distilling bert for natural language understanding. arXiv preprint arXiv:1909.10351, 2019. ",
+        "bbox": [
+            173,
+            358,
+            825,
+            401
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Zhuohan Li, Eric Wallace, Sheng Shen, Kevin Lin, Kurt Keutzer, Dan Klein, and Joseph E. Gonzalez. Train large, then compress: Rethinking model size for efficient training and inference of transformers, 2020. ",
+        "bbox": [
+            173,
+            411,
+            823,
+            454
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Zhuang Liu, Jianguo Li, Zhiqiang Shen, Gao Huang, Shoumeng Yan, and Changshui Zhang. Learning efficient convolutional networks through network slimming. In ICCV, 2017. ",
+        "bbox": [
+            171,
+            464,
+            821,
+            494
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ilya Loshchilov and Frank Hutter. Decoupled weight decay regularization. arXiv preprint arXiv:1711.05101, 2017. ",
+        "bbox": [
+            173,
+            503,
+            823,
+            532
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "J Scott McCarley. Pruning a bert-based question answering model. arXiv preprint arXiv:1910.06360, 2019. ",
+        "bbox": [
+            171,
+            542,
+            823,
+            571
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Paul Michel, Omer Levy, and Graham Neubig. Are sixteen heads really better than one? In NeurIPS, 2019. ",
+        "bbox": [
+            174,
+            580,
+            823,
+            611
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ari Morcos, Haonan Yu, Michela Paganini, and Yuandong Tian. One ticket to win them all: generalizing lottery ticket initializations across datasets and optimizers. In NeurIPS, pp. 4932–4942, 2019. ",
+        "bbox": [
+            173,
+            619,
+            823,
+            662
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sai Prasanna, Anna Rogers, and Anna Rumshisky. When bert plays the lottery, all tickets are winning. arXiv preprint arXiv:2005.00561, 2020. ",
+        "bbox": [
+            171,
+            672,
+            823,
+            703
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, and Peter J Liu. Exploring the limits of transfer learning with a unified text-to-text transformer. arXiv preprint arXiv:1910.10683, 2019. ",
+        "bbox": [
+            176,
+            712,
+            823,
+            755
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Pranav Rajpurkar, Jian Zhang, Konstantin Lopyrev, and Percy Liang. Squad: $1 0 0 { , } 0 0 0 { + }$ questions for machine comprehension of text, 2016. ",
+        "bbox": [
+            169,
+            763,
+            823,
+            794
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Hubert Ramsauer, Bernhard Schafl, Johannes Lehner, Philipp Seidl, Michael Widrich, Lukas Gru- ¨ ber, Markus Holzleitner, Milena Pavlovic, Geir Kjetil Sandve, Victor Greiff, et al. Hopfield ´ networks is all you need. arXiv preprint arXiv:2008.02217, 2020. ",
+        "bbox": [
+            176,
+            803,
+            823,
+            847
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alex Renda, Jonathan Frankle, and Michael Carbin. Comparing rewinding and fine-tuning in neural network pruning. arXiv preprint arXiv:2003.02389, 2020. ",
+        "bbox": [
+            171,
+            856,
+            823,
+            886
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Victor Sanh, Lysandre Debut, Julien Chaumond, and Thomas Wolf. Distilbert, a distilled version of bert: smaller, faster, cheaper and lighter. arXiv preprint arXiv:1910.01108, 2019. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sheng Shen, Zhen Dong, Jiayu Ye, Linjian Ma, Zhewei Yao, Amir Gholami, Michael W Mahoney, and Kurt Keutzer. Q-bert: Hessian based ultra low precision quantization of bert. In AAAI, pp. 8815–8821, 2020. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "M. Shoeybi, M. Patwary, R. Puri, P. LeGresley, J. Casper, and Bryan Catanzaro. Megatron-lm: Training multi-billion parameter language models using model parallelism. arXiv, 2019. ",
+        "bbox": [
+            171,
+            155,
+            821,
+            184
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014. ",
+        "bbox": [
+            173,
+            193,
+            823,
+            222
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "S. Sun, Yu Cheng, Zhe Gan, and Jingjing Liu. Patient knowledge distillation for bert model compression. In EMNLP, 2019. ",
+        "bbox": [
+            173,
+            229,
+            823,
+            258
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zhiqing Sun, Hongkun Yu, Xiaodan Song, Renjie Liu, Yiming Yang, and Denny Zhou. MobileBERT: a compact task-agnostic BERT for resource-limited devices. In ACL, 2020. ",
+        "bbox": [
+            171,
+            267,
+            823,
+            296
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In NeurIPS, pp. 5998–6008, 2017. ",
+        "bbox": [
+            174,
+            305,
+            823,
+            348
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Elena Voita, David Talbot, Fedor Moiseev, Rico Sennrich, and Ivan Titov. Analyzing multi-head self-attention: Specialized heads do the heavy lifting, the rest can be pruned. arXiv preprint arXiv:1905.09418, 2019. ",
+        "bbox": [
+            173,
+            357,
+            826,
+            400
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alex Wang, Amanpreet Singh, Julian Michael, Felix Hill, Omer Levy, and Samuel R Bowman. Glue: A multi-task benchmark and analysis platform for natural language understanding. arXiv preprint arXiv:1804.07461, 2018. ",
+        "bbox": [
+            173,
+            409,
+            825,
+            452
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ziheng Wang, Jeremy Wohlwend, and Tao Lei. Structured pruning of large language models. arXiv preprint arXiv:1910.04732, 2019. ",
+        "bbox": [
+            173,
+            460,
+            823,
+            489
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Wei Wen, Chunpeng Wu, Yandan Wang, Yiran Chen, and Hai Li. Learning structured sparsity in deep neural networks. In NeurIPS, pp. 2074–2082, 2016. ",
+        "bbox": [
+            173,
+            497,
+            823,
+            527
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Thomas Wolf, Lysandre Debut, Victor Sanh, Julien Chaumond, Clement Delangue, Anthony Moi, Pierric Cistac, Tim Rault, Remi Louf, Morgan Funtowicz, et al. Huggingface’s transformers: ´ State-of-the-art natural language processing. ArXiv, pp. arXiv–1910, 2019. ",
+        "bbox": [
+            176,
+            535,
+            823,
+            579
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ji Xin, Raphael Tang, Jaejun Lee, Yaoliang Yu, and Jimmy Lin. DeeBERT: Dynamic early exiting for accelerating BERT inference. In ACL, pp. 2246–2251, Online, July 2020. Association for Computational Linguistics. ",
+        "bbox": [
+            173,
+            587,
+            825,
+            630
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zhilin Yang, Zihang Dai, Yiming Yang, Jaime Carbonell, Russ R Salakhutdinov, and Quoc V Le. Xlnet: Generalized autoregressive pretraining for language understanding. In NeurIPS, 2019. ",
+        "bbox": [
+            171,
+            638,
+            823,
+            669
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Haoran You, Chaojian Li, Pengfei Xu, Yonggan Fu, Yue Wang, Xiaohan Chen, Richard G. Baraniuk, Zhangyang Wang, and Yingyan Lin. Drawing early-bird tickets: Toward more efficient training of deep networks. In ICLR, 2020a. ",
+        "bbox": [
+            174,
+            676,
+            823,
+            719
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yang You, Jing Li, Sashank Reddi, Jonathan Hseu, Sanjiv Kumar, Srinadh Bhojanapalli, Xiaodan Song, James Demmel, Kurt Keutzer, and Cho-Jui Hsieh. Large batch optimization for deep learning: Training bert in 76 minutes. In ICLR, 2020b. ",
+        "bbox": [
+            176,
+            728,
+            825,
+            771
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Haonan Yu, Sergey Edunov, Yuandong Tian, and Ari S Morcos. Playing the lottery with rewards and multiple languages: lottery tickets in rl and nlp. In ICLR, 2019. ",
+        "bbox": [
+            169,
+            780,
+            823,
+            809
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ofir Zafrir, Guy Boudoukh, Peter Izsak, and Moshe Wasserblat. Q8bert: Quantized 8bit bert. arXiv preprint arXiv:1910.06188, 2019. ",
+        "bbox": [
+            171,
+            818,
+            823,
+            847
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hattie Zhou, Janice Lan, Rosanne Liu, and Jason Yosinski. Deconstructing lottery tickets: Zeros, signs, and the supermask. In NeurIPS, pp. 3597–3607, 2019. ",
+        "bbox": [
+            173,
+            856,
+            823,
+            885
+        ],
+        "page_idx": 9
+    }
+]

parse/train/Ic9vRN3VpZ/Ic9vRN3VpZ_content_list.json

@@ -0,0 +1,1037 @@
+[
+    {
+        "type": "text",
+        "text": "Neo-GNNs: Neighborhood Overlap-aware Graph Neural Networks for Link Prediction ",
+        "text_level": 1,
+        "bbox": [
+            233,
+            122,
+            761,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Seongjun Yun, Seoyoon Kim, Junhyun Lee, Jaewoo Kang∗ , Hyunwoo J. Kim∗ ",
+        "bbox": [
+            227,
+            226,
+            772,
+            241
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Department of Computer Science and Engineering Korea University {ysj5419, sykim45, ljhyun33, kangj, hyunwoojkim}@korea.ac.kr ",
+        "bbox": [
+            284,
+            241,
+            715,
+            281
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            318,
+            535,
+            334
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Graph Neural Networks (GNNs) have been widely applied to various fields for learning over graph-structured data. They have shown significant improvements over traditional heuristic methods in various tasks such as node classification and graph classification. However, since GNNs heavily rely on smoothed node features rather than graph structure, they often show poor performance than simple heuristic methods in link prediction where the structural information, e.g., overlapped neighborhoods, degrees, and shortest paths, is crucial. To address this limitation, we propose Neighborhood Overlap-aware Graph Neural Networks (Neo-GNNs) that learn useful structural features from an adjacency matrix and estimate overlapped neighborhoods for link prediction. Our Neo-GNNs generalize neighborhood overlap-based heuristic methods and handle overlapped multi-hop neighborhoods. Our extensive experiments on Open Graph Benchmark datasets (OGB) demonstrate that Neo-GNNs consistently achieve state-of-the-art performance in link prediction. ",
+        "bbox": [
+            233,
+            349,
+            766,
+            529
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            554,
+            310,
+            571
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Graph-structured data is ubiquitous in a wide range of domains ranging from social network analysis [1, 2, 3] to biology [4, 5, 6, 7] and computer vision [8, 9, 10]. In recent years, numerous variants of Graph neural networks (GNNs) have been proposed for learning representations over graph-structured data. GNNs learn low dimensional representations of nodes or graphs via iterative aggregation of features from neighbors using non-linear transformations. In this manner, GNNs have shown significant improvements over traditional methods, e.g., heuristic methods and embedding-based methods, and achieved state-of-the-art performance on various tasks, such as node classification [11, 12, 13, 14, 15], graph classification [16, 17, 18, 19, 20], and graph generation [21, 22, 23, 24]. ",
+        "bbox": [
+            174,
+            587,
+            825,
+            698
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "However, in link prediction, traditional heuristic methods still show competitive performance compared to GNNs, which often even outperform GNNs. This is because structural information, (e.g., overlapped neighborhoods, degrees, and shortest path), is crucial for link prediction whereas GNNs heavily rely on smoothed node features rather than graph structure. Recently, SEAL [25] has been proposed to consider structural information for link prediction by utilizing the relative distance between the target node pair and their neighborhoods. Nonetheless, SEAL requires the expensive computational cost to apply a GNN independently to an extracted subgraph for each target node pair. ",
+        "bbox": [
+            174,
+            703,
+            825,
+            801
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To address this limitation, we propose Neighborhood Overlap-aware Graph Neural Networks (NeoGNNs) that are designed to consider key structural information regarding links without manual processes. Specifically, instead of using input node features, Neo-GNNs first learn to generate useful structrual features for each node from an adjacency matrix. Then Neo-GNNs measure the existence of links by considering the structural features of overlapped neighbhorhoods via neighbhorhood overlap-aware aggregation scheme. Finally, to consider both structural information and input node features, our proposed model adaptively combines scores from Neo-GNNs and feature-based GNNs in an end-to-end fashion. We show that Neo-GNNs consistently outperform both state-of-the-art GNNs and heuristic methods on four Open Graph Benchmark datasets (OGB) for link prediction. Furthermore, Our Neo-GNNs generalize the neighborhood overlap-based heuristic methods which measure the likelihood of the link based on manually designed structural information of overlapped neighbors. ",
+        "bbox": [
+            174,
+            808,
+            823,
+            877
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            188
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our contributions are as follows: (i) We propose Neighborhood Overlap-aware Graph Neural Networks (Neo-GNNs) that learn useful structural features from an adjacency matrix and estimate overlapped neighborhoods for link prediction. (ii) Neo-GNNs generalize neighborhood overlap-based heuristic methods and handle overlapped multi-hop neighborhoods. (iii) Our extensive experiments on Open Graph Benchmark datasets (OGB) demonstrate that Neo-GNNs consistently achieve state-of-the-art performance in link prediction. ",
+        "bbox": [
+            174,
+            194,
+            825,
+            279
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related Works ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            329,
+            328,
+            347
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Graph Neural Networks. GNNs have been designed to learn node representations by using neural networks on graph topology. Among deep learning based approaches, the message passing scheme is dominantly used in recent studies such as GCN [11], GraphSAGE [26], and GAT [12]. Due to the iterative aggregation step, each node representation vector can have information of neighbor nodes in multi-hop relationships required for downstream tasks. However, there is a limitation of the expressive power that is upper-bounded by the 1-Weisfeiler-Lehman (1-WL) graph isomorphism test. To overcome this limitation, recent works have tried to boost the expressive power of GNNs by augmenting node features with ordering vectors or position-aware vectors [11, 27, 28]. The main purpose of these works is to complement GNNs with structural information which is crucial for prediction tasks. Our study focuses on adaptively incorporating structural information to GNNs for the link prediction task. ",
+        "bbox": [
+            174,
+            381,
+            825,
+            532
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Link Prediction. Link prediction has been studied in various ways. Conventionally, diverse heuristic methods have been proposed for link prediction. They basically measure the scores of given node pairs based on structural information e.g., overlapped neighbors and shortest path, about the pair of nodes. Common neighbors and preferential attachment [29] exploit structural information about one-hop neighbors to compute the score. To consider more than one-hop relationships, second-order heuristic methods (e.g., Adamic-Adar [30] and resource allocation [31]) and higher-order heuristic methods (e.g., Katz [32] , PageRank [33] , and SimRank [34]) have been proposed. Heuristic methods are extremely effective for link prediction. However, they require manually designed structural information for each heuristic method. To overcome this limitation, embedding-based methods have been proposed. They learn node embeddings based on connections between nodes and compute similarity scores using the embeddings. Typically, Matrix factorization [35] learns node embeddings by decomposing an adjacency matrix of the graph. Random walk-based embedding methods such as Deepwalk [36], and node2vec [37] learn node embeddings by applying the Skip-Gram [38] techniques on the random walks. LINK [39] learns to classify the existence of links based on each row in the adjacency matrix, which includes connectivity information. Since the performance of the embedding methods depends on the sparsity of the input graph, it is hard to regard these methods as generalized ones. Recently, with the success of GNNs in learning graph representations, there have been several attempts to apply them to the link prediction task. Typically, GAE and VGAE [40] learn node representations through GCN to reconstruct the input graph in the auto-encoder framework. Based on the GAE, various GNN architectures have been applied to link prediction. On the other hand, SEAL [25] reformulated the link prediction task to the classification of enclosing subgraphs. Instead of directly predicting the link, enclosing graphs are sampled around each target link to compose dataset and SEAL performs the graph classification task. Due to the node labeling step to mark nodes’ different roles in an enclosing subgraph, SEAL has better performance than GAE even though both are GNN-based methods. However, constructing subgraphs is inefficient because it requires a large amount of computation, whereas our model is as efficient as GAE and can consider structural information like SEAL. ",
+        "bbox": [
+            174,
+            540,
+            825,
+            910
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 Methods ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            279,
+            106
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The goal of our framework, Neighborhood Overlap-aware Graph Neural Networks (Neo-GNNs), is to learn useful structural features from an adjacency matrix and estimate overlapped neighbors for link prediction. We begin with defining the basic notions of graph neural networks for link prediction and review neighborhood overlap-based heuristic methods, and then introduce Neo-GNNs. ",
+        "bbox": [
+            174,
+            119,
+            825,
+            176
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 Preliminaries ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            193,
+            307,
+            207
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Notations. Consider an undirected graph $\\mathcal { G } = ( \\nu , \\mathcal { E } )$ with $N$ nodes, where $\\mathcal { V } = \\{ v _ { 1 } , v _ { 2 } , \\ldots , v _ { N } \\}$ represents a set of nodes and $\\mathcal { E } = \\{ e _ { i j } \\ | \\ v _ { i } , v _ { j } \\ \\in \\mathcal { V } \\}$ represents a set of edges where the nodes $v _ { i } , v _ { j } \\in \\mathcal { V }$ are connected. The adjacency matrix $A \\in \\mathbf { R } ^ { N \\times N }$ is defined by $A _ { i j } = 1$ if $e _ { i j } \\in \\mathcal { E }$ and 0 otherwise. The degree matrix $D \\in { \\bf R } ^ { N \\times N }$ is a diagonal matrix defined by $\\begin{array} { r } { D _ { i i } = \\sum _ { j } A _ { i j } } \\end{array}$ . The nodes of $\\mathcal { G }$ have their own feature vectors $\\boldsymbol { x } _ { i } \\in \\mathbf { R } ^ { F }$ $( i \\in \\{ 1 , 2 , \\ldots , N \\} )$ , with $X \\in \\mathbf { R } ^ { N \\times F }$ denoting the collection of such vectors in a matrix form. ",
+        "bbox": [
+            173,
+            217,
+            825,
+            311
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Graph Neural Networks for Link Prediction. Given a graph $\\mathcal { G }$ and a feature matrix $X$ , graph neural networks learn meaningful node representations by an iterative aggregation of transformed representations of neighbor nodes in each $l$ -th GNN layer as follows: ",
+        "bbox": [
+            173,
+            316,
+            823,
+            359
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/033540f4c3584311b5d3bbfe46ef44c32ec0fe226bda81dc02e9b32829ef7fed.jpg",
+        "text": "$$\n\\begin{array} { r } { H ^ { ( l + 1 ) } = \\sigma \\left( \\tilde { A } _ { \\mathrm { G N N } } H ^ { ( l ) } W ^ { ( l ) } \\right) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            392,
+            366,
+            604,
+            393
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\tilde { A } _ { \\mathbf { G N N } } \\in \\mathbf { R } ^ { N \\times N }$ is the adjacency matrix normalized in different ways depending on each GNN architecture (e.g., D˜ − 12 (A + I )D˜ − 12 ), W (l) ∈ Rd(l)×d(l+1) i s a trainable weight matrix, and $H ^ { ( 0 ) }$ is the node feature matrix $X \\in \\mathbf { R } ^ { N \\times F }$ . After stacking $L$ GNN layers, node representations $H ^ { ( L ) }$ are then used to predict existence of each link $( i , j )$ : ",
+        "bbox": [
+            173,
+            400,
+            825,
+            465
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a98d2e91aa48fb0c9aca6618d6340c2072e2f420abafa136c155c9caf0b40ac5.jpg",
+        "text": "$$\n\\hat { y } _ { i j } = \\sigma ( s ( h _ { i } ^ { ( L ) } , h _ { j } ^ { ( L ) } ) ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            419,
+            470,
+            576,
+            494
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $s ( \\cdot , \\cdot )$ is a function, e.g., inner product or MLP, and $h _ { i } ^ { ( L ) }$ is the representation of the node $i$ from $H ^ { ( L ) }$ . ",
+        "bbox": [
+            171,
+            501,
+            825,
+            534
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 Neighborhood Overlap-based Heuristic Methods ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            550,
+            552,
+            566
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Heuristic methods for link prediction measure the score of given node pairs based on structural information about the node pairs, e.g., shortest path, degree, and common neighbors. Although GNNs outperform existing traditional heuristic methods in various graph tasks, in link prediction, since GNNs heavily rely on smoothed node features rather than graph structure, the heuristic methods often show competitive performance compared to GNNs. Especially, neighborhood overlap-based heuristic methods are straightforward yet highly effective, even better than GNN models in several datasets, e.g., ogbl-collab and ogbl-ppa. Typical neighborhood overlap-based heuristic methods are Common Neighbors, Resource Allocation (RA) [31], and Adamic Adar [30]. The Common Neighbors method measures the score of link $( u , v )$ by counting the number of common neighbors between node $u$ and $v$ as ",
+        "bbox": [
+            173,
+            575,
+            826,
+            713
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7201b4ad4a588bc789237fa8ecb032765c1c7d10790f523325a9d390785bb18a.jpg",
+        "text": "$$\n\\mathit { S c N } ( u , v ) = \\left| \\mathcal { N } ( u ) \\cap \\mathcal { N } ( v ) \\right| = \\sum _ { k \\in \\mathcal { N } ( u ) \\cap \\mathcal { N } ( v ) } 1 .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            339,
+            709,
+            658,
+            746
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The Common Neighbors method is simple and effective, but has a limitation that equally weighs the importance of each common neighbor. To solve this issue, several heuristic methods e.g., Resource Allocation, and Adamic-Adar measure the score for the link by considering the importance of each common neighbor. From the intuition that neighbor nodes with lower degrees are more significant, they give more weight to neighbors with lower degrees. Specifically, Resource Allocation (RA) [31] measures the score of link $( u , v )$ by counting the inverse degrees of common neighbors between node $u$ and $v$ as ",
+        "bbox": [
+            173,
+            747,
+            825,
+            844
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f5bad43b5387f62e6e8ec35850a6b61a66f3032123525ac552445be120e54112.jpg",
+        "text": "$$\nS _ { R A } ( u , v ) = \\sum _ { k \\in \\mathcal { N } ( u ) \\cap \\mathcal { N } ( v ) } \\frac { 1 } { d _ { k } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            397,
+            840,
+            601,
+            881
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $d _ { k }$ denotes the degree of node $k$ . Adamic-Adar has a relatively decreased penalty for higher degree compared to RA by using the reciprocal logarithm of common neighbors’ degrees between ",
+        "bbox": [
+            174,
+            883,
+            823,
+            912
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/09c76c16cea1518b521ed316a7261cfcd630e83900e5fe848689b282756ac108.jpg",
+        "image_caption": [
+            "Figure 1: The Neo-GNNs framework for link prediction. Neo-GNNs learn useful structural features from an adjacency matrix and estimate similarity scores based on overlapped neighborhoods. (a) Neo-GNNs first generate the structural feature vector $\\boldsymbol { x } ^ { s t r u c t } \\in \\mathbf { R } ^ { N \\times 1 }$ from an adjacency matrix $A \\in \\mathbf { R } ^ { N \\times N }$ by using Structural feature generator $\\mathcal { F } _ { \\theta }$ , i.e., ${ \\mathcal { F } } _ { \\theta } ( A )$ . Then to consider only features of overlapped neighbors between nodes, (b) Neo-GNNs construct a diagonal matrix $X ^ { s t r u c t } \\in \\mathbf { R } ^ { N \\times N }$ and (c) aggregate the features of multi-hop neighborhoods by multiplying the sum of powers of adjacency matrices, i.e., $\\textstyle \\sum _ { l = 1 } ^ { L } { \\beta ^ { l - 1 } } A ^ { l }$ . Finally, two node representations $Z$ and $H$ , respectively from Neo-GNNs and feature-based GNNs, are used to (d) compute similarity scores and combined adaptively with the learnable parameter $\\alpha$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            95,
+            818,
+            367
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "node $u$ and $v$ as ",
+        "bbox": [
+            174,
+            542,
+            279,
+            556
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/55fab71527d1dbdddf5c03f4662f3734e978f0a62d0e8f9390d132206a7af828.jpg",
+        "text": "$$\nS _ { A A } ( u , v ) = \\sum _ { k \\in \\mathcal { N } ( u ) \\cap \\mathcal { N } ( v ) } \\frac { 1 } { \\log d _ { k } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            383,
+            556,
+            614,
+            595
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "These heuristic methods show comparable performance to GNNs for link prediction. ",
+        "bbox": [
+            173,
+            603,
+            727,
+            619
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "However, they have two limitations. First, each heuristic method uses manually designed structural features of neighborhoods, e.g., 1, $\\textstyle { \\frac { 1 } { d } }$ , $\\frac { 1 } { \\log d }$ . This requires the manual choice by domain experts to select the best heuristic method for each dataset. Second, they only consider structural similarity. While the GNNs do not use graph structures well compared to using node features, heuristic methods cannot utilize the node features for link prediction. ",
+        "bbox": [
+            174,
+            625,
+            825,
+            696
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To address the limitations of both GNNs and heuristic methods, we propose Neighborhood Overlapaware Graph Neural Networks (Neo-GNN), that learn useful structural features from an adjacency matrix and estimate overlapped neighborhoods for link prediction, and adaptively combine with the conventional feature-based GNNs in an end-to-end fashion. ",
+        "bbox": [
+            174,
+            702,
+            825,
+            758
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 Neighborhood Overlap-aware Graph Neural Networks ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            777,
+            594,
+            792
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We now introduce Neighborhood Overlap-aware Graph Neural Networks (Neo-GNNs) for link prediction. We first explain how Neo-GNNs learn and utilize structural information for link prediction and then explain the process of adaptively combining with the feature-based GNNs. ",
+        "bbox": [
+            176,
+            804,
+            823,
+            848
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Neo-GNNs consist of two key components: (1) Structural feature generator and (2) neighborhood overlap-aware aggregation scheme. First, as we discussed in section 3.2, each heuristic method uses manually designed structural features of neighborhoods, 1, $\\textstyle { \\frac { 1 } { d } }$ , $\\frac { 1 } { \\log d }$ . To generalize and learn these structural features, we propose Structural feature generator $\\mathcal { F } _ { \\theta }$ which learns to generate structural features of each node using an only adjacency matrix $A \\in \\mathbf { R } ^ { N \\times N }$ of the graph as ",
+        "bbox": [
+            174,
+            853,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            88,
+            705,
+            107
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0b6e12b22e341a01b1f16ef599f0ce4fa36e3f516c121f1c166363e017715189.jpg",
+        "text": "$$\nx _ { i } ^ { s t r u c t } = \\mathcal { F } _ { \\theta } ( A _ { i } ) = f _ { \\theta _ { n o d e } } \\left( \\sum _ { j \\in \\mathcal { N } _ { i } } f _ { \\theta _ { e d g e } } ( A _ { i j } ) \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            333,
+            112,
+            663,
+            162
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $x _ { i } ^ { s t r u c t }$ is a structural feature value of the node $i$ and $\\mathcal { F } _ { \\theta }$ is a learnable function comprised of two MLPs, $f _ { \\theta _ { n o d e } }$ and $f _ { \\theta _ { e d g e } }$ , for nodes and edges, respectively. That is to say, Neo-GNNs take only an adjacency matrix $A$ as an input to generate the most beneficial structural features. This input adjacency matrix $A$ can be replaced with the combination of powers of adjacency matrices. Now, Structural feature generator $\\mathcal { F } _ { \\theta }$ can generate structural features for each heuristic method. For example, if $f _ { \\theta _ { n o d e } }$ is a reciprocal of the logarithm function, i.e., $\\begin{array} { r } { f ( x ) = \\frac { 1 } { \\log x } } \\end{array}$ , and $f _ { \\theta _ { e d g e } }$ is an identity function, i.e., $f ( x ) = x$ , then Structural feature generator $\\mathcal { F } _ { \\theta }$ can generate the exactly same structural feature as the features used in Adamic-Adar method. ",
+        "bbox": [
+            173,
+            167,
+            826,
+            284
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Based on the generated structural features of each node, the next process is to calculate the similarity score that considers only structural features of overlapped neighbors between given nodes. Note that conventional GNNs cannot compute this score due to two reasons: the normalized adjacency matrix and the lower dimension of hidden representations than the number of nodes (i.e., $d \\ll N$ ). The normalized adjacency matrix hinders GNNs counting a number of neighborhoods and the low dimension makes features of each neighborhoods indistinguishable after aggregation, which cannot detect the neighborhoods overlap. We propose the neighborhood overlap-aware aggregation scheme to calculate neighborhood overlap-aware score. First, to maintain the respective features of each node after aggregation, we construct a diagonal matrix $X ^ { s t r u c t } \\in \\mathbf { R } ^ { N \\times N }$ using the structural feature vector $\\boldsymbol { x } ^ { s t r u c t } \\in \\mathbf { R } ^ { N \\times 1 }$ as ",
+        "bbox": [
+            173,
+            287,
+            826,
+            429
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a3ae2bf7f9efdfa64d0da9fa5757cf38e116c4fbc502174418af45dfb40d7865.jpg",
+        "text": "$$\nX ^ { s t r u c t } = \\mathrm { { d i a g } } ( x ^ { s t r u c t } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            413,
+            428,
+            583,
+            445
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Then, to consider the number of overlapped neighbors, we aggregate features of neighborhoods by multiplying an unnormalized adjacency matrix $A$ as ",
+        "bbox": [
+            174,
+            448,
+            826,
+            477
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/15b8063605c8c88a15a04d109617475b21e6c6cf105b1c9d6a1c9719cbe53a4e.jpg",
+        "text": "$$\nZ = A X ^ { s t r u c t } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            446,
+            482,
+            552,
+            498
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Now, each $i$ -th row vector of $Z , z _ { i }$ , involves all the features of node $i$ ’s neighboring nodes individually. If we compute the inner product of two row vectors in $Z$ , then we can compute the scores with the only overlapped neighborhoods, which equals the sum of square of structural feature values of overlapped neighborhoods, i.e., $\\begin{array} { r } { z _ { i } ^ { T } z _ { j } = \\sum _ { k \\in \\dot { \\mathcal { N } } ( i ) \\cap \\mathcal { N } ( j ) } \\big ( x _ { k } ^ { s t r u c t } \\big ) ^ { 2 } } \\end{array}$ . ",
+        "bbox": [
+            173,
+            506,
+            825,
+            565
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Furthermore, to consider multi-hop overlapped neigbhors, we extend (8) to multi-hop settings as follows: ",
+        "bbox": [
+            176,
+            570,
+            821,
+            597
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/47ecadba0833253e85f77bbd95263361ea62629542a5c85a75265517351e9736.jpg",
+        "text": "$$\nZ = g _ { \\Phi } \\left( \\sum _ { l = 1 } ^ { L } \\beta ^ { l - 1 } A ^ { l } X ^ { s t r u c t } \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            387,
+            594,
+            606,
+            638
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\beta$ denotes a hyper-parameter controlling how much weight is given to close neighbors versus distant neighbors and $g _ { \\Phi }$ is a MLP which controls the scale of representations $Z$ . Since node representations $Z$ are based on only structural information, we compute feature-based node representations H ∈ RN × d 0 using the conventional feature-based GNNs as ",
+        "bbox": [
+            173,
+            640,
+            825,
+            699
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/85abf407f96d50ffc97bc4834e64508569655b971c61afc72df12cf97593c644.jpg",
+        "text": "$$\nH = \\mathbf { G } \\mathbf { N } \\mathbf { N } ( X , \\tilde { A } _ { G N N } ; W ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            405,
+            705,
+            591,
+            724
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $X \\in \\mathbf { R } ^ { N \\times F }$ denotes the raw feature matrix, $\\tilde { A } _ { G N N }$ denotes a normalized adjacency matrix, and $W$ is the parameter for GNNs. Then given a link $( i , j )$ , Neo-GNNs calculate both similarity scores from each representation matrix $Z$ and $H$ and compute the convex combination of two scores by a trainable parameter $\\alpha$ as follows: ",
+        "bbox": [
+            173,
+            731,
+            825,
+            787
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9a5e66409ee98c8a5443a6f2c264b8ed591f31633dba8d40d3451af96b5caa4c.jpg",
+        "text": "$$\n\\hat { y } _ { i j } = \\alpha \\cdot \\sigma ( z _ { i } ^ { T } z _ { j } ) + ( 1 - \\alpha ) \\cdot \\sigma ( s ( h _ { i } , h _ { j } ) ) ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            349,
+            794,
+            647,
+            814
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Based on (12), we jointly train our proposed model and individual models using three standard (binary) cross-entropy losses ",
+        "bbox": [
+            176,
+            819,
+            825,
+            848
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2ba2d8155d020933bdaefb3ab55145da5a9df282cf1426fd452948a9e28ae502.jpg",
+        "text": "$$\n\\mathcal { L } = \\sum _ { ( i , j ) \\in D } \\big ( \\lambda _ { 1 } B C E ( \\hat { y } _ { i j } , y _ { i j } ) + \\lambda _ { 2 } B C E ( \\sigma ( z _ { i } ^ { T } z _ { j } ) , y _ { i j } ) + \\lambda _ { 3 } B C E ( \\sigma ( s ( h _ { i } , h _ { j } ) ) , y _ { i j } ) \\big ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            191,
+            854,
+            777,
+            890
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $B C E ( \\cdot , \\cdot )$ denotes binary cross entropy loss and $\\lambda _ { i }$ are the weights. ",
+        "bbox": [
+            173,
+            896,
+            663,
+            912
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/8636f59bb048449d43106670b4fdfb31c3fe539e7e7cf27743389c66a1fb0bb6.jpg",
+        "table_caption": [
+            "Table 1: Statistics and evaluation metrics of OGB link prediction datasets. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>#Nodes</td><td>#Edges</td><td>Avg. node deg.</td><td>Density</td><td>Split ratio</td><td>Metric</td></tr><tr><td>OGB-PPA</td><td>576,289</td><td>30,326,273</td><td>73.7</td><td>0.018%</td><td>70/20/10</td><td>Hits @100</td></tr><tr><td>OGB-COLLAB</td><td>235,868</td><td>1,285,465</td><td>8.2</td><td>0.0046%</td><td>92/4/4</td><td>Hits @50</td></tr><tr><td>OGB-DDI</td><td>4,267</td><td>1,334,889</td><td>500.5</td><td>14.67%</td><td>80/10/10</td><td>Hits@20</td></tr><tr><td>OGB-CITATION2</td><td>2,927,963</td><td>30,561,187</td><td>20.7</td><td>0.00036%</td><td>98/1/1</td><td>MRR</td></tr></table>",
+        "bbox": [
+            223,
+            116,
+            774,
+            212
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Computational Complexity. Our proposed model uses the $N \\times N$ matrix $X ^ { s t r u c t }$ for neigbhorhood overlap detection, which generally takes $O ( N | \\mathcal { E } | _ { L } )$ computational time to compute node representations $Z$ in (9), where $| \\mathcal { E } | _ { L }$ denotes a number of edges connected up to $L$ -hop. To solve this high complexity issue, we represent matrices $X ^ { s t r u c t }$ and $Z$ as the sparse matrix form and the computational time becomes just $\\bar { O } ( \\vert \\mathcal { E } \\vert _ { L } )$ . Also, as we can pre-compute the set of adjacency matrices $\\{ A ^ { l } \\} _ { l = 1 } ^ { L }$ in (9), thus there is no additional cost to calculate the powers of the adjacency matrix during training and inference. ",
+        "bbox": [
+            173,
+            226,
+            825,
+            325
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            344,
+            312,
+            363
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we evaluate the benefits of our method against state-of-the-art models on link prediction benchmarks. Then we analyze the contribution of each component in Neo-GNNs and show how Neo-GNNs can actually generalize and learn neighborhood overlap-based heuristic methods. ",
+        "bbox": [
+            176,
+            377,
+            823,
+            420
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 Experiment Settings ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            436,
+            354,
+            452
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Datasets. We evaluate the effectiveness of our Neo-GNNs for link prediction on Open Graph Benchmark datasets [41] (OGB) : OGB-PPA, OGB-Collab, OGB-DDI, OGB-Citation2. Note that OGB-Collab contains multiple edges. Detailed statistics of each dataset are summarized in Table 1. ",
+        "bbox": [
+            174,
+            463,
+            825,
+            505
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Evaluation. The evaluation for link prediction is based on the ranking performance of positive test edges over negative test edges. Specifically, in OGB-PPA, OGB-Collab, OGB-DDI, each model ranks positive test edges against randomly-sampled negative edges, and computes the ratio of positive test edges that are ranked at K-th place or above (Hits $\\ @ \\mathrm { K } )$ . In OGB-Citation2, the evaluation metric is Mean Reciprocal Rank (MRR), where the reciprocal rank of the true link among the negative candidates is calculated for each source node, and then the average is taken over all source nodes. ",
+        "bbox": [
+            174,
+            511,
+            825,
+            594
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Baselines. To demonstrate the effectiveness of our Neo-GNNs in link prediction, we compare Neo-GNNs with three heuristic link prediction methods, three embedding-based methods, and five GNN-based models. For heuristic methods, we used three well-known neighborhood-overlap based heuristic methods, Common Neighbors, Adamic Adar [30], and Resource Allocation [31]. Without learning process, they predict links by utilizing each designed structural information regarding overlapped neighborhoods. For embedding-based methods, we used Matrix Factorization, Node2Vec [42], and Multi-Layer Perceptron (MLP). Furthermore, we compare our method to GNN-based models, GCN [11], GraphSAGE [26], JK-Net [43], GAT [12], and SEAL [25]. GCN, GraphSAGE, JK-Net, and GAT compute representations for each node and predict target links by measuring the similarity score between the source and target node of the target links. SEAL extracts enclosing subgraphs around target links and predict target links based on representations of the enclosing subgraphs as graph classification. ",
+        "bbox": [
+            174,
+            599,
+            825,
+            766
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Implementation Details. We reimplemented neighborhood overlap-based heuristic method,i.e., Common neighbors, Adamic Adar, and Resource allocation from the referenced papers by using PyTorch. For Node2Vec, GCN, GraphSAGE, JK-Net, and GAT, we used the implementation in PyTorch Geometric [44] and the implementation in the official github repository for SEAL. We set the number of layers to 3 and latent dimensionality to 256 for all GNN-based models. To train our method, we used GCN as a feature-based GNN based model and all MLP models in our Neo-GNNs consist of 2 fully connected layers. We jointly trained feature-based GNNs and Neo-GNNs. Since a GNN model requires more epochs for convergence than that of Neo-GNNs on OGB-PPA, and OGB-DDI, we adopted pre-trained GCN to handle this issue. In OGB-Citation2, due to memory issue, we fix the $f _ { \\theta _ { e d g e } }$ as the identity function. For fair comparison, we reported performances of all baselines and our Neo-GNNs as the mean and the standard deviation of performances from 10 independent runs, where each seed is from 0 to 9. The experiments are conducted on a RTX 3090 (24GB) and a Quadro RTX (48GB). ",
+        "bbox": [
+            174,
+            772,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/68f18099b2b4ceab180efde71acaa5b99971ad10de7a15af002150d579377292.jpg",
+        "table_caption": [
+            "Table 2: Link prediction performances $( \\% )$ of our Neo-GNNs and baselines on Open Graph Benchmark (OGB) datasets. Each number is the average performance for 10 random initialization of the experiments. OOM denotes ’out of memory’. Bold indicates the second best performance and underline indicates the best performance. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>OGB-PPA</td><td>OGB-COLLAB</td><td>OGB-DDI</td><td>OGB-CITATION2</td></tr><tr><td>Common Neighbors</td><td>27.65 ± 0.00</td><td>50.06 ±0.00</td><td>17.73 ± 0.00</td><td>76.20±0.00</td></tr><tr><td>Adamic Adar</td><td>32.45 ± 0.00</td><td>53.00 ± 0.00</td><td>18.61 ± 0.00</td><td>76.12 ± 0.00</td></tr><tr><td>Resource Allocation</td><td>49.33 ± 0.00</td><td>52.89 ± 0.00</td><td>6.23± 0.00</td><td>76.20 ± 0.00</td></tr><tr><td>Matrix Factorization</td><td>27.83 ± 2.02</td><td>38.74 ± 0.30</td><td>17.92 ± 3.57</td><td>53.08 ± 4.19</td></tr><tr><td>Node2Vec</td><td>17.24 ± 0.76</td><td>41.36 ± 0.69</td><td>21.95 ± 1.58</td><td>53.47 ± 0.12</td></tr><tr><td>MLP</td><td>0.47± 0.05</td><td>19.98 ± 0.96</td><td>N/A</td><td>28.99 ± 0.16</td></tr><tr><td>GCN</td><td>16.98 ± 1.33</td><td>47.01 ± 0.79</td><td>44.60 ± 8.87</td><td>84.79 ± 0.24</td></tr><tr><td>GraphSAGE</td><td>13.93 ± 2.38</td><td>48.60 ± 0.46</td><td>48.01 ± 9.02</td><td>82.64 ± 0.01</td></tr><tr><td>JK-Net</td><td>11.40 ± 2.04</td><td>48.84 ± 0.83</td><td>57.98 ± 6.88</td><td>OOM</td></tr><tr><td>GAT</td><td>OOM</td><td>44.89 ± 1.23</td><td>29.51 ±6.40</td><td>OOM</td></tr><tr><td>SEAL</td><td>48.15 ± 4.17</td><td>54.37 ± 0.02</td><td>26.25 ±6.00</td><td>86.32 ± 0.52</td></tr><tr><td>Neo-GNN</td><td>49.13 ± 0.60</td><td>57.52 ± 0.37</td><td>63.57 ± 3.52</td><td>87.26 ± 0.84</td></tr></table>",
+        "bbox": [
+            179,
+            154,
+            813,
+            372
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            405,
+            825,
+            446
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 Results on Link Prediction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            470,
+            398,
+            486
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 2 shows link prediction results of the baselines and Neo-GNNs on Open Graph Benchmark (OGB) datasets. We use GCN to adaptively combine with Neo-GNNs across all datasets except OGBCitation2. In OGB-Citation2, since GCN requires 46 GB memory to train, we trained our Neo-GNNs without GCN. As shown in Table 2, we can observe that Neo-GNNs consistently achieve state-ofthe-arts performance across all datasets. Especially, Neo-GNNs show significant improvements on OGB-Collab and OGB-DDI, where the improvements of Neo-GNNs over the best baseline are $5 . 4 \\%$ and $9 . 6 \\%$ , respectively. Furthermore, note that Neo-GNNs achieved state-of-the-art performance in OGB-Citation2 without GCN, that is, by using only graph structures without input node features. Interestingly, conventional feature-based GNNs show poor performance with a huge gap than that of neighborhood overlap-based heuristic methods on OGB-PPA and OGB-Collab. This implies that feature-based GNNs have a difficulty in directly utilizing structural information e.g., degree and overlapped neighbors, for link prediction. According to this implication, Neo-GNNs and SEAL are able to learn structural information, thus these methods accomplish better performance than conventional GNNs do. Moreover, Neo-GNNs and SEAL even show good performance compared to the heuristic methods in all datasets as they can capture structural information that the heuristic methods utilize. Although SEAL shows good performance compared to heuristic methods, SEAL shows poor performance than feature-based GNNs in OGB-DDI. One possible interpretation is that SEAL cannot adaptively utilize the input node features and structural features according to each data. Instead, Neo-GNNs adaptively combine Neo-GNNs and GCN for each dataset using the learnable parameter $\\alpha$ , which shows even higher performance than each performance of Neo-GNNs and GCN. We further analyze the effectiveness of $\\alpha$ in 4.2 ",
+        "bbox": [
+            173,
+            500,
+            826,
+            789
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 Ablation Studies ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            813,
+            328,
+            828
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We present ablation experiments to identify the benefits of different components of Neo-GNNs. First, we evaluate our Neo-GNNs without GCN and examine the effectiveness of the parameter $\\alpha$ that adaptively combine scores from Neo-GNNs and GCN. Then we study the effects of considering multihop overlapped neighborhoods. Specifically, we investigate the effectiveness of two hyper-parameters, the decaying factor $\\beta$ and the maximum hop $L$ , related to multi-hop overlapped neighborhoods. ",
+        "bbox": [
+            174,
+            842,
+            826,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/4015dcd5033375d59724d95ae280868b9c3af9f7e5a671d972018c4928f58654.jpg",
+        "table_caption": [
+            "Table 3: Ablation study analyzing the significance of Neo-GNNs on the OGB-PPA, OGB-Collab, OGB-DDI, and OGB-Citation2 datasets for link prediction. $\\alpha$ denotes the attention weight of Neo-GNNs’ scores. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>α</td><td>Neo-GNN (w/ GCN)</td><td>Neo-GNN (w/o GCN)</td><td>GCN</td></tr><tr><td>PPA</td><td>0.98 ± 0.003</td><td>49.13 ± 0.60</td><td>48.63 ± 0.88</td><td>16.98 ± 1.33</td></tr><tr><td>COLLAB</td><td>0.57 ± 0.130</td><td>57.52 ± 0.37</td><td>55.70 ± 0.24</td><td>47.01 ± 0.79</td></tr><tr><td>DDI</td><td>0.48 ± 0.015</td><td>63.57 ± 3.52</td><td>17.38 ± 4.05</td><td>44.60 ± 8.87</td></tr><tr><td>CITATION2</td><td>N/A</td><td>0OM</td><td>87.26 ± 0.84</td><td>84.79 ± 0.24</td></tr></table>",
+        "bbox": [
+            233,
+            138,
+            759,
+            255
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/19fdc09cfde826ac8942b6d759e51cb35f51a84e97b747f08e2badb452f619b2.jpg",
+        "image_caption": [
+            "Figure 2: Link prediction results on the OGB-Collab dataset by varying the maximum hop $L$ (left) and the decaying factor $\\beta$ (right). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            310,
+            777,
+            474
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Neo-GNNs without GCN. To measure the effectiveness of Neo-GNNs itself, we perform an ablation study on four datasets, as shown in Table 3. We can see that Neo-GNNs (w/o GCN) still show the state-of-the-art performances compared to baselines except OGB-DDI. Note that Neo-GNNs (w/o GCN) only use graph structures and outperform other GNNs whereas other GNNs use both input features and graph structures. This shows that utilizing key structrual information about overlapped neighbors is crucial for link prediction. ",
+        "bbox": [
+            173,
+            491,
+            825,
+            575
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Effectiveness of the parameter $\\alpha$ . To consider both structural information and input features, our proposed model predict similarity scores from the convex combination of two scores from Neo-GNNs and GCN by the trainable parameter $\\alpha$ . As shown in Table 3, $\\alpha$ varies for each dataset, which indicates that $\\alpha$ properly adjusts the weight of structural information and features for each dataset. With the combining process, Neo-GNNs (w/ GCN) consistently show better performance than performances of individual model, i.e., Neo-GNN (w/o GCN) and GCN. Especially, in OGB-DDI, Neo-GNN (w/o GCN) and GCN show less than 50, but the combined model Neo-GNN (w/ GCN) shows $42 \\%$ and $80 \\%$ improved performance compared to each model. ",
+        "bbox": [
+            173,
+            582,
+            825,
+            693
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Effectiveness of multi-hop overlapped neighborhoods. We study the effectiveness of multi-hop overlapped neighborhoods by investigating effects of two hyper-parameters, $L$ and $\\beta$ , on OGB-Collab dataset. First, as shown in Figure 2, if Neo-GNNs only consider 1-hop ovelapped neighbhors, i.e., $L = 1$ , Neo-GNNs converge faster than other cases considering multi-hop overlapped neighbors. However, the best performance is lower than the others, which shows that multi-hop overlapped neighborhoods enhance the performance of Neo-GNNs for link prediction. Second, $\\beta$ controls how much to reduce the effects of neighborhoods when the distance increases. As shown in Figure 2, as $\\beta$ decreases, Neo-GNNs converge slowly but eventually show similar performance. This means that if multi-hop overlapped neighbors are informative, then Neo-GNNs achieve good performance robustly to the value of $\\beta$ . ",
+        "bbox": [
+            174,
+            698,
+            825,
+            837
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.4 Analysis on learning neighborhood overlap-based heuristic methods ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            856,
+            686,
+            871
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "As we discussed in Sec 3.3, our Neo-GNNs generalize several neighborhood overlap-based heuristic methods, (e.g., Common Neighbors, Adamic Adar, and Resource Allocation). Further, in this section, we show that Neo-GNNs (w/o GCN) directly learn each neighbhorhood overlap-based heuristic method and implicitly learn the best one among three heuristic methods on OGB-PPA dataset. We first trained Neo-GNNs to fit the scores from each heuristic method on the train set of OGB-PPA. Then we measure the Spearman correlations by using ranks of test edges from each model. We analyze rank correlations between Neo-GNNs and three heuristic methods based on 50000 sampled test edges in Figure 3. As shown in Figure 3, Neo-GNNs show a strong correlation with other heuristic methods. That is, Neo-GNNs can learn each heuristic method. Next, to show that Neo-GNNs learn the most desirable heuristic method depending on datasets, we compute Spearman correlations between ranks from trained Neo-GNNs on OGB-PPA dataset and the heuristic methods. As a result, correlation scores between Neo-GNNs and Resource Allocation, Adamic Adar, and Common Neighbors are 0.9627, 0.9277, and 0.8982, respectively. We can see that correlation scores are proportional to performances of each heuristic method (49.33, 32.45, and 27.65), which learn the best heuristic method. ",
+        "bbox": [
+            176,
+            883,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            825,
+            270
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/692e5a685e638c68cb8e31f7dbca25df06abc85b6950dcf5f84e9e12d9c99021.jpg",
+        "image_caption": [
+            "Figure 3: Comparison of rank correlation between our Neo-GNNs and three neighborhood overlapbased heuristic methods on OGB-PPA. We evaluate a rank correlation on positive test edges after ranking the entire test edge prediction scores. We visualize a rank correlation using randomly sampled 50,000 positive test edges. The 3(a), 3(b), and 3(c) show rank correlation when Neo-GNNs (w/o GCN) fit to scores of each heuristic method. The 3(d), 3(e), and 3(f) present the rank correlation between Neo-GNNs (w/o GCN) and each heuristic method upon OGB-PPA. The number in parentheses indicates Spearman Correlation coefficient. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            287,
+            812,
+            643
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            784,
+            299,
+            800
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We introduced Neighborhood Overlap-based Graph Neural Networks (Neo-GNNs) that learn and utilize structural information, which is a key element in link prediction. Neo-GNNs learn useful structural features from an adjacency matrix and estimate overlapped neighborhoods for link prediction. We also adaptively combine Neo-GNNs and feature-based GNNs to consider both structural features and input node features. Furthermore, our Neo-GNNs generalize several neigbhorhood overlap-based heuristic methods and handle overlapped multi-hop neigbhorhoods. Extensive experiments on four Open Graph Benchmark (OGB) datasets demonstrate that Neo-GNNs consistently acheive stateof-the-art performance on four OGB datasets in link prediction. In future work, we plan to further develop Neo-GNNs to generalize more link prediction-based heuristic methods and improve the scalability with efficient sparse matrix computation. ",
+        "bbox": [
+            174,
+            814,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            823,
+            133
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Acknowledgement ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            151,
+            359,
+            169
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This work was supported by the following funding sources: National Research Foundation of Korea (NRF-2020R1A2C3010638, NRF-2014M3C9A3063541); ICT Creative Consilience program(IITP2021-2020-0-01819) supervised by the IITP; Samsung Research Funding & Incubation Center of Samsung Electronics under Project Number SRFC-IT1701-51. ",
+        "bbox": [
+            174,
+            183,
+            826,
+            238
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            257,
+            266,
+            273
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[1] Jiezhong Qiu, Jian Tang, Hao Ma, Yuxiao Dong, Kuansan Wang, and Jie Tang. Deepinf: Social influence prediction with deep learning. In Proceedings of the 24th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining (KDD), pages 2110–2119, 2018.   \n[2] Lei Tang and Huan Liu. Graph mining applications to social network analysis. In Managing and Mining Graph Data, pages 487–513. Springer, 2010.   \n[3] Hao Wang, Tong Xu, Qi Liu, Defu Lian, Enhong Chen, Dongfang Du, Han Wu, and Wen Su. Mcne: An end-to-end framework for learning multiple conditional network representations of social network. In Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery Data Mining (KDD), pages 1064–1072, 2019.   \n[4] Nicola De Cao and Thomas Kipf. Molgan: An implicit generative model for small molecular graphs. arXiv preprint arXiv:1805.11973, 2018.   \n[5] David K Duvenaud, Dougal Maclaurin, Jorge Iparraguirre, Rafael Bombarell, Timothy Hirzel, Alan Aspuru-Guzik, and Ryan P Adams. Convolutional networks on graphs for learning molecular fingerprints. In Advances in Neural Information Processing Systems (NeurIPS) 28, pages 2224–2232. Curran Associates, Inc., 2015.   \n[6] Alex Fout, Jonathon Byrd, Basir Shariat, and Asa Ben-Hur. Protein interface prediction using graph convolutional networks. In Advances in Neural Information Processing Systems (NeurIPS) 30, pages 6530–6539. Curran Associates, Inc., 2017.   \n[7] 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, Proceedings of Machine Learning Research, pages 1263– 1272, 2017.   \n[8] Helisa Dhamo, Azade Farshad, Iro Laina, Nassir Navab, Gregory D. Hager, Federico Tombari, and Christian Rupprecht. Semantic image manipulation using scene graphs. In The IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 5213–5222, 2020.   \n[9] Charles R Qi, Hao Su, Kaichun Mo, and Leonidas J Guibas. Pointnet: Deep learning on point sets for 3d classification and segmentation. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 652–660, 2017.   \n[10] Yue Wang, Yongbin Sun, Ziwei Liu, Sanjay E Sarma, Michael M Bronstein, and Justin M Solomon. Dynamic graph cnn for learning on point clouds. Acm Transactions On Graphics (tog), 38(5):1–12, 2019.   \n[11] Thomas N. Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. In International Conference on Learning Representations, 2017.   \n[12] Petar Velickovi ˇ c, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Lio, and Yoshua ´ Bengio. Graph attention networks. arXiv preprint arXiv:1710.10903, 2017.   \n[13] Johannes Klicpera, Stefan Weiß enberger, and Stephan Günnemann. Diffusion improves graph learning. In Advances in Neural Information Processing Systems (NeurIPS) 32, pages 13333–13345. Curran Associates, Inc., 2019.   \n[14] Ming Chen, Zhewei Wei, Zengfeng Huang, Bolin Ding, and Yaliang Li. Simple and deep graph convolutional networks. In Proceedings of the 37th International Conference on Machine Learning (ICML), pages 1725–1735, 2020.   \n[15] Cheng Zheng, Bo Zong, Wei Cheng, Dongjin Song, Jingchao Ni, Wenchao Yu, Haifeng Chen, and Wei Wang. Robust graph representation learning via neural sparsification. In Proceedings of the 37th International Conference on Machine Learning (ICML), pages 11458–11468, 2020.   \n[16] Muhan Zhang, Zhicheng Cui, Marion Neumann, and Yixin Chen. An end-to-end deep learning architecture for graph classification. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 32, 2018.   \n[17] Rex Ying, Jiaxuan You, Christopher Morris, Xiang Ren, William L Hamilton, and Jure Leskovec. Hierarchical graph representation learning with differentiable pooling. arXiv preprint arXiv:1806.08804, 2018.   \n[18] Junhyun Lee, Inyeop Lee, and Jaewoo Kang. Self-attention graph pooling. In Kamalika Chaudhuri and Ruslan Salakhutdinov, editors, Proceedings of the 36th International Conference on Machine Learning. PMLR, 2019.   \n[19] Keyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. How powerful are graph neural networks? arXiv preprint arXiv:1810.00826, 2018.   \n[20] Seongmin Ok. A graph similarity for deep learning. In Advances in Neural Information Processing Systems (NeurIPS) 33, pages 1–12. Curran Associates, Inc., 2020.   \n[21] Wengong Jin, Regina Barzilay, and Tommi Jaakkola. Junction tree variational autoencoder for molecular graph generation. In International Conference on Machine Learning, pages 2323–2332. PMLR, 2018.   \n[22] Wengong Jin, Regina Barzilay, and Tommi Jaakkola. Hierarchical generation of molecular graphs using structural motifs. In Proceedings of the 37th International Conference on Machine Learning (ICML), pages 4839–4848, 2020.   \n[23] Jenny Liu, Aviral Kumar, Jimmy Ba, Jamie Kiros, and Kevin Swersky. Graph normalizing flows. In Advances in Neural Information Processing Systems (NeurIPS) 32, pages 13556–13566. Curran Associates, Inc., 2019.   \n[24] Jiaxuan You, Bowen Liu, Rex Ying, Vijay Pande, and Jure Leskovec. Graph convolutional policy network for goal-directed molecular graph generation. In Advances in Neural Information Processing Systems (NeurIPS) 31, pages 6412–6422. Curran Associates, Inc., 2018.   \n[25] Muhan Zhang and Yixin Chen. Link prediction based on graph neural networks. In Advances in Neural Information Processing Systems, pages 5165–5175, 2018.   \n[26] William Hamilton, Rex Ying, and Jure Leskovec. Inductive representation learning on large graphs. In I. Guyon, U. V. Luxburg, S. Bengio, H. Wallach, R. Fergus, S. Vishwanathan, and R. Garnett, editors, Advances in Neural Information Processing Systems 30, pages 1024–1034. Curran Associates, Inc., 2017.   \n[27] Haggai Maron, Heli Ben-Hamu, Nadav Shamir, and Yaron Lipman. Invariant and equivariant graph networks. In International Conference on Learning Representations, 2018.   \n[28] Jiaxuan You, Rex Ying, and Jure Leskovec. Position-aware graph neural networks. In International Conference on Machine Learning, pages 7134��7143. PMLR, 2019.   \n[29] Albert-László Barabási and Réka Albert. Emergence of scaling in random networks. science, 286(5439):509–512, 1999.   \n[30] Lada A Adamic and Eytan Adar. Friends and neighbors on the web. Social networks, 25(3):211– 230, 2003.   \n[31] Tao Zhou, Linyuan Lü, and Yi-Cheng Zhang. Predicting missing links via local information. The European Physical Journal B, 71(4):623–630, 2009.   \n[32] Leo Katz. A new status index derived from sociometric analysis. Psychometrika, 18(1):39–43, 1953.   \n[33] Sergey Brin and Lawrence Page. Reprint of: The anatomy of a large-scale hypertextual web search engine. Computer networks, 56(18):3825–3833, 2012.   \n[34] Glen Jeh and Jennifer Widom. Simrank: a measure of structural-context similarity. In Proceedings of the eighth ACM SIGKDD international conference on Knowledge discovery and data mining, pages 538–543, 2002.   \n[35] Yehuda Koren, Robert Bell, and Chris Volinsky. Matrix factorization techniques for recommender systems. Computer, 42(8):30–37, 2009.   \n[36] Bryan Perozzi, Rami Al-Rfou, and Steven Skiena. Deepwalk: Online learning of social representations. In Proceedings of the 20th ACM SIGKDD international conference on Knowledge discovery and data mining, pages 701–710, 2014.   \n[37] Jiezhong Qiu, Yuxiao Dong, Hao Ma, Jian Li, Kuansan Wang, and Jie Tang. Network embedding as matrix factorization: Unifying deepwalk, line, pte, and node2vec. In Proceedings of the eleventh ACM international conference on web search and data mining, pages 459–467, 2018.   \n[38] Tomas Mikolov, Kai Chen, Greg Corrado, and Jeffrey Dean. Efficient estimation of word representations in vector space. arXiv preprint arXiv:1301.3781, 2013.   \n[39] Elena Zheleva and Lise Getoor. To join or not to join: The illusion of privacy in social networks with mixed public and private user profiles. In Proceedings of the 18th International Conference on World Wide Web, WWW ’09, page 531–540, 2009.   \n[40] Thomas N Kipf and Max Welling. Variational graph auto-encoders. arXiv preprint arXiv:1611.07308, 2016.   \n[41] Weihua Hu, Matthias Fey, Marinka Zitnik, Yuxiao Dong, Hongyu Ren, Bowen Liu, Michele Catasta, and Jure Leskovec. Open graph benchmark: Datasets for machine learning on graphs. arXiv preprint arXiv:2005.00687, 2020.   \n[42] Aditya Grover and Jure Leskovec. node2vec: Scalable feature learning for networks. In Proceedings of the 22nd ACM SIGKDD international conference on Knowledge discovery and data mining, pages 855–864, 2016.   \n[43] Keyulu Xu, Chengtao Li, Yonglong Tian, Tomohiro Sonobe, Ken-ichi Kawarabayashi, and Stefanie Jegelka. Representation learning on graphs with jumping knowledge networks. In International Conference on Machine Learning, pages 5453–5462. PMLR, 2018.   \n[44] 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,
+            277,
+            826,
+            912
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            32,
+            828,
+            921
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            90,
+            828,
+            670
+        ],
+        "page_idx": 11
+    }
+]

parse/train/_eXwwWOyqT_/_eXwwWOyqT_.md

@@ -0,0 +1,425 @@
+# Practical Large-Scale Linear Programming using Primal-Dual Hybrid Gradient
+
+David Applegate Google Research dapplegate@google.com
+
+Mateo Díaz California Institute of Technology∗ mateodd@caltech.edu
+
+Oliver Hinder   
+Google Research   
+University of Pittsburgh   
+ohinder@pitt.edu
+
+# Haihao Lu
+
+Miles Lubin Google Research mlubin@google.com
+
+University of Chicago† haihao.lu@chicagobooth.edu
+
+Brendan O’Donoghue DeepMind bodonoghue@deepmind.com
+
+Warren Schudy Google Research wschudy@google.com
+
+# Abstract
+
+We present PDLP, a practical first-order method for linear programming (LP) that can solve to the high levels of accuracy that are expected in traditional LP applications. In addition, it can scale to very large problems because its core operation is matrix-vector multiplications. PDLP is derived by applying the primaldual hybrid gradient (PDHG) method, popularized by Chambolle and Pock (2011), to a saddle-point formulation of LP. PDLP enhances PDHG for LP by combining several new techniques with older tricks from the literature; the enhancements include diagonal preconditioning, presolving, adaptive step sizes, and adaptive restarting. PDLP improves the state of the art for first-order methods applied to LP. We compare PDLP with SCS, an ADMM-based solver, on a set of $3 8 3 \ \mathrm { L P }$ instances derived from MIPLIB 2017. With a target of $1 0 ^ { - 8 }$ relative accuracy and 1 hour time limit, PDLP achieves a $6 . 3 \mathrm { x }$ reduction in the geometric mean of solve times and a 4.6x reduction in the number of instances unsolved (from 227 to 49). Furthermore, we highlight standard benchmark instances and a large-scale application (PageRank) where our open-source prototype of PDLP, written in Julia, outperforms a commercial LP solver.
+
+# 1 Introduction
+
+First-order methods (FOMs), which use gradient and not Hessian information, are now applied as standard practice in many areas of optimization [12]. A known weakness of FOMs is the tailing-off effect, where FOMs quickly find moderately accurate solutions, but progress towards an optimal solution slows down over time. While moderately accurate solutions are often sufficient for large machine learning applications, other applications traditionally demand higher precision. One such area is Linear Programming (LP), the focus of this work.
+
+LP is a fundamental class of optimization problems in applied mathematics, operations research, and computer science with a huge range of applications, including mixed-integer programming, scheduling, network flow, chip design, budget allocation, and many others [17, 22, 65, 69]. Software for solving LP problems, called LP solvers, originated in the earliest days of computing, predating the invention of operating systems [55]. The state-of-the-art methods for LP, namely Dantzig’s simplex method [22,23] and interior-point (or barrier) methods [51], are quite mature and reliable at delivering highly accurate solutions. These widely successful methods have left little room for FOMs to make inroads. Furthermore, practitioners who use LP solvers are not accustomed to reasoning about the trade-off between accuracy and computing times typically intrinsic to FOMs.
+
+In this paper, we provide evidence that, if properly enhanced, FOMs can obtain high quality solutions to LP problems quickly. Indeed, there’s reason to expect this, as authors have developed FOMs for LP with linear rates of convergence [24, 32, 47, 70, 71]. On the other hand, the linear rates depend on potentially loose and hard-to-compute constants; hence, tailing off may still be observed in practice. To our knowledge, ours is the first work to combine both theoretical enhancements with practical heuristics, demonstrating their combined effectiveness with extensive computational experiments on standard benchmark instances. In fact, our experiments will expose a substantial gap between algorithms presented in the literature and what’s needed to obtain good performance.
+
+Starting from a baseline primal-dual hybrid gradient (PDHG) method [19] applied to a saddle point formulation of LP, we develop a series of algorithmic improvements. These enhancements include adaptive restarting [7], dynamic primal-dual step size selection [36, 37], presolving techniques [1], and diagonal preconditioning (data equilibration) [33]. Most of these enhancements, while inspired by existing literature, are novel. We name our collection of enhancements PDLP (PDHG for LP).
+
+The impact of these improvements is substantial. For example, on $3 8 3 \mathrm { L P }$ instances derived from the MIPLIB 2017 collection [34], our implementation of a baseline version of PDHG solved only 50 problems to $1 0 ^ { - 8 }$ relative accuracy given a limit of approximately 100,000 iterations per problem. By contrast, PDLP solves 283 of the 383 problems under the same conditions. We demonstrate that PDLP outperforms FOM baselines and, in a small number of cases, obtains performance competitive with a commercial LP solver.
+
+Although not the focus of this paper, we believe that our results open the door to a new set of possibilities and computational trade-offs when solving LP problems. PDLP has the potential to solve extremely large scale instances where the simplex method and interior-point methods are unable to run because of their reliance on matrix factorization. Since PDLP uses matrix-vector operations at its core, it can effectively run on multi-threaded CPUs, GPUs [68], or distributed clusters [26]. Furthermore, a GPU implementation of PDLP could efficiently solve batches of similar problems, a setup that has already been successfully applied with other optimization algorithms in applications like strong branching [46] and training neural networks that contain optimization layers [5].
+
+Outline. The remainder of this section focuses on related work. Section 2 introduces LP and PDHG. Section 3 describes the set of enhancements that define PDLP. Section 4 presents numerical experiments, and Section 5 concludes and outlines future directions.
+
+# 1.1 Literature review
+
+PDHG PDHG was first developed by Zhu and Chan [72], with subsequent analysis and extension by a number of authors [3,18,19,21,27,38,60]. PDHG is closely related to the Arrow-Hurwicz method [8]. PDHG is a form of operator-splitting [11, 64] and can be interpreted as a variant of the alternating directions method of multipliers (ADMM) and Douglas-Rachford splitting (DRS) [16, 25, 56], which themselves are both instantiations of the proximal point method [25, 58, 62]. As opposed to ADMM or DRS, PDHG is ‘matrix-free’ in that the data matrix is only used for matrix-vector multiplications. This allows PDHG to scale to problems even larger than those tackled by these other techniques, and to make better use of parallel and distributed computation.
+
+FOM-based solvers Recent interest in large-scale cone programming has sparked the development several first-order solvers based on competing methods. ProxSDP [66] is a solver for semidefinite programming based on PDHG. Solvers based on Nesterov’s accelerated gradients [49] include TFOCS [14], and FOM which is a suite of solvers employing both gradient and proximal algorithms [13]. Solvers based on operator splitting techniques like ADMM include SCS [52–54], OSQP [67], POGS [28], and COSMO [30]. Of these both SCS and POGS offer a matrix-free implementation where the linear system, that arises from the proximal operator used in ADMM, is solved using the conjugate gradient method. However, we shall show experimentally that our method can be significantly faster and more robust than this approach. Finally, [4] considers applying a truncated semismooth Newton method to the system of equations defining a fixed point of the SCS operator.
+
+FOMs for LP Lan, Lu and Monteiro [40] and Renegar [61] develop FOMs for LP as a special case of semidefinite programming, with sublinear convergence rates. The FOM-based solvers above all apply to more general problem classes like cone programming or quadratic programming. In contrast, some of the enhancements that constitute PDLP are specialized, either in theory or practice, for LP (namely restarts [7] and presolving). A number of authors [24, 32, 47, 70, 71] have proposed linearly convergent FOMs for LP; to our knowledge, none have been subject of a comprehensive computational study. ECLIPSE [10] solves huge-scale industrial LP problems by accelerated gradient descent, without presenting comparisons on standard test problems. Lin et al. [42] propose an ADMM-based interior point method. In contrast with PDLP which solves to high accuracy (i.e., $1 0 ^ { - 8 }$ relative error), [42] perform experiments with $1 0 ^ { - 3 }$ and $1 0 ^ { - 5 }$ relative error. SNIPAL [41] is a semismooth Newton method based on the proximal augmented Lagrangian. SNIPAL has fast asymptotic convergence, yet, to get good performance, the authors use ADMM for warm-starts. Given PDLP’s favorable comparisons with SCS, it’s plausible that PDLP could provide a more effective warm-start. Finally, Pock and Chambolle [59] apply PDHG with diagonal preconditioning to a limited set of test LP problems and Applegate et al. [6] show how to extract infeasibility certificates when applying PDHG to LP.
+
+# 2 Preliminaries
+
+In this section, we introduce the notation we use throughout the paper, summarize the LP formulations we solve, and introduce the baseline PDHG algorithm.
+
+Notation. Let $\mathbb { R }$ denote the set of real numbers, $\mathbb { R } ^ { + }$ the set of nonnegative real numbers, and $\mathbb { R } ^ { - }$ the set of nonpositive real numbers. Let $\mathbb { N }$ denote the set of natural numbers (starting from one). Let $\| \cdot \| _ { p }$ denote the $\ell _ { p }$ norm for a vector, and let $\| \cdot \| _ { 2 }$ denote the spectral norm for a matrix. For a vector $v \in \mathbb { R } ^ { n }$ , we use $v ^ { + }$ and $v ^ { - }$ for their positive and negative parts, i.e., $v _ { i } ^ { + } = \operatorname* { m a x } \{ 0 , v _ { i } \}$ and $v _ { i } ^ { - } = \operatorname* { m i n } \{ 0 , v _ { i } \}$ . The symbol $v _ { 1 : m }$ denotes the vector with the first $m$ components of $v$ . The symbols $K _ { i , }$ ,· and $K _ { \cdot , j }$ correspond to the $i$ th column and $j$ th row of the matrix $K$ , respectively. The symbol 1 denotes the vector of all ones. Given a convex set $X$ , we use $\mathbf { p r o j } _ { X }$ to denote the map that projects onto $X$ .
+
+Linear Programming. We solve primal-dual LP problems of the form:
+
+$$
+{ \begin{array} { r l } & { { \underset { x \in \mathbb { R } ^ { n } } { \mathrm { m i n i m i z e } } } ~ c ^ { \top } x } \\ & { { \mathrm { s u b j e c t ~ t o : } } ~ G x \geq h } \\ & { ~ A x = b } \\ & { ~ l \leq x \leq u } \end{array} }
+$$
+
+$$
+\begin{array} { r l } { \underset { y \in \mathbb { R } ^ { m _ { 1 } + m _ { 2 } } , \lambda \in \mathbb { R } ^ { n } } { \mathrm { m a x i m i z e } } } & { q ^ { \top } y + l ^ { \top } \lambda ^ { + } - u ^ { \top } \lambda ^ { - } } \\ { \mathrm { s u b j e c t ~ t o : } } & { c - K ^ { \top } y = \lambda } \\ & { y _ { 1 : m _ { 1 } } \geq 0 } \\ & { \lambda \in \Lambda ~ , } \end{array}
+$$
+
+where $G \in \mathbb { R } ^ { m _ { 1 } \times n }$ , $\in \mathbb { R } ^ { m _ { 2 } \times n } , c \in \mathbb { R } ^ { n } , h \in \mathbb { R } ^ { m _ { 1 } } , b \in \mathbb { R } ^ { m _ { 2 } } , l \in ( \mathbb { R } \cup \{ - \infty \} ) ^ { n } , u \in ( \mathbb { R } \cup \{ \infty \} ) ^ { n } .$ , $K ^ { \top } = { \left( G ^ { \top } , A ^ { \top } \right) } , q ^ { \top } : = { \left( h ^ { \top } , b ^ { \top } \right) }$ , a nd
+
+$$
+\Lambda = \Lambda _ { 1 } \times \cdot \cdot \times \Lambda _ { n } \quad \Lambda _ { i } : = \left\{ \begin{array} { l l } { \{ 0 \} } & { l _ { i } = - \infty , u _ { i } = \infty , } \\ { \mathbb { R } ^ { - } } & { l _ { i } = - \infty , u _ { i } \in \mathbb { R } } \\ { \mathbb { R } ^ { + } } & { l _ { i } \in \mathbb { R } , u _ { i } = \infty } \\ { \mathbb { R } } & { \mathrm { o t h e r w i s e } } \end{array} \right.
+$$
+
+is the set of variables $\lambda$ such that the dual objective is finite. This pair of primal-dual problems is equivalent to the saddle-point problem:
+
+$$
+\operatorname* { m i n } _ { x \in X } \operatorname* { m a x } _ { y \in Y } { \mathcal { L } } ( x , y ) : = c ^ { \top } x - y ^ { \top } K x + q ^ { \top } y
+$$
+
+with $X : = \{ x \in \mathbb { R } ^ { n } : l \leq x \leq u \}$ , and $Y : = \{ y \in \mathbb { R } ^ { m _ { 1 } + m _ { 2 } } : y _ { 1 : m _ { 1 } } \geq 0 \}$
+
+PDHG. When specialized to (2), the PDHG algorithm takes the form:
+
+$$
+\begin{array} { r l } & { x ^ { k + 1 } = \underset { X } { \mathbf { p r o j } } ( x ^ { k } - \tau ( c - K ^ { \top } y ^ { k } ) ) } \\ & { y ^ { k + 1 } = \underset { Y } { \mathbf { p r o j } } ( y ^ { k } + \sigma ( q - K ( 2 x ^ { k + 1 } - x ^ { k } ) ) ) } \end{array}
+$$
+
+where $\tau , \sigma > 0$ are primal and dual step sizes, respectively. PDHG is known to converge to an optimal solution when $\tau \sigma \| \dot { \boldsymbol { K } } \| _ { 2 } ^ { 2 } \leq 1$ [20, 21]. We reparameterize the step sizes by
+
+$$
+\tau = \eta / \omega \quad \mathrm { a n d } \quad \sigma = \omega \eta \qquad \mathrm { w i t h } \ \eta \in ( 0 , \infty ) \quad \mathrm { a n d } \quad \omega \in ( 0 , \infty ) .
+$$
+
+We call $\omega \in ( 0 , \infty )$ the primal weight, and $\eta \in ( 0 , \infty )$ the step size. Under this reparameterization PDHG converges for all $\eta \leq 1 / \| K \| _ { 2 }$ . This allows us to control the scaling between the primal and dual iterates with a single parameter $\omega$ . We use the term primal weight to describe $\omega$ because it weights the primal variables in the following norm:
+
+$$
+\| z \| _ { \omega } : = \sqrt { \omega \| x \| _ { 2 } ^ { 2 } + \frac { \| y \| _ { 2 } ^ { 2 } } { \omega } } .
+$$
+
+This norm plays a role in the theory for PDHG [20] and later algorithmic discussions.
+
+For the baseline PDHG algorithm that we use for comparisons, we consider two simple choices for $\eta$ and $\omega$ . For the step size, set $\eta = 0 . 9 / \lVert K \rVert _ { 2 }$ where $\| K \| _ { 2 }$ is estimated via power iteration, and for the primal weight we set $\omega = 1$ ; this is similar to the default parameters in the standard PDHG implementation in ODL [2].
+
+# 3 Practical algorithmic improvements
+
+In this section, we detail these enhancements, and defer further experimental testing of them to Section 4 and ablation studies to Appendix C. While our enhancements are inspired by theory, our focus is on practical performance. The algorithm as a whole has no convergence guarantee, although some individual enhancements do; see Section 3.6 for further discussion.
+
+Algorithm 1 presents pseudo-code for PDLP after preprocessing steps. We modify the step sizes (Section 3.1), add restarts (Section 3.2), and dynamically update the primal weights (Section 3.3). Before running Algorithm 1 we apply presolve (Section 3.4) and diagonal preconditioning (Section 3.5). There are some minor differences between the pseudo-code and the actual code. In particular, we only evaluate the restart or termination criteria (Line 10) every 40 iterations. This reduces the associated overheads with minimal impact on the total number of iterations. We also check the termination criteria before beginning the algorithm or if we detect a numerical error.
+
+# Algorithm 1: PDLP (after preconditioning and presolve)
+
+1 Input: An initial solution z0,0;   
+2 Initialize outer loop counter $n \gets 0$ , total iterations $k  0$ , step size $\hat { \eta } ^ { 0 , 0 } \gets 1 / \| K \| _ { \infty }$ , primal   
+weight $\omega ^ { 0 } $ InitializePrimalWeight $( c , q )$ ;   
+3 repeat   
+4 $t \gets 0$ ;   
+5 repeat   
+6 $\begin{array} { r l } & { z ^ { n , t + 1 } , \eta ^ { n , t + 1 } , \hat { \eta } ^ { n , t + 1 } \xleftarrow { \mathrm { A d a p t i v e S t e p } \ 0 \mathrm { f P D H } \mathfrak { G } } ( z ^ { n , t } , \omega ^ { n } , \hat { \eta } ^ { n , t } , k ) : } \\ & { \bar { z } ^ { n , t + 1 } \xleftarrow { \frac { 1 } { \sum _ { i = 1 } ^ { t + 1 } \eta ^ { n , i } } \sum _ { i = 1 } ^ { t + 1 } \eta ^ { n , i } z ^ { n , i } ; } } \\ & { z _ { \mathrm { c } } ^ { n , t + 1 } \xleftarrow { \mathrm { G e t R e s t a r t c a n d i d a t e } ( z ^ { n , t + 1 } , \bar { z } ^ { n , t + 1 } , z ^ { n , 0 } ) } ; } \\ & { t  t + 1 , k  k + 1 ; } \end{array}$   
+7   
+8   
+9   
+10 until restart or termination criteria holds;   
+11 restart the outer loop. $z ^ { n + 1 , 0 } \gets z _ { \mathrm { c } } ^ { n , t }$ , $n \gets n + 1$ ;   
+12 $\omega ^ { n } \gets$ PrimalWeightUpdate $( z ^ { n , 0 } , z ^ { n - 1 , 0 } , \omega ^ { n - 1 } )$ ;   
+13 until termination criteria holds;   
+14 Output: $z ^ { n , 0 }$ .
+
+# 3.1 Step size choice
+
+The convergence analysis [20, Equation (15)] of PDHG (equation (3)) relies on a small constant step size
+
+$$
+\eta \leq \frac { \| z ^ { k + 1 } - z ^ { k } \| _ { \omega } ^ { 2 } } { 2 ( y ^ { k + 1 } - y ^ { k } ) ^ { \top } K ( x ^ { k + 1 } - x ^ { k } ) }
+$$
+
+# Algorithm 2: One step of PDHG using our step size heuristic
+
+Function AdaptiveStepOfPDHG $( z ^ { n , t } , \omega ^ { n } , \hat { \eta } ^ { n , t } , k )$ :   
+2 $( x , y ) \gets z ^ { n , t }$ , $\eta  \hat { \eta } ^ { n , t }$ ;   
+3 for i = 1, . . . , ∞ do   
+4 $\begin{array} { r } { x ^ { \prime }  \mathbf { p r o j } _ { X } ( x - \frac { \eta } { \omega ^ { n } } ( c - K ^ { \top } y ) ) } \end{array}$ ;   
+5 $y ^ { \prime }  \mathbf { p r o j } _ { Y } ( y + \eta \omega ^ { n } ( q - K ( 2 x ^ { \prime } - x ) ) )$ ;   
+6 η¯ ← k(x −x,y −y)k ωn2(y0−y)>K(x0−x) ;   
+7 $\eta ^ { \prime }  \operatorname* { m i n } ( ( 1 - ( k + 1 ) ^ { - 0 . 3 } ) \bar { \eta } , ( 1 + ( k + 1 ) ^ { - 0 . 6 } ) \eta ) ;$   
+8 if $\eta \leq \bar { \eta }$ then   
+9 return $( x ^ { \prime } , y ^ { \prime } ) , \eta , \eta ^ { \prime }$   
+10 end   
+11 $\eta  \eta ^ { \prime }$ ;   
+12 end
+
+where $z ^ { k } = ( x ^ { k } , y ^ { k } )$ . Classically one would ensure (5) by picking $\begin{array} { r } { \eta = \frac { 1 } { \left. K \right. _ { 2 } } } \end{array}$ . This is overly pessimistic and requires estimation of $\| K \| _ { 2 }$ . Instead our AdaptiveStepOfPDHG adjusts $\eta$ dynamically to ensure that (5) is satisfied. If (5) isn’t satisfied, we abort the step; i.e., we reduce $\eta$ , and try again. If (5) is satisfied we accept the step. This is described in Algorithm 2. Note that in Algorithm 2 η¯ ≥ 1kKk2 holds always, and from this one can show the resulting step size $\begin{array} { r } { \eta \geq \frac { 1 - o ( 1 ) } { \| K \| _ { 2 } } } \end{array}$ holds as $k \to \infty$ .
+
+Our step size routine compares favorably in practice with the line search by Malitsky and Pock [43] (See Appendix C.1).
+
+# 3.2 Adaptive restarts
+
+In PDLP, we adaptively restart the PDHG algorithm in each outer iteration. The key to our restarts at the $n$ -th outer iteration is the normalized duality gap at $z$ which for any radius $r \in ( 0 , \infty )$ is defined by
+
+$$
+\rho _ { r } ^ { n } ( z ) : = \frac { 1 } { r } \operatorname* { m a x i m i z e } _ { ( \hat { x } , \hat { y } ) \in \{ \hat { z } \in Z : \| \hat { z } - z \| _ { \omega ^ { n } } \leq r \} } \{ \mathcal { L } ( x , \hat { y } ) - \mathcal { L } ( \hat { x } , y ) \} ,
+$$
+
+introduced by [7]. Unlike the standard duality gap
+
+$$
+\operatorname* { m a x i m i z e } _ { ( { \hat { x } } , { \hat { y } } ) \in Z } \{ { \mathcal { L } } ( x , { \hat { y } } ) - { \mathcal { L } } ( { \hat { x } } , y ) \} ,
+$$
+
+the normalized duality gap is always a finite quantity. Furthermore, for any value of $r$ and $\omega ^ { n }$ , the normalized duality gap $\rho _ { r } ^ { n } ( z )$ is 0 if and only if the solution $z$ is an optimal solution to (2) [7]; thus, it provides a valid metric for measuring progress towards the optimal solution. The normalized duality gap is computable in linear time [7]. For brevity, define $\mu _ { n } ( z , z _ { \mathrm { r e f } } )$ as the normalized duality gap at $z$ with radius $\| z - z _ { \mathrm { r e f } } \| _ { \omega ^ { n } }$ , i.e.,
+
+$$
+\begin{array} { r } { \mu _ { n } ( z , z _ { \mathrm { r e f } } ) : = \rho _ { \parallel z - z _ { \mathrm { r e f } } \parallel _ { \omega ^ { n } } } ^ { n } ( z ) , } \end{array}
+$$
+
+where $z _ { \mathrm { r e f } }$ is a user-chosen reference point.
+
+Choosing the restart candidate. To choose the restart candidate $z _ { \mathrm { c } } ^ { n , t + 1 }$ we call
+
+$$
+( z ^ { n , t + 1 } , \bar { z } ^ { n , t + 1 } , z ^ { n , 0 } ) : = \left\{ \begin{array} { l l } { z ^ { n , t + 1 } } & { \mu _ { n } \big ( z ^ { n , t + 1 } , z ^ { n , 0 } \big ) < \mu _ { n } \big ( \bar { z } ^ { n , t + 1 } , z ^ { n , 0 } \big ) } \\ { \bar { z } ^ { n , t + 1 } } & { \mathrm { o t h e r w i s e } \ . } \end{array} \right.
+$$
+
+This choice is justified in Remark 5 of [7].
+
+Restart criteria. We define three parameters: $\beta _ { \mathrm { s u f f i c i e n t } } \ \in \ ( 0 , 1 ) .$ , $\beta _ { \mathrm { n e c e s s a r y } } ~ \in ~ \left( 0 , \beta _ { \mathrm { s u f f i c i e n t } } \right)$ and $\beta _ { \mathrm { a r t i f i c i a l } } \in ( 0 , 1 )$ . In PDLP we use $\beta _ { \mathrm { s u f f i c i e n t } } = 0 . 9$ , $\beta _ { \mathrm { n e c e s s a r y } } = 0 . 1$ , and $\beta _ { \mathrm { a r t i f i c i a l } } = 0 . 5$ . The algorithm restarts if one of three conditions holds:
+
+(i) (Sufficient decay in normalized duality gap) $\mu _ { n } ( z _ { \mathrm { c } } ^ { n , t + 1 } , z ^ { n , 0 } ) \leq \beta _ { \mathrm { s u f f i c i e n t } } \mu _ { n } ( z ^ { n , 0 } , z ^ { n - 1 , 0 } )$ , (ii) (Necessary decay $^ +$ no local progress in normalized duality gap)
+
+$$
+\begin{array} { r } { \mu _ { n } ( z _ { \mathrm { c } } ^ { n , t + 1 } , z ^ { n , 0 } ) \leq \beta _ { \mathrm { n e c e s s a r y } } \mu _ { n } ( z ^ { n , 0 } , z ^ { n - 1 , 0 } ) \quad \mathrm { a n d } \quad \mu _ { n } ( z _ { \mathrm { c } } ^ { n , t + 1 } , z ^ { n , 0 } ) > \mu _ { n } ( z _ { \mathrm { c } } ^ { n , t } , z ^ { n , 0 } ) , } \end{array}
+$$
+
+# (iii) (Long inner loop) $t \geq \beta _ { \mathrm { a r t i f i c i a l } } k$
+
+The motivation for (i) is presented in [7]; it guarantees the linear convergence of restarted PDHG on LP problems. The second condition in (ii) is inspired by adaptive restart schemes for accelerated gradient descent where restarts are triggered if the function value increases [57]. The first inequality in (ii) provides a safeguard for the second one, preventing the algorithm restarting every inner iteration or never restarting. The motivation for (iii) relates to the primal weights (Section 3.3). In particular, primal weight updates only occur after a restart, and condition (iii) ensures that the primal weight will be updated infinitely often. This prevents a bad choice of primal weight in earlier iterations causing progress to stall for a long time.
+
+# 3.3 Primal weight updates
+
+The primal weight is initialized using
+
+$$
+\mathrm { I n i t i a l i z e P r i m a l W e i g h t } ( c , q ) : = \left\{ \begin{array} { l l } { \frac { \| c \| _ { 2 } } { \| q \| _ { 2 } } } & { \| c \| _ { 2 } , \| q \| _ { 2 } > \epsilon _ { \mathrm { z e r o } } } \\ { 1 } & { \mathrm { o t h e r w i s e } } \end{array} \right.
+$$
+
+where $\epsilon _ { \mathrm { z e r o } }$ is a small nonzero tolerance. This primal weight update scheme guarantees scale invariance. In particular, in Appendix A we consider PDHG with $\epsilon _ { \mathrm { z e r o } } = 0$ , $\eta = 0 . 9 / \| K \| _ { 2 }$ and $\omega =$ InitializePrimalWeight $( c , q )$ . In this simplified setting, we prove that if we multiply the objective, constraints, or the right hand side and variable bounds by a scalar then the iterate behaviour remain identical (up to a scaling factor).
+
+# Algorithm 3: Primal weight update
+
+1 Function PrimalWeightUpdate(zn,0, zn−1,0, ωn−1):
+
+2 $\Delta _ { x } ^ { n } = \lVert x ^ { n , 0 } - x ^ { \bar { n - 1 } , 0 } \rVert _ { 2 } , \quad \Delta _ { y } ^ { n } = \lVert y ^ { n , 0 } - y ^ { n - 1 , 0 } \rVert _ { 2 } ;$   
+3 if $\Delta _ { x } ^ { n } > \epsilon _ { z e r o }$ $\Delta _ { y } ^ { n } > \epsilon _ { z e r o }$   
+4 $\begin{array} { r l } { \exp \left( \theta \log \left( \frac { \Delta _ { y } ^ { n } } { \Delta _ { x } ^ { n } } \right) + ( 1 - \theta ) \log \left( \omega ^ { n - 1 } \right) \right) } & { { } } \end{array}$   
+5 else   
+6 return $\omega ^ { n - 1 }$ ;   
+7 end
+
+Algorithm 3 aims to choose the primal weight $\omega ^ { n }$ such that distance to optimality in the primal and dual is the same, i.e., $\| ( x ^ { n , t } - \bar { x ^ { \star } } , \mathbf { 0 } ) \| _ { \omega ^ { n } } \approx \| ( \mathbf { 0 } , y ^ { n , t } - y ^ { \star } ) \| _ { \omega ^ { n } }$ . By definition of $\| \cdot \| _ { \omega }$ ,
+
+$$
+\| ( x ^ { n , t } - x ^ { \star } , \mathbf { 0 } ) \| _ { \omega ^ { n } } = \omega ^ { n } \| x ^ { n , t } - x ^ { \star } \| _ { 2 } , \quad \| ( \mathbf { 0 } , y ^ { n , t } - y ^ { \star } ) \| _ { \omega ^ { n } } = \frac { 1 } { \omega ^ { n } } \| y ^ { n , t } - y ^ { \star } \| _ { 2 } .
+$$
+
+Setting these two terms equal yields beforehand, but we attempt to estim $\begin{array} { r } { \omega ^ { n } = \frac { \| y ^ { n , t } - y ^ { \star } \| _ { 2 } } { \| x ^ { n , t } - x ^ { \star } \| _ { 2 } } } \end{array}$ f course, the quantity . However, the quant kyn,t−y?k2 is unknowncan change $\Delta _ { y } ^ { n } / \Delta _ { x } ^ { n }$ $\Delta _ { y } ^ { n } / \Delta _ { x } ^ { n }$ wildly from one restart to another, causing $\omega ^ { n }$ to oscillate. To dampen variations in $\omega ^ { n }$ , we first move to a log-scale where the primal weight is symmetric, i.e., $\log ( 1 / \omega ^ { n } ) = - \log ( \omega ^ { n } )$ , and perform a exponential smoothing with parameter $\theta \in [ 0 , 1 ]$ . In PDLP, we use $\theta = 0 . 5$ .
+
+There are several important differences between our primal weight heuristic and literature [36, 37]. For example, [36,37] make relatively small changes to the primal weights at each iteration, attempting to balance the primal and dual residual. These changes have to be diminishingly small because, in our experience, PDHG may be unstable if they are too big. In contrast, in our method the primal weight is only updated during restarts, which in practice allows for much larger changes without instability issues. Moreover, our scheme tries to balance the weighted distance traveled in the primal and dual rather than the residuals [36, 37].
+
+# 3.4 Presolve
+
+Presolving refers to transformation steps that simplify the input problem before starting the optimization solver. These steps span from relatively easy transformations such as detecting inconsistent bounds, removing empty rows and columns of $K$ , and removing variables whose lower and upper bounds are equal, to more complex operations such as detecting duplicate rows in $K$ and tightening bounds. Presolve is a standard component of traditional LP solvers [44]. We are not aware of presolve being combined with PDHG for LP. However, [41, 42] combine presolve with other FOMs.
+
+As an experiment to measure the impact of presolve, we used PaPILO [29], an open-source presolving library. For technical reasons, it was easier to use PaPILO as a standalone executable than as a library. We simulate its effect by simply solving the preprocessed instances. Convergence criteria are evaluated with respect to the presolved instance, not the original problem.
+
+# 3.5 Diagonal Preconditioning
+
+Preconditioning is a popular heuristic in optimization for improving the convergence of FOMs. To avoid factorizations, we only consider diagonal preconditioners. Our goal is to rescale the constraint matrix $K = ( G , A )$ to $\tilde { K } = ( \tilde { G } , \tilde { A } ) = \tilde { D _ { 1 } K } D _ { 2 }$ with positive diagonal matrices $D _ { 1 }$ and $D _ { 2 }$ , so that the resulting matrix $\tilde { K }$ is “well balanced”. Such preconditioning creates a new LP instance that replaces $A , G , c , b , h , u$ , and $l$ in (1) with $\tilde { G } , \tilde { A }$ , $\hat { x } = D _ { 2 } ^ { - 1 } x$ , $\tilde { c } = D _ { 2 } c$ , $( \tilde { b } , \tilde { h } ) = D _ { 1 } ( b , h )$ , $\tilde { u } = D _ { 2 } ^ { - 1 } u$ and $\tilde { l } = D _ { 2 } ^ { - 1 } l$ . Common choices for $D _ { 1 }$ and $D _ { 2 }$ include:
+
+• No scaling: Solve the original LP instance (1) without additional scaling, namely $D _ { 1 } = D _ { 2 } = I$ . • Pock-Chambolle [59]: Pock and Chambolle proposed a family of diagonal preconditioners3 for PDHG parameterized by $\alpha$ , where the diagonal matrices are defined by $( D _ { 1 } ) _ { j j } = \sqrt { \| K _ { j , \cdot } \| _ { 2 - \alpha } }$ for $j = 1 , . . . , m _ { 1 } + m _ { 2 }$ and $( D _ { 2 } ) _ { i i } = \sqrt { \| K _ { \cdot , i } \| _ { \alpha } }$ for $i = 1 , . . . , n$ . We use $\alpha = 1$ in PDLP (we also tested $\alpha = 0$ and $\alpha = 2$ ). This is the baseline diagonal preconditioner in the PDHG literature. • Ruiz [63]: Ruiz scaling is a popular algorithm in numerical linear algebra to equilibrate matrices. In an iteration of Ruiz scaling, the diagonal matrices are defined as $( D _ { 1 } ) _ { j j } = \sqrt { \| K _ { j , \cdot } \| _ { \infty } }$ for $j = 1 , . . . , m _ { 1 } + m _ { 2 }$ and $( D _ { 2 } ) _ { i i } = \sqrt { \| K _ { \cdot , i } \| _ { \infty } }$ for $i = 1 , . . . , n$ . Ruiz [63] shows that if this rescaling is applied iteratively, the infinity norm of each row and each column converge to 1.
+
+For the default PDLP settings, we apply a combination of Ruiz rescaling [63] and the preconditioning technique proposed by Pock and Chambolle [59]. In particular, we apply 10 iterations of Ruiz scaling and then apply the Pock-Chambolle scaling. To illustrate the effectiveness of our proposed scaling technique, we compare it against these three common techniques in Appendix C.5.
+
+# 3.6 Theoretical guarantees for the above enhancements
+
+While PDLP’s enhancements are motivated by theory, some of them may not preserve theoretical guarantees as discussed below:
+
+• We do not have a proof of convergence for the adaptive step size rule (Section 3.1).   
+• One can show our restart criteria (Section 3.2) preserve convergence guarantees by modifying the proof of [7] to a more general setting.   
+• Primal weight updates (Section 3.3) do not readily preserve convergence guarantees, but we conjecture that a proof of convergence is possible if they are updated infrequently.   
+• Presolve (Section 3.4) and diagonal preconditioning (Section 3.5) preserve theoretical guarantees because they can be viewed as applying PDHG to an LP instance with different data.
+
+# 4 Numerical experiments
+
+Our numerical experiments study the effectiveness of PDLP primarily with respect to traditional LP applications and benchmark sets. Section 4.1 describes the setup for the experiments. Section 4.2 demonstrates PDLP’s improvements over baseline PDHG. Section 4.3 compares PDLP with other FOMs. Section 4.4 highlights benchmark instances where PDLP outperforms a commercial LP solver. Finally, Section 4.5 illustrates the ability of PDLP to scale to a large application where barrier and simplex-based solvers run out of memory. The supplemental materials contain extensive ablation studies and additional instructions for reproducing the experiments.
+
+# 4.1 Experimental setup
+
+Optimality termination criteria. PDLP terminates with an approximately optimal solution when the primal-dual iterates $x \in X$ , $y \in Y$ , $\lambda \in \Lambda$ , satisfy:
+
+$$
+\begin{array} { r l } & { | q ^ { \top } y + l ^ { \top } \lambda ^ { + } - u ^ { \top } \lambda ^ { - } - c ^ { \top } x | \leq \epsilon ( 1 + | q ^ { \top } y + l ^ { \top } \lambda ^ { + } - u ^ { \top } \lambda ^ { - } | + | c ^ { \top } x | ) } \\ & { \qquad \| ( { A x } - b ) \| _ { 2 } \leq \epsilon ( 1 + \| q \| _ { 2 } ) } \\ & { \qquad \| c - K ^ { \top } y - \lambda \| _ { 2 } \leq \epsilon ( 1 + \| c \| _ { 2 } ) } \end{array}
+$$
+
+where $\epsilon \in ( 0 , \infty )$ is the termination tolerance. Note that if (6) is satisfied with $\epsilon = 0$ , then by LP duality we have found an optimal solution [35]. Indeed, (6a) is the duality gap, (6b) is primal feasibility, and (6c) is dual feasibility. We use these criteria to be consistent with those of SCS [54]. The PDHG algorithm does not explicitly include a reduced costs variable $\lambda$ . Therefore, to evaluate the optimality termination criteria we compute $\lambda = \mathbf { p r o j } _ { \Lambda } ( c - K ^ { \top } y )$ . All instances considered have an optimal primal-dual solution. We use $\epsilon = 1 0 ^ { - 8 }$ as a benchmark for high-quality solutions and $\epsilon = \dot { 1 } 0 ^ { - 4 }$ for moderately accurate solutions.
+
+Benchmark datasets. We use three datasets to compare algorithmic performance. One is the LP benchmark dataset of 56 problems, formed by merging the instances from “Benchmark of Simplex LP Solvers”, “Benchmark of Barrier LP solvers”, and “Large Network-LP Benchmark” from [45]. We also created a larger benchmark of 383 instances curated from LP relaxations of mixed-integer programming problems from the MIPLIB2017 collection [34] (see Appendix B) that we label MIP Relaxations. MIP Relaxations was used extensively during algorithmic development, e.g., for hyperparameter choices; we held out LP benchmark as a test set. Finally, we also performed some experiments on the Netlib LP benchmark [31], an historically important benchmark that is no longer state of the art for large-scale LP.
+
+Software. PDLP is implemented in an open-source Julia [15] module available at https: //github.com/google-research/FirstOrderLp.jl. The module also contains a baseline implementation of the extragradient method with many of the same enhancements as PDLP (labeled ‘Enh. Extragradient’). We compare with two external packages: SCS [54] version 2.1.3, an opensource generic cone solver based on ADMM, and Gurobi version 9.0.1, a state-of-the-art commercial LP solver. SCS supports two modes for solving the linear system that arises at each iteration, a direct method based on a cached LDL factorization (which is the default ‘SCS’) and an indirect method based on the conjugate gradient method (which we label ‘SCS (matrix-free)’). All solvers are run single-threaded. SCS and Gurobi are provided the same presolved instances as PDLP.
+
+Computing environment. We used two computing environments for our experiments: 1) e2-highmem-2 virtual machines (VMs) on Google Cloud Platform (GCP). Each VM provides two virtual CPUs and 16GB RAM. 2) A dedicated workstation with an Intel Xeon E5-2669 v3 processor and 128 GB RAM. This workstation has a license for Gurobi that permits at most one concurrent solve. Total compute time on GCP for all preliminary and final experiments was approximately 72, 000 virtual CPU hours.
+
+Initialization. All first-order methods use all-zero vectors as the initial starting points.
+
+Metrics. We use the term KKT passes to refer to the number of matrix multiplications by both $K$ and $K ^ { \top }$ . Given that the most expensive operation in our algorithm is matrix-vector multiplication, this metric is less noisy than runtime for comparing performance between matrix-free solvers. SGM10 stands for shifted geometric mean with shift 10, which is computed by adding 10 to all data points, taking the geometric mean, and then subtracting 10. Unsolved instances are assigned values corresponding to the limits specified in the next paragraph.
+
+Time and KKT pass limits. For Section 4.2 we impose a limit on the KKT passes of 100, 000.   
+For Section 4.3 we impose a time limit of 1 hour.
+
+# 4.2 Impact of PDLP’s improvements
+
+The y-axes of Figure 1 display the SGM10 of the KKT passes normalized by the value for baseline PDHG. We can see, with the exception of presolve for LP benchmark at tolerance $1 0 ^ { - 4 }$ , each of our modifications described in Section 3 improves the performance of PDHG.
+
+![](images/cf07ba9149d88bf36db5d069d5bfdb95182df7c308b1a0cf6b0f32d746d94b6c.jpg)  
+Figure 1: Summary of relative impact of PDLP’s improvements
+
+![](images/495c51e32202a8940dcaf7bd76eccbc8cbf088dad2e040d7d6474b010e4021d0.jpg)  
+Figure 2: Number of problems solved for MIP Relaxations (top), LP benchmark (middle), and Netlib (bottom) datasets.
+
+# 4.3 Comparison with other first-order baselines
+
+We compared PDLP with several other first-order baselines: SCS [54], in both direct (default) mode and matrix-free mode, and our enhanced implementation of the extragradient method [39, 48]. For SCS in matrix-free mode, we include the KKT passes from the conjugate gradient solves; for SCS in direct mode there is no reasonable measure of KKT passes for the factorization and direct solve, so we only measure running time. The comparisons are summarized in Figure 2.
+
+# 4.4 PDLP versus simplex and barrier
+
+In this section, we test the performance of PDLP against the three methods available in Gurobi: barrier, primal simplex, and dual simplex. By default when provided multiple threads, Gurobi runs these three methods concurrently and terminates when the first method completes. We used default termination for Gurobi and set $\epsilon = 1 0 ^ { - 8 }$ for PDLP. We ran experiments with instances from the MIP Relaxations and LP benchmark. Although, for most instances, Gurobi outperforms PDLP, we found problems for which PDLP exhibits moderate to significant gains. Table 1 gives examples of instances where our prototype implementation is within a factor of two of the best of the three Gurobi methods. While further improvements are needed for PDLP to truly compete with the portfolio of methods that Gurobi offers, we interpret these results as evidence that PDLP itself could be of value in this portfolio.
+
+Table 1: Instances from MIP Relaxations (top) and LP benchmark (bottom) where PDLP is within a factor of 2 of the best of all Gurobi methods. Time to solve in seconds.   
+
+<table><tr><td>Instance</td><td>PDLP</td><td>Gurobi Barrier</td><td>Gurobi Primal Simp.</td><td>Gurobi Dual Simp.</td></tr><tr><td>ex9</td><td>1.6</td><td>102.6</td><td>181.3</td><td>47.6</td></tr><tr><td>genus-sym-g62-2</td><td>2.1</td><td>10.7</td><td>6.7</td><td>33.2</td></tr><tr><td>highschooll-aigio</td><td>72.6</td><td>243.8</td><td>&gt;3600</td><td>&gt;3600</td></tr><tr><td>neos-578379</td><td>1.4</td><td>0.7</td><td>1.7</td><td>1.8</td></tr><tr><td>rwth-timetable</td><td>1870.3</td><td>&gt;3600</td><td>&gt;3600</td><td>&gt;3600</td></tr><tr><td>ex10</td><td>4.9</td><td>63.1</td><td>16.8</td><td>7.9</td></tr><tr><td>nug08-3rd</td><td>2.2</td><td>3.2</td><td>2219.2</td><td>24.1</td></tr><tr><td>savsched1</td><td>35.9</td><td>25.9</td><td>56.0</td><td>261.3</td></tr></table>
+
+Table 2: Solve time for PageRank instances. Gurobi barrier has crossover disabled, 1 thread. PDLP and SCS solve to $1 0 ^ { - 8 }$ relative accuracy. SCS is matrix-free. Baseline PDHG is unable to solve any instances. Presolve not applied. $\mathrm { O O M } = \cdot$ Out of Memory. The number of nonzero coefficients per instance is $8 \times$ (# nodes) − 18.   
+
+<table><tr><td># nodes</td><td>PDLP</td><td>SCS</td><td>Gurobi Barrier</td><td>Gurobi Primal Simp.</td><td>Gurobi Dual Simp.</td></tr><tr><td>104</td><td>7.4 sec.</td><td>1.3 sec.</td><td>36 sec.</td><td>37 sec.</td><td>114 sec.</td></tr><tr><td>105</td><td>35 sec.</td><td>38 sec.</td><td>7.8 hr.</td><td>9.3 hr.</td><td>&gt;24 hr.</td></tr><tr><td>106</td><td>11 min.</td><td>25 min.</td><td>0OM</td><td>&gt;24 hr.</td><td>1</td></tr><tr><td>107</td><td>5.4 hr.</td><td>3.8 hr.</td><td>1</td><td>1</td><td>1</td></tr></table>
+
+# 4.5 Large-scale application: PageRank
+
+Nesterov [50, equation (7.3)] gives an LP formulation of the standard “PageRank” problem. Although the LP formulation is not the best approach to computing PageRank, it is a source of very large instances. For a random scalable collection of PageRank instances, we used Barabási-Albert [9] preferential attachment graphs with approximately three edges per node; see Appendix D for details. The results are summarized in Table 2.
+
+# 5 Conclusions and future work
+
+We find our experimental results encouraging for the application of FOMs like PDHG to LP. At a minimum, they provide evidence against the claim that FOMs are useful only when moderately accurate solutions are desired. The practical success of our heuristics that lack theoretical guarantees provides fresh motivation for theoreticians to study these methods. It is important, as well, to understand what drives the difficulty of some instances and how they could be transformed to solve more quickly. We hope the community will use the benchmarks and baselines released with this work as a starting point for further investigating new FOMs for LP. With additional algorithmic and implementation refinements, we believe that PDLP or similar approaches could become part of the standard toolkit for linear programming.
+
+# Acknowledgments and Disclosure of Funding
+
+We thank Yura Malitsky for advice on parameter choices for the linesearch rule of [43].
+
+The authors have no third-party funding or competing interests to declare.
+
+References   
+[1] T. Achterberg, R. E. Bixby, Z. Gu, E. Rothberg, and D. Weninger. Presolve reductions in mixed integer programming. INFORMS Journal on Computing, 32(2):473–506, 2020.   
+[2] J. Adler, H. Kohr, and O. Öktem. Operator discretization library (ODL), Jan. 2017.   
+[3] A. Alacaoglu, O. Fercoq, and V. Cevher. On the convergence of stochastic primal-dual hybrid gradient. arXiv preprint arXiv:1911.00799, 2019.   
+[4] A. Ali, E. Wong, and J. Z. Kolter. A semismooth Newton method for fast, generic convex programming. In International Conference on Machine Learning, pages 70–79. PMLR, 2017.   
+[5] B. Amos and J. Z. Kolter. OptNet: Differentiable optimization as a layer in neural networks. In D. Precup and Y. W. Teh, editors, Proceedings of the 34th International Conference on Machine Learning, volume 70 of Proceedings of Machine Learning Research, pages 136–145. PMLR, 06–11 Aug 2017.   
+[6] D. Applegate, M. Díaz, H. Lu, and M. Lubin. Infeasibility detection with primal-dual hybrid gradient for large-scale linear programming. arXiv preprint arXiv:2102.04592, 2021.   
+[7] D. Applegate, O. Hinder, H. Lu, and M. Lubin. Faster First-Order Primal-Dual Methods for Linear Programming using Restarts and Sharpness. arXiv preprint arXiv:2105.12715, 2021.   
+[8] K. J. Arrow, L. Hurwicz, and H. Uzawa. Studies in linear and non-linear programming. Stanford University Press, 1958.   
+[9] A.-L. Barabási and R. Albert. Emergence of scaling in random networks. Science, 286(5439):509–512, 1999.   
+[10] K. Basu, A. Ghoting, R. Mazumder, and Y. Pan. ECLIPSE: An extreme-scale linear program solver for web-applications. In H. D. III and A. Singh, editors, Proceedings of the 37th International Conference on Machine Learning, volume 119 of Proceedings of Machine Learning Research, pages 704–714, Virtual, 13–18 Jul 2020. PMLR.   
+[11] H. H. Bauschke and P. L. Combettes. Convex analysis and monotone operator theory in Hilbert spaces, volume 408. Springer, 2 edition, 2017.   
+[12] A. Beck. First-Order Methods in Optimization. Society for Industrial and Applied Mathematics, Philadelphia, PA, 2017.   
+[13] A. Beck and N. Guttmann-Beck. FOM–a MATLAB toolbox of first-order methods for solving convex optimization problems. Optimization Methods and Software, 34(1):172–193, 2019.   
+[14] S. R. Becker, E. J. Candès, and M. C. Grant. Templates for convex cone problems with applications to sparse signal recovery. Mathematical programming computation, 3(3):165, 2011.   
+[15] J. Bezanson, A. Edelman, S. Karpinski, and V. B. Shah. Julia: A fresh approach to numerical computing. SIAM Review, 59(1):65–98, 2017.   
+[16] S. Boyd, N. Parikh, E. Chu, B. Peleato, and J. Eckstein. Distributed optimization and statistical learning via the alternating direction method of multipliers. Foundations and Trends $\textsuperscript { \textregistered }$ in Machine learning, 3(1):1–122, 2011.   
+[17] S. Boyd and L. Vandenberghe. Convex optimization. Cambridge university press, 2004.   
+[18] A. Chambolle, M. J. Ehrhardt, P. Richtárik, and C.-B. Schonlieb. Stochastic primal-dual hybrid gradient algorithm with arbitrary sampling and imaging applications. SIAM Journal on Optimization, 28(4):2783–2808, 2018.   
+[19] A. Chambolle and T. Pock. A first-order primal-dual algorithm for convex problems with applications to imaging. Journal of mathematical imaging and vision, 40(1):120–145, 2011.   
+[20] A. Chambolle and T. Pock. On the ergodic convergence rates of a first-order primal–dual algorithm. Mathematical Programming, 159(1):253–287, 2016.   
+[21] L. Condat. A primal–dual splitting method for convex optimization involving Lipschitzian, proximable and linear composite terms. Journal of Optimization Theory and Applications, 158(2):460–479, 2013.   
+[22] G. Dantzig. Linear programming and extensions. Princeton university press, 2016.   
+[23] G. B. Dantzig. Origins of the simplex method. In A history of scientific computing, pages 141–151. Association for Computing Machinery, New York, NY, USA, 1990.   
+[24] J. Eckstein and D. P. Bertsekas. An alternating direction method for linear programming. Technical Report LIDS-P-1967, Laboratory for Information and Decision Systems, Massachusetts Institute of Technology, 1990.   
+[25] J. Eckstein and D. P. Bertsekas. On the Douglas–Rachford splitting method and the proximal point algorithm for maximal monotone operators. Mathematical Programming, 55(1-3):293– 318, 1992.   
+[26] J. Eckstein and G. Matyasfalvi. Efficient distributed-memory parallel matrix-vector multiplication with wide or tall unstructured sparse matrices. arXiv preprint arXiv:1812.00904, 2018.   
+[27] E. Esser, X. Zhang, and T. F. Chan. A general framework for a class of first order primal-dual algorithms for convex optimization in imaging science. SIAM Journal on Imaging Sciences, 3(4):1015–1046, 2010.   
+[28] C. Fougner and S. Boyd. Parameter selection and preconditioning for a graph form solver. In Emerging Applications of Control and Systems Theory, pages 41–61. Springer, 2018.   
+[29] G. Gamrath, D. Anderson, K. Bestuzheva, W.-K. Chen, L. Eifler, M. Gasse, P. Gemander, A. Gleixner, L. Gottwald, K. Halbig, et al. The SCIP optimization suite 7.0. ZIB-Report 20-10, Zuse Institut Berlin, 2020.   
+[30] M. Garstka, M. Cannon, and P. Goulart. COSMO: A conic operator splitting method for large convex problems. In European Control Conference, 2019.   
+[31] D. M. Gay. Electronic mail distribution of linear programming test problems. Mathematical Programming Society COAL Newsletter, 13:10–12, 1985.   
+[32] A. Gilpin, J. Pena, and T. Sandholm. First-order algorithm with $\mathcal { O } ( \ln ( 1 / \epsilon ) )$ convergence for $\epsilon$ -equilibrium in two-person zero-sum games. Mathematical programming, 133(1):279–298, 2012.   
+[33] P. Giselsson and S. Boyd. Linear convergence and metric selection for Douglas-Rachford splitting and ADMM. IEEE Transactions on Automatic Control, 62(2):532–544, 2016.   
+[34] A. Gleixner, G. Hendel, G. Gamrath, T. Achterberg, M. Bastubbe, T. Berthold, P. M. Christophel, K. Jarck, T. Koch, J. Linderoth, M. Lübbecke, H. D. Mittelmann, D. Ozyurt, T. K. Ralphs, D. Salvagnin, and Y. Shinano. MIPLIB 2017: Data-Driven Compilation of the 6th Mixed-Integer Programming Library. Mathematical Programming Computation, 2021.   
+[35] A. J. Goldman and A. W. Tucker. Theory of linear programming. Linear inequalities and related systems, 38:53–97, 1956.   
+[36] T. Goldstein, M. Li, and X. Yuan. Adaptive primal-dual splitting methods for statistical learning and image processing. In Advances in Neural Information Processing Systems, pages 2089–2097, 2015.   
+[37] T. Goldstein, M. Li, X. Yuan, E. Esser, and R. Baraniuk. Adaptive primal-dual hybrid gradient methods for saddle-point problems. arXiv preprint arXiv:1305.0546, 2013.   
+[38] B. He and X. Yuan. Convergence analysis of primal-dual algorithms for a saddle-point problem: from contraction perspective. SIAM Journal on Imaging Sciences, 5(1):119–149, 2012.   
+[39] G. M. Korpelevich. The extragradient method for finding saddle points and other problems. Matecon, 12:747–756, 1976.   
+[40] G. Lan, Z. Lu, and R. D. C. Monteiro. Primal-dual first-order methods with $\mathcal { O } ( 1 / \epsilon )$ iterationcomplexity for cone programming. Mathematical Programming, 126(1):1–29, Jan 2011.   
+[41] X. Li, D. Sun, and K.-C. Toh. An asymptotically superlinearly convergent semismooth newton augmented lagrangian method for linear programming. SIAM Journal on Optimization, 30(3):2410–2440, 2020.   
+[42] T. Lin, S. Ma, Y. Ye, and S. Zhang. An ADMM-based interior-point method for large-scale linear programming. Optimization Methods and Software, 36(2-3):389–424, 2021.   
+[43] Y. Malitsky and T. Pock. A first-order primal-dual algorithm with linesearch. SIAM Journal on Optimization, 28(1):411–432, 2018.   
+[44] I. Maros. Computational Techniques of the Simplex Method. International Series in Operations Research & Management Science. Springer US, 2002.   
+[45] H. Mittelmann. Decision tree for optimization software. http://plato.asu.edu/guide. html, 2021.   
+[46] V. Nair, S. Bartunov, F. Gimeno, I. von Glehn, P. Lichocki, I. Lobov, B. O’Donoghue, N. Sonnerat, C. Tjandraatmadja, P. Wang, R. Addanki, T. Hapuarachchi, T. Keck, J. Keeling, P. Kohli, I. Ktena, Y. Li, O. Vinyals, and Y. Zwols. Solving Mixed Integer Programs Using Neural Networks. arXiv preprint arXiv:2012.13349, Dec. 2020.   
+[47] I. Necoara, Y. Nesterov, and F. Glineur. Linear convergence of first order methods for nonstrongly convex optimization. Mathematical Programming, 175(1):69–107, May 2019.   
+[48] A. Nemirovski. Prox-method with rate of convergence $O ( 1 / t )$ for variational inequalities with Lipschitz continuous monotone operators and smooth convex-concave saddle point problems. SIAM Journal on Optimization, 15(1):229–251, 2004.   
+[49] Y. Nesterov. A method of solving a convex programming problem with convergence rate $O ( 1 / k ^ { 2 } )$ . Soviet Mathematics Doklady, 27(2):372–376, 1983.   
+[50] Y. Nesterov. Subgradient methods for huge-scale optimization problems. Mathematical Programming, 146:275–297, 2014.   
+[51] Y. Nesterov and A. Nemirovskii. Interior-point polynomial algorithms in convex programming, volume 13. SIAM, 1994.   
+[52] B. O’Donoghue. Operator splitting for a homogeneous embedding of the monotone linear complementarity problem. arXiv preprint arXiv:2004.02177, 2020.   
+[53] B. O’Donoghue, E. Chu, N. Parikh, and S. Boyd. Conic optimization via operator splitting and homogeneous self-dual embedding. Journal of Optimization Theory and Applications, 169(3):1042–1068, June 2016.   
+[54] B. O’Donoghue, E. Chu, N. Parikh, and S. Boyd. SCS: Splitting conic solver, version 2.1.0. https://github.com/cvxgrp/scs, Nov. 2017.   
+[55] W. Orchard-Hays. History of mathematical programming systems. IEEE Annals of the History of Computing, 6(3):296–312, 1984.   
+[56] D. O’Connor and L. Vandenberghe. On the equivalence of the primal-dual hybrid gradient method and Douglas–Rachford splitting. Mathematical Programming, 179(1):85–108, 2020.   
+[57] B. O’Donoghue and E. Candes. Adaptive restart for accelerated gradient schemes. Foundations of computational mathematics, 15(3):715–732, 2015.   
+[58] N. Parikh and S. Boyd. Proximal algorithms. Foundations and Trends $\textsuperscript { \textregistered }$ in Optimization, 1(3):127–239, 2014.   
+[59] T. Pock and A. Chambolle. Diagonal preconditioning for first order primal-dual algorithms in convex optimization. In 2011 International Conference on Computer Vision, pages 1762–1769. IEEE, 2011.   
+[60] T. Pock, D. Cremers, H. Bischof, and A. Chambolle. An algorithm for minimizing the mumfordshah functional. In 2009 IEEE 12th International Conference on Computer Vision, pages 1133–1140. IEEE, 2009.   
+[61] J. Renegar. Accelerated first-order methods for hyperbolic programming. Mathematical Programming, 173(1):1–35, Jan 2019.   
+[62] R. T. Rockafellar. Monotone operators and the proximal point algorithm. SIAM journal on control and optimization, 14(5):877–898, 1976.   
+[63] D. Ruiz. A scaling algorithm to equilibrate both rows and columns norms in matrices. Technical report, CM-P00040415, 2001.   
+[64] E. K. Ryu and S. Boyd. Primer on monotone operator methods. Appl. Comput. Math, 15(1):3–43, 2016.   
+[65] A. Schrijver. Theory of linear and integer programming. John Wiley & Sons, 1998.   
+[66] M. Souto, J. D. Garcia, and Á. Veiga. Exploiting low-rank structure in semidefinite programming by approximate operator splitting. Optimization, pages 1–28, 2020.   
+[67] B. Stellato, G. Banjac, P. Goulart, A. Bemporad, and S. Boyd. OSQP: an operator splitting solver for quadratic programs. Mathematical Programming Computation, 12(4):637–672, 2020.   
+[68] Y. M. Tsai, T. Cojean, and H. Anzt. Sparse linear algebra on AMD and NVIDIA GPUs – the race is on. In P. Sadayappan, B. L. Chamberlain, G. Juckeland, and H. Ltaief, editors, High Performance Computing, pages 309–327, Cham, 2020. Springer International Publishing.   
+[69] R. J. Vanderbei et al. Linear programming, volume 3. Springer, 2015.   
+[70] S. Wang and N. Shroff. A new alternating direction method for linear programming. In I. Guyon, U. V. Luxburg, S. Bengio, H. Wallach, R. Fergus, S. Vishwanathan, and R. Garnett, editors, Advances in Neural Information Processing Systems, volume 30. Curran Associates, Inc., 2017.   
+[71] T. Yang and Q. Lin. RSG: Beating subgradient method without smoothness and strong convexity. The Journal of Machine Learning Research, 19(1):236–268, 2018.   
+[72] M. Zhu and T. Chan. An efficient primal-dual hybrid gradient algorithm for total variation image restoration. UCLA CAM Report, 34:8–34, 2008.
+
+# 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] Our comparisons with baselines show that PDLP is not always the best, hence demonstrating its limitations. We also note which of our heuristics are lacking theoretical guarantees.   
+(c) Did you discuss any potential negative societal impacts of your work? [No] As a purely algorithmic paper, we do not believe such a discussion is relevant. Linear programming is a mature area whose societal impact is well understood.   
+(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] The only theoretical result appear in the appendix (Proposition 1). (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)? [Yes] Code, data, and instructions needed to reproduce the main experimental results are publicly released in an open source repository at https://github.com/google-research/ FirstOrderLp.jl. Additional instructions are included in the supplementary materials.   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] We discussed that we used MIP Relaxations to build our algorithm
+
+and LP benchmark and Netlib as held out evaluation sets. We run a large ablation study to justify algorithmic decisions and most hyperparameter settings.
+
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [No] We used large datasets that would have been computational intensive to run multiple times. When possible, we use the “KKT pass” metric that’s reproducible and not subject to measurement noise. Only the PageRank instances use a random seed, and these are too large to run multiple times because we have a single concurrent license for Gurobi.   
+(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] See Section 4.1.
+
+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 use LP Benchmark, MIP Relaxations, and Netlib datasets. We cite the sources for the datasets.   
+(b) Did you mention the license of the assets? [No] Although these datasets are widely used in the community, we were unable to find explicit licenses.   
+(c) Did you include any new assets either in the supplemental material or as a URL? [Yes] We include our code and data processing scripts in the supplemental material.   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [No]   
+(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/_eXwwWOyqT_/_eXwwWOyqT__content_list.json

@@ -0,0 +1,1618 @@
+[
+    {
+        "type": "text",
+        "text": "Practical Large-Scale Linear Programming using Primal-Dual Hybrid Gradient ",
+        "text_level": 1,
+        "bbox": [
+            200,
+            122,
+            799,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "David Applegate Google Research dapplegate@google.com ",
+        "bbox": [
+            191,
+            226,
+            374,
+            268
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Mateo Díaz California Institute of Technology∗ mateodd@caltech.edu ",
+        "bbox": [
+            398,
+            226,
+            629,
+            267
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Oliver Hinder   \nGoogle Research   \nUniversity of Pittsburgh   \nohinder@pitt.edu ",
+        "bbox": [
+            647,
+            226,
+            805,
+            281
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Haihao Lu ",
+        "text_level": 1,
+        "bbox": [
+            264,
+            303,
+            339,
+            315
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Miles Lubin Google Research mlubin@google.com ",
+        "bbox": [
+            436,
+            303,
+            586,
+            344
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "University of Chicago† haihao.lu@chicagobooth.edu ",
+        "bbox": [
+            191,
+            318,
+            413,
+            345
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Brendan O’Donoghue DeepMind bodonoghue@deepmind.com ",
+        "bbox": [
+            607,
+            303,
+            808,
+            344
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Warren Schudy Google Research wschudy@google.com ",
+        "bbox": [
+            421,
+            367,
+            578,
+            409
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            445,
+            535,
+            460
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We present PDLP, a practical first-order method for linear programming (LP) that can solve to the high levels of accuracy that are expected in traditional LP applications. In addition, it can scale to very large problems because its core operation is matrix-vector multiplications. PDLP is derived by applying the primaldual hybrid gradient (PDHG) method, popularized by Chambolle and Pock (2011), to a saddle-point formulation of LP. PDLP enhances PDHG for LP by combining several new techniques with older tricks from the literature; the enhancements include diagonal preconditioning, presolving, adaptive step sizes, and adaptive restarting. PDLP improves the state of the art for first-order methods applied to LP. We compare PDLP with SCS, an ADMM-based solver, on a set of $3 8 3 \\ \\mathrm { L P }$ instances derived from MIPLIB 2017. With a target of $1 0 ^ { - 8 }$ relative accuracy and 1 hour time limit, PDLP achieves a $6 . 3 \\mathrm { x }$ reduction in the geometric mean of solve times and a 4.6x reduction in the number of instances unsolved (from 227 to 49). Furthermore, we highlight standard benchmark instances and a large-scale application (PageRank) where our open-source prototype of PDLP, written in Julia, outperforms a commercial LP solver. ",
+        "bbox": [
+            233,
+            470,
+            766,
+            691
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            705,
+            312,
+            722
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "First-order methods (FOMs), which use gradient and not Hessian information, are now applied as standard practice in many areas of optimization [12]. A known weakness of FOMs is the tailing-off effect, where FOMs quickly find moderately accurate solutions, but progress towards an optimal solution slows down over time. While moderately accurate solutions are often sufficient for large machine learning applications, other applications traditionally demand higher precision. One such area is Linear Programming (LP), the focus of this work. ",
+        "bbox": [
+            174,
+            729,
+            825,
+            814
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "LP is a fundamental class of optimization problems in applied mathematics, operations research, and computer science with a huge range of applications, including mixed-integer programming, scheduling, network flow, chip design, budget allocation, and many others [17, 22, 65, 69]. Software for solving LP problems, called LP solvers, originated in the earliest days of computing, predating the invention of operating systems [55]. The state-of-the-art methods for LP, namely Dantzig’s simplex method [22,23] and interior-point (or barrier) methods [51], are quite mature and reliable at delivering highly accurate solutions. These widely successful methods have left little room for FOMs to make inroads. Furthermore, practitioners who use LP solvers are not accustomed to reasoning about the trade-off between accuracy and computing times typically intrinsic to FOMs. ",
+        "bbox": [
+            176,
+            820,
+            825,
+            862
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            174
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we provide evidence that, if properly enhanced, FOMs can obtain high quality solutions to LP problems quickly. Indeed, there’s reason to expect this, as authors have developed FOMs for LP with linear rates of convergence [24, 32, 47, 70, 71]. On the other hand, the linear rates depend on potentially loose and hard-to-compute constants; hence, tailing off may still be observed in practice. To our knowledge, ours is the first work to combine both theoretical enhancements with practical heuristics, demonstrating their combined effectiveness with extensive computational experiments on standard benchmark instances. In fact, our experiments will expose a substantial gap between algorithms presented in the literature and what’s needed to obtain good performance. ",
+        "bbox": [
+            174,
+            181,
+            825,
+            291
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Starting from a baseline primal-dual hybrid gradient (PDHG) method [19] applied to a saddle point formulation of LP, we develop a series of algorithmic improvements. These enhancements include adaptive restarting [7], dynamic primal-dual step size selection [36, 37], presolving techniques [1], and diagonal preconditioning (data equilibration) [33]. Most of these enhancements, while inspired by existing literature, are novel. We name our collection of enhancements PDLP (PDHG for LP). ",
+        "bbox": [
+            174,
+            299,
+            825,
+            367
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The impact of these improvements is substantial. For example, on $3 8 3 \\mathrm { L P }$ instances derived from the MIPLIB 2017 collection [34], our implementation of a baseline version of PDHG solved only 50 problems to $1 0 ^ { - 8 }$ relative accuracy given a limit of approximately 100,000 iterations per problem. By contrast, PDLP solves 283 of the 383 problems under the same conditions. We demonstrate that PDLP outperforms FOM baselines and, in a small number of cases, obtains performance competitive with a commercial LP solver. ",
+        "bbox": [
+            174,
+            375,
+            825,
+            458
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Although not the focus of this paper, we believe that our results open the door to a new set of possibilities and computational trade-offs when solving LP problems. PDLP has the potential to solve extremely large scale instances where the simplex method and interior-point methods are unable to run because of their reliance on matrix factorization. Since PDLP uses matrix-vector operations at its core, it can effectively run on multi-threaded CPUs, GPUs [68], or distributed clusters [26]. Furthermore, a GPU implementation of PDLP could efficiently solve batches of similar problems, a setup that has already been successfully applied with other optimization algorithms in applications like strong branching [46] and training neural networks that contain optimization layers [5]. ",
+        "bbox": [
+            174,
+            464,
+            825,
+            575
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Outline. The remainder of this section focuses on related work. Section 2 introduces LP and PDHG. Section 3 describes the set of enhancements that define PDLP. Section 4 presents numerical experiments, and Section 5 concludes and outlines future directions. ",
+        "bbox": [
+            174,
+            583,
+            825,
+            625
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1.1 Literature review ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            636,
+            334,
+            650
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "PDHG PDHG was first developed by Zhu and Chan [72], with subsequent analysis and extension by a number of authors [3,18,19,21,27,38,60]. PDHG is closely related to the Arrow-Hurwicz method [8]. PDHG is a form of operator-splitting [11, 64] and can be interpreted as a variant of the alternating directions method of multipliers (ADMM) and Douglas-Rachford splitting (DRS) [16, 25, 56], which themselves are both instantiations of the proximal point method [25, 58, 62]. As opposed to ADMM or DRS, PDHG is ‘matrix-free’ in that the data matrix is only used for matrix-vector multiplications. This allows PDHG to scale to problems even larger than those tackled by these other techniques, and to make better use of parallel and distributed computation. ",
+        "bbox": [
+            173,
+            654,
+            825,
+            765
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "FOM-based solvers Recent interest in large-scale cone programming has sparked the development several first-order solvers based on competing methods. ProxSDP [66] is a solver for semidefinite programming based on PDHG. Solvers based on Nesterov’s accelerated gradients [49] include TFOCS [14], and FOM which is a suite of solvers employing both gradient and proximal algorithms [13]. Solvers based on operator splitting techniques like ADMM include SCS [52–54], OSQP [67], POGS [28], and COSMO [30]. Of these both SCS and POGS offer a matrix-free implementation where the linear system, that arises from the proximal operator used in ADMM, is solved using the conjugate gradient method. However, we shall show experimentally that our method can be significantly faster and more robust than this approach. Finally, [4] considers applying a truncated semismooth Newton method to the system of equations defining a fixed point of the SCS operator. ",
+        "bbox": [
+            174,
+            772,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "FOMs for LP Lan, Lu and Monteiro [40] and Renegar [61] develop FOMs for LP as a special case of semidefinite programming, with sublinear convergence rates. The FOM-based solvers above all apply to more general problem classes like cone programming or quadratic programming. In contrast, some of the enhancements that constitute PDLP are specialized, either in theory or practice, for LP (namely restarts [7] and presolving). A number of authors [24, 32, 47, 70, 71] have proposed linearly convergent FOMs for LP; to our knowledge, none have been subject of a comprehensive computational study. ECLIPSE [10] solves huge-scale industrial LP problems by accelerated gradient descent, without presenting comparisons on standard test problems. Lin et al. [42] propose an ADMM-based interior point method. In contrast with PDLP which solves to high accuracy (i.e., $1 0 ^ { - 8 }$ relative error), [42] perform experiments with $1 0 ^ { - 3 }$ and $1 0 ^ { - 5 }$ relative error. SNIPAL [41] is a semismooth Newton method based on the proximal augmented Lagrangian. SNIPAL has fast asymptotic convergence, yet, to get good performance, the authors use ADMM for warm-starts. Given PDLP’s favorable comparisons with SCS, it’s plausible that PDLP could provide a more effective warm-start. Finally, Pock and Chambolle [59] apply PDHG with diagonal preconditioning to a limited set of test LP problems and Applegate et al. [6] show how to extract infeasibility certificates when applying PDHG to LP. ",
+        "bbox": [
+            173,
+            90,
+            826,
+            313
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 Preliminaries ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            324,
+            318,
+            342
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we introduce the notation we use throughout the paper, summarize the LP formulations we solve, and introduce the baseline PDHG algorithm. ",
+        "bbox": [
+            174,
+            349,
+            823,
+            378
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Notation. Let $\\mathbb { R }$ denote the set of real numbers, $\\mathbb { R } ^ { + }$ the set of nonnegative real numbers, and $\\mathbb { R } ^ { - }$ the set of nonpositive real numbers. Let $\\mathbb { N }$ denote the set of natural numbers (starting from one). Let $\\| \\cdot \\| _ { p }$ denote the $\\ell _ { p }$ norm for a vector, and let $\\| \\cdot \\| _ { 2 }$ denote the spectral norm for a matrix. For a vector $v \\in \\mathbb { R } ^ { n }$ , we use $v ^ { + }$ and $v ^ { - }$ for their positive and negative parts, i.e., $v _ { i } ^ { + } = \\operatorname* { m a x } \\{ 0 , v _ { i } \\}$ and $v _ { i } ^ { - } = \\operatorname* { m i n } \\{ 0 , v _ { i } \\}$ . The symbol $v _ { 1 : m }$ denotes the vector with the first $m$ components of $v$ . The symbols $K _ { i , }$ ,· and $K _ { \\cdot , j }$ correspond to the $i$ th column and $j$ th row of the matrix $K$ , respectively. The symbol 1 denotes the vector of all ones. Given a convex set $X$ , we use $\\mathbf { p r o j } _ { X }$ to denote the map that projects onto $X$ . ",
+        "bbox": [
+            173,
+            386,
+            825,
+            502
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Linear Programming. We solve primal-dual LP problems of the form: ",
+        "bbox": [
+            174,
+            508,
+            655,
+            525
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4a532f77e6d673b0c28571b271d500fa5d1ec1adf65c61a17bb7d15f3a759112.jpg",
+        "text": "$$\n{ \\begin{array} { r l } & { { \\underset { x \\in \\mathbb { R } ^ { n } } { \\mathrm { m i n i m i z e } } } ~ c ^ { \\top } x } \\\\ & { { \\mathrm { s u b j e c t ~ t o : } } ~ G x \\geq h } \\\\ & { ~ A x = b } \\\\ & { ~ l \\leq x \\leq u } \\end{array} }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            241,
+            532,
+            395,
+            614
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c29c3b4e11f053132b34d2e9461bebaf37574f59d78f949f0ef2537d118c29db.jpg",
+        "text": "$$\n\\begin{array} { r l } { \\underset { y \\in \\mathbb { R } ^ { m _ { 1 } + m _ { 2 } } , \\lambda \\in \\mathbb { R } ^ { n } } { \\mathrm { m a x i m i z e } } } & { q ^ { \\top } y + l ^ { \\top } \\lambda ^ { + } - u ^ { \\top } \\lambda ^ { - } } \\\\ { \\mathrm { s u b j e c t ~ t o : } } & { c - K ^ { \\top } y = \\lambda } \\\\ & { y _ { 1 : m _ { 1 } } \\geq 0 } \\\\ & { \\lambda \\in \\Lambda ~ , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            486,
+            530,
+            754,
+            616
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $G \\in \\mathbb { R } ^ { m _ { 1 } \\times n }$ , $\\in \\mathbb { R } ^ { m _ { 2 } \\times n } , c \\in \\mathbb { R } ^ { n } , h \\in \\mathbb { R } ^ { m _ { 1 } } , b \\in \\mathbb { R } ^ { m _ { 2 } } , l \\in ( \\mathbb { R } \\cup \\{ - \\infty \\} ) ^ { n } , u \\in ( \\mathbb { R } \\cup \\{ \\infty \\} ) ^ { n } .$ , $K ^ { \\top } = { \\left( G ^ { \\top } , A ^ { \\top } \\right) } , q ^ { \\top } : = { \\left( h ^ { \\top } , b ^ { \\top } \\right) }$ , a nd ",
+        "bbox": [
+            171,
+            622,
+            826,
+            655
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cee711c233ca406d949fdec1e51ccc86ce2948b3dcab4354c9130b2fa29d9027.jpg",
+        "text": "$$\n\\Lambda = \\Lambda _ { 1 } \\times \\cdot \\cdot \\times \\Lambda _ { n } \\quad \\Lambda _ { i } : = \\left\\{ \\begin{array} { l l } { \\{ 0 \\} } & { l _ { i } = - \\infty , u _ { i } = \\infty , } \\\\ { \\mathbb { R } ^ { - } } & { l _ { i } = - \\infty , u _ { i } \\in \\mathbb { R } } \\\\ { \\mathbb { R } ^ { + } } & { l _ { i } \\in \\mathbb { R } , u _ { i } = \\infty } \\\\ { \\mathbb { R } } & { \\mathrm { o t h e r w i s e } } \\end{array} \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            307,
+            662,
+            686,
+            731
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "is the set of variables $\\lambda$ such that the dual objective is finite. This pair of primal-dual problems is equivalent to the saddle-point problem: ",
+        "bbox": [
+            173,
+            738,
+            825,
+            767
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f9a2f77aff7777a01e61d2816b42b29e4855aedf081227b381c967cfb625cf65.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { x \\in X } \\operatorname* { m a x } _ { y \\in Y } { \\mathcal { L } } ( x , y ) : = c ^ { \\top } x - y ^ { \\top } K x + q ^ { \\top } y\n$$",
+        "text_format": "latex",
+        "bbox": [
+            356,
+            773,
+            642,
+            801
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "with $X : = \\{ x \\in \\mathbb { R } ^ { n } : l \\leq x \\leq u \\}$ , and $Y : = \\{ y \\in \\mathbb { R } ^ { m _ { 1 } + m _ { 2 } } : y _ { 1 : m _ { 1 } } \\geq 0 \\}$ ",
+        "bbox": [
+            174,
+            808,
+            658,
+            825
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "PDHG. When specialized to (2), the PDHG algorithm takes the form: ",
+        "bbox": [
+            173,
+            832,
+            645,
+            848
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a435d4e1b0312ad6ca61c946ca1f5f741fa750425d06da15926506d950b76a2e.jpg",
+        "text": "$$\n\\begin{array} { r l } & { x ^ { k + 1 } = \\underset { X } { \\mathbf { p r o j } } ( x ^ { k } - \\tau ( c - K ^ { \\top } y ^ { k } ) ) } \\\\ & { y ^ { k + 1 } = \\underset { Y } { \\mathbf { p r o j } } ( y ^ { k } + \\sigma ( q - K ( 2 x ^ { k + 1 } - x ^ { k } ) ) ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            348,
+            853,
+            648,
+            910
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\tau , \\sigma > 0$ are primal and dual step sizes, respectively. PDHG is known to converge to an optimal solution when $\\tau \\sigma \\| \\dot { \\boldsymbol { K } } \\| _ { 2 } ^ { 2 } \\leq 1$ [20, 21]. We reparameterize the step sizes by ",
+        "bbox": [
+            171,
+            90,
+            823,
+            119
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3c1915959db15f2e31ecfc89f3ec5163161ee68c54c4f1333d4b18c3a06053fd.jpg",
+        "text": "$$\n\\tau = \\eta / \\omega \\quad \\mathrm { a n d } \\quad \\sigma = \\omega \\eta \\qquad \\mathrm { w i t h } \\ \\eta \\in ( 0 , \\infty ) \\quad \\mathrm { a n d } \\quad \\omega \\in ( 0 , \\infty ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            276,
+            127,
+            720,
+            145
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We call $\\omega \\in ( 0 , \\infty )$ the primal weight, and $\\eta \\in ( 0 , \\infty )$ the step size. Under this reparameterization PDHG converges for all $\\eta \\leq 1 / \\| K \\| _ { 2 }$ . This allows us to control the scaling between the primal and dual iterates with a single parameter $\\omega$ . We use the term primal weight to describe $\\omega$ because it weights the primal variables in the following norm: ",
+        "bbox": [
+            173,
+            151,
+            825,
+            209
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ccdbb36d2530bbde5d7fd49c08cfdba649b76b4bda16ba5fe4bfb4d9a248d3b9.jpg",
+        "text": "$$\n\\| z \\| _ { \\omega } : = \\sqrt { \\omega \\| x \\| _ { 2 } ^ { 2 } + \\frac { \\| y \\| _ { 2 } ^ { 2 } } { \\omega } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            406,
+            217,
+            591,
+            252
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "This norm plays a role in the theory for PDHG [20] and later algorithmic discussions. ",
+        "bbox": [
+            176,
+            257,
+            733,
+            273
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For the baseline PDHG algorithm that we use for comparisons, we consider two simple choices for $\\eta$ and $\\omega$ . For the step size, set $\\eta = 0 . 9 / \\lVert K \\rVert _ { 2 }$ where $\\| K \\| _ { 2 }$ is estimated via power iteration, and for the primal weight we set $\\omega = 1$ ; this is similar to the default parameters in the standard PDHG implementation in ODL [2]. ",
+        "bbox": [
+            173,
+            280,
+            825,
+            337
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 Practical algorithmic improvements ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            351,
+            506,
+            368
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this section, we detail these enhancements, and defer further experimental testing of them to Section 4 and ablation studies to Appendix C. While our enhancements are inspired by theory, our focus is on practical performance. The algorithm as a whole has no convergence guarantee, although some individual enhancements do; see Section 3.6 for further discussion. ",
+        "bbox": [
+            173,
+            376,
+            825,
+            431
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 presents pseudo-code for PDLP after preprocessing steps. We modify the step sizes (Section 3.1), add restarts (Section 3.2), and dynamically update the primal weights (Section 3.3). Before running Algorithm 1 we apply presolve (Section 3.4) and diagonal preconditioning (Section 3.5). There are some minor differences between the pseudo-code and the actual code. In particular, we only evaluate the restart or termination criteria (Line 10) every 40 iterations. This reduces the associated overheads with minimal impact on the total number of iterations. We also check the termination criteria before beginning the algorithm or if we detect a numerical error. ",
+        "bbox": [
+            173,
+            438,
+            825,
+            536
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1: PDLP (after preconditioning and presolve) ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            556,
+            549,
+            571
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "1 Input: An initial solution z0,0;   \n2 Initialize outer loop counter $n \\gets 0$ , total iterations $k  0$ , step size $\\hat { \\eta } ^ { 0 , 0 } \\gets 1 / \\| K \\| _ { \\infty }$ , primal   \nweight $\\omega ^ { 0 } $ InitializePrimalWeight $( c , q )$ ;   \n3 repeat   \n4 $t \\gets 0$ ;   \n5 repeat   \n6 $\\begin{array} { r l } & { z ^ { n , t + 1 } , \\eta ^ { n , t + 1 } , \\hat { \\eta } ^ { n , t + 1 } \\xleftarrow { \\mathrm { A d a p t i v e S t e p } \\ 0 \\mathrm { f P D H } \\mathfrak { G } } ( z ^ { n , t } , \\omega ^ { n } , \\hat { \\eta } ^ { n , t } , k ) : } \\\\ & { \\bar { z } ^ { n , t + 1 } \\xleftarrow { \\frac { 1 } { \\sum _ { i = 1 } ^ { t + 1 } \\eta ^ { n , i } } \\sum _ { i = 1 } ^ { t + 1 } \\eta ^ { n , i } z ^ { n , i } ; } } \\\\ & { z _ { \\mathrm { c } } ^ { n , t + 1 } \\xleftarrow { \\mathrm { G e t R e s t a r t c a n d i d a t e } ( z ^ { n , t + 1 } , \\bar { z } ^ { n , t + 1 } , z ^ { n , 0 } ) } ; } \\\\ & { t  t + 1 , k  k + 1 ; } \\end{array}$   \n7   \n8   \n9   \n10 until restart or termination criteria holds;   \n11 restart the outer loop. $z ^ { n + 1 , 0 } \\gets z _ { \\mathrm { c } } ^ { n , t }$ , $n \\gets n + 1$ ;   \n12 $\\omega ^ { n } \\gets$ PrimalWeightUpdate $( z ^ { n , 0 } , z ^ { n - 1 , 0 } , \\omega ^ { n - 1 } )$ ;   \n13 until termination criteria holds;   \n14 Output: $z ^ { n , 0 }$ . ",
+        "bbox": [
+            158,
+            575,
+            790,
+            780
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            155,
+            780,
+            387,
+            809
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 Step size choice ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            835,
+            321,
+            851
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The convergence analysis [20, Equation (15)] of PDHG (equation (3)) relies on a small constant step size ",
+        "bbox": [
+            171,
+            854,
+            823,
+            881
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6cf2d37ac21c1a1c44f3b9be43c347c9b0adb3fefc846699cf500560050770a8.jpg",
+        "text": "$$\n\\eta \\leq \\frac { \\| z ^ { k + 1 } - z ^ { k } \\| _ { \\omega } ^ { 2 } } { 2 ( y ^ { k + 1 } - y ^ { k } ) ^ { \\top } K ( x ^ { k + 1 } - x ^ { k } ) }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            379,
+            881,
+            619,
+            916
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 2: One step of PDHG using our step size heuristic ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            94,
+            578,
+            109
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            113,
+            521,
+            127
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Function AdaptiveStepOfPDHG $( z ^ { n , t } , \\omega ^ { n } , \\hat { \\eta } ^ { n , t } , k )$ :   \n2 $( x , y ) \\gets z ^ { n , t }$ , $\\eta  \\hat { \\eta } ^ { n , t }$ ;   \n3 for i = 1, . . . , ∞ do   \n4 $\\begin{array} { r } { x ^ { \\prime }  \\mathbf { p r o j } _ { X } ( x - \\frac { \\eta } { \\omega ^ { n } } ( c - K ^ { \\top } y ) ) } \\end{array}$ ;   \n5 $y ^ { \\prime }  \\mathbf { p r o j } _ { Y } ( y + \\eta \\omega ^ { n } ( q - K ( 2 x ^ { \\prime } - x ) ) )$ ;   \n6 η¯ ← k(x −x,y −y)k ωn2(y0−y)>K(x0−x) ;   \n7 $\\eta ^ { \\prime }  \\operatorname* { m i n } ( ( 1 - ( k + 1 ) ^ { - 0 . 3 } ) \\bar { \\eta } , ( 1 + ( k + 1 ) ^ { - 0 . 6 } ) \\eta ) ;$   \n8 if $\\eta \\leq \\bar { \\eta }$ then   \n9 return $( x ^ { \\prime } , y ^ { \\prime } ) , \\eta , \\eta ^ { \\prime }$   \n10 end   \n11 $\\eta  \\eta ^ { \\prime }$ ;   \n12 end ",
+        "bbox": [
+            158,
+            117,
+            581,
+            297
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $z ^ { k } = ( x ^ { k } , y ^ { k } )$ . Classically one would ensure (5) by picking $\\begin{array} { r } { \\eta = \\frac { 1 } { \\left. K \\right. _ { 2 } } } \\end{array}$ . This is overly pessimistic and requires estimation of $\\| K \\| _ { 2 }$ . Instead our AdaptiveStepOfPDHG adjusts $\\eta$ dynamically to ensure that (5) is satisfied. If (5) isn’t satisfied, we abort the step; i.e., we reduce $\\eta$ , and try again. If (5) is satisfied we accept the step. This is described in Algorithm 2. Note that in Algorithm 2 η¯ ≥ 1kKk2 holds always, and from this one can show the resulting step size $\\begin{array} { r } { \\eta \\geq \\frac { 1 - o ( 1 ) } { \\| K \\| _ { 2 } } } \\end{array}$ holds as $k \\to \\infty$ . ",
+        "bbox": [
+            173,
+            327,
+            826,
+            421
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Our step size routine compares favorably in practice with the line search by Malitsky and Pock [43] (See Appendix C.1). ",
+        "bbox": [
+            168,
+            428,
+            825,
+            457
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 Adaptive restarts ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            465,
+            334,
+            481
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In PDLP, we adaptively restart the PDHG algorithm in each outer iteration. The key to our restarts at the $n$ -th outer iteration is the normalized duality gap at $z$ which for any radius $r \\in ( 0 , \\infty )$ is defined by ",
+        "bbox": [
+            173,
+            484,
+            825,
+            525
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b9cd42f772726e711c7ebcf0c210a90767149e7c74cd301969679501973664cb.jpg",
+        "text": "$$\n\\rho _ { r } ^ { n } ( z ) : = \\frac { 1 } { r } \\operatorname* { m a x i m i z e } _ { ( \\hat { x } , \\hat { y } ) \\in \\{ \\hat { z } \\in Z : \\| \\hat { z } - z \\| _ { \\omega ^ { n } } \\leq r \\} } \\{ \\mathcal { L } ( x , \\hat { y } ) - \\mathcal { L } ( \\hat { x } , y ) \\} ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            313,
+            523,
+            683,
+            556
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "introduced by [7]. Unlike the standard duality gap ",
+        "bbox": [
+            173,
+            559,
+            504,
+            574
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8b64e81f868ec5fa5e792d01066d5dcb762945d541c6ca4aa45bb8d7152c5ef3.jpg",
+        "text": "$$\n\\operatorname* { m a x i m i z e } _ { ( { \\hat { x } } , { \\hat { y } } ) \\in Z } \\{ { \\mathcal { L } } ( x , { \\hat { y } } ) - { \\mathcal { L } } ( { \\hat { x } } , y ) \\} ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            392,
+            578,
+            602,
+            604
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "the normalized duality gap is always a finite quantity. Furthermore, for any value of $r$ and $\\omega ^ { n }$ , the normalized duality gap $\\rho _ { r } ^ { n } ( z )$ is 0 if and only if the solution $z$ is an optimal solution to (2) [7]; thus, it provides a valid metric for measuring progress towards the optimal solution. The normalized duality gap is computable in linear time [7]. For brevity, define $\\mu _ { n } ( z , z _ { \\mathrm { r e f } } )$ as the normalized duality gap at $z$ with radius $\\| z - z _ { \\mathrm { r e f } } \\| _ { \\omega ^ { n } }$ , i.e., ",
+        "bbox": [
+            173,
+            609,
+            826,
+            679
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/af1a0539acb3ddcc4a0dd4ba80d887133a7cfe3203570a7b4b2b1b1e57bf7882.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mu _ { n } ( z , z _ { \\mathrm { r e f } } ) : = \\rho _ { \\parallel z - z _ { \\mathrm { r e f } } \\parallel _ { \\omega ^ { n } } } ^ { n } ( z ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            400,
+            678,
+            596,
+            696
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $z _ { \\mathrm { r e f } }$ is a user-chosen reference point. ",
+        "bbox": [
+            176,
+            698,
+            455,
+            713
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Choosing the restart candidate. To choose the restart candidate $z _ { \\mathrm { c } } ^ { n , t + 1 }$ we call ",
+        "bbox": [
+            174,
+            720,
+            709,
+            737
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/802e3069d5677d9718347b8a61396fa27544bf6c401d7c91cbcfb0f7a1520669.jpg",
+        "text": "$$\n( z ^ { n , t + 1 } , \\bar { z } ^ { n , t + 1 } , z ^ { n , 0 } ) : = \\left\\{ \\begin{array} { l l } { z ^ { n , t + 1 } } & { \\mu _ { n } \\big ( z ^ { n , t + 1 } , z ^ { n , 0 } \\big ) < \\mu _ { n } \\big ( \\bar { z } ^ { n , t + 1 } , z ^ { n , 0 } \\big ) } \\\\ { \\bar { z } ^ { n , t + 1 } } & { \\mathrm { o t h e r w i s e } \\ . } \\end{array} \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            338,
+            742,
+            820,
+            779
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This choice is justified in Remark 5 of [7]. ",
+        "bbox": [
+            176,
+            784,
+            452,
+            799
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Restart criteria. We define three parameters: $\\beta _ { \\mathrm { s u f f i c i e n t } } \\ \\in \\ ( 0 , 1 ) .$ , $\\beta _ { \\mathrm { n e c e s s a r y } } ~ \\in ~ \\left( 0 , \\beta _ { \\mathrm { s u f f i c i e n t } } \\right)$ and $\\beta _ { \\mathrm { a r t i f i c i a l } } \\in ( 0 , 1 )$ . In PDLP we use $\\beta _ { \\mathrm { s u f f i c i e n t } } = 0 . 9$ , $\\beta _ { \\mathrm { n e c e s s a r y } } = 0 . 1$ , and $\\beta _ { \\mathrm { a r t i f i c i a l } } = 0 . 5$ . The algorithm restarts if one of three conditions holds: ",
+        "bbox": [
+            176,
+            806,
+            823,
+            848
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "(i) (Sufficient decay in normalized duality gap) $\\mu _ { n } ( z _ { \\mathrm { c } } ^ { n , t + 1 } , z ^ { n , 0 } ) \\leq \\beta _ { \\mathrm { s u f f i c i e n t } } \\mu _ { n } ( z ^ { n , 0 } , z ^ { n - 1 , 0 } )$ , (ii) (Necessary decay $^ +$ no local progress in normalized duality gap) ",
+        "bbox": [
+            171,
+            852,
+            825,
+            893
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3075144ff69af48c2ee2f33cea17f427c68d1c01f18fc3327076b68813f722b6.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mu _ { n } ( z _ { \\mathrm { c } } ^ { n , t + 1 } , z ^ { n , 0 } ) \\leq \\beta _ { \\mathrm { n e c e s s a r y } } \\mu _ { n } ( z ^ { n , 0 } , z ^ { n - 1 , 0 } ) \\quad \\mathrm { a n d } \\quad \\mu _ { n } ( z _ { \\mathrm { c } } ^ { n , t + 1 } , z ^ { n , 0 } ) > \\mu _ { n } ( z _ { \\mathrm { c } } ^ { n , t } , z ^ { n , 0 } ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            222,
+            895,
+            805,
+            912
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "(iii) (Long inner loop) $t \\geq \\beta _ { \\mathrm { a r t i f i c i a l } } k$ ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            92,
+            426,
+            106
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The motivation for (i) is presented in [7]; it guarantees the linear convergence of restarted PDHG on LP problems. The second condition in (ii) is inspired by adaptive restart schemes for accelerated gradient descent where restarts are triggered if the function value increases [57]. The first inequality in (ii) provides a safeguard for the second one, preventing the algorithm restarting every inner iteration or never restarting. The motivation for (iii) relates to the primal weights (Section 3.3). In particular, primal weight updates only occur after a restart, and condition (iii) ensures that the primal weight will be updated infinitely often. This prevents a bad choice of primal weight in earlier iterations causing progress to stall for a long time. ",
+        "bbox": [
+            173,
+            111,
+            826,
+            223
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.3 Primal weight updates ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            231,
+            370,
+            246
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The primal weight is initialized using ",
+        "bbox": [
+            174,
+            250,
+            419,
+            265
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8e4a8ec379ef2264d0dc061c8c7b2d3496df4bfe96281b84e9a776a1d63612b1.jpg",
+        "text": "$$\n\\mathrm { I n i t i a l i z e P r i m a l W e i g h t } ( c , q ) : = \\left\\{ \\begin{array} { l l } { \\frac { \\| c \\| _ { 2 } } { \\| q \\| _ { 2 } } } & { \\| c \\| _ { 2 } , \\| q \\| _ { 2 } > \\epsilon _ { \\mathrm { z e r o } } } \\\\ { 1 } & { \\mathrm { o t h e r w i s e } } \\end{array} \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            279,
+            267,
+            715,
+            310
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\epsilon _ { \\mathrm { z e r o } }$ is a small nonzero tolerance. This primal weight update scheme guarantees scale invariance. In particular, in Appendix A we consider PDHG with $\\epsilon _ { \\mathrm { z e r o } } = 0$ , $\\eta = 0 . 9 / \\| K \\| _ { 2 }$ and $\\omega =$ InitializePrimalWeight $( c , q )$ . In this simplified setting, we prove that if we multiply the objective, constraints, or the right hand side and variable bounds by a scalar then the iterate behaviour remain identical (up to a scaling factor). ",
+        "bbox": [
+            173,
+            313,
+            826,
+            383
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 3: Primal weight update ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            401,
+            408,
+            416
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "1 Function PrimalWeightUpdate(zn,0, zn−1,0, ωn−1): ",
+        "bbox": [
+            161,
+            420,
+            547,
+            434
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "2 $\\Delta _ { x } ^ { n } = \\lVert x ^ { n , 0 } - x ^ { \\bar { n - 1 } , 0 } \\rVert _ { 2 } , \\quad \\Delta _ { y } ^ { n } = \\lVert y ^ { n , 0 } - y ^ { n - 1 , 0 } \\rVert _ { 2 } ;$   \n3 if $\\Delta _ { x } ^ { n } > \\epsilon _ { z e r o }$ $\\Delta _ { y } ^ { n } > \\epsilon _ { z e r o }$   \n4 $\\begin{array} { r l } { \\exp \\left( \\theta \\log \\left( \\frac { \\Delta _ { y } ^ { n } } { \\Delta _ { x } ^ { n } } \\right) + ( 1 - \\theta ) \\log \\left( \\omega ^ { n - 1 } \\right) \\right) } & { { } } \\end{array}$   \n5 else   \n6 return $\\omega ^ { n - 1 }$ ;   \n7 end ",
+        "bbox": [
+            160,
+            426,
+            553,
+            535
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 3 aims to choose the primal weight $\\omega ^ { n }$ such that distance to optimality in the primal and dual is the same, i.e., $\\| ( x ^ { n , t } - \\bar { x ^ { \\star } } , \\mathbf { 0 } ) \\| _ { \\omega ^ { n } } \\approx \\| ( \\mathbf { 0 } , y ^ { n , t } - y ^ { \\star } ) \\| _ { \\omega ^ { n } }$ . By definition of $\\| \\cdot \\| _ { \\omega }$ , ",
+        "bbox": [
+            171,
+            553,
+            825,
+            583
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3874c175d2bcf5b31d209d444a6210da4d9892f08f2d15d7be5418494ef377f2.jpg",
+        "text": "$$\n\\| ( x ^ { n , t } - x ^ { \\star } , \\mathbf { 0 } ) \\| _ { \\omega ^ { n } } = \\omega ^ { n } \\| x ^ { n , t } - x ^ { \\star } \\| _ { 2 } , \\quad \\| ( \\mathbf { 0 } , y ^ { n , t } - y ^ { \\star } ) \\| _ { \\omega ^ { n } } = \\frac { 1 } { \\omega ^ { n } } \\| y ^ { n , t } - y ^ { \\star } \\| _ { 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            225,
+            587,
+            769,
+            616
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Setting these two terms equal yields beforehand, but we attempt to estim $\\begin{array} { r } { \\omega ^ { n } = \\frac { \\| y ^ { n , t } - y ^ { \\star } \\| _ { 2 } } { \\| x ^ { n , t } - x ^ { \\star } \\| _ { 2 } } } \\end{array}$ f course, the quantity . However, the quant kyn,t−y?k2 is unknowncan change $\\Delta _ { y } ^ { n } / \\Delta _ { x } ^ { n }$ $\\Delta _ { y } ^ { n } / \\Delta _ { x } ^ { n }$ wildly from one restart to another, causing $\\omega ^ { n }$ to oscillate. To dampen variations in $\\omega ^ { n }$ , we first move to a log-scale where the primal weight is symmetric, i.e., $\\log ( 1 / \\omega ^ { n } ) = - \\log ( \\omega ^ { n } )$ , and perform a exponential smoothing with parameter $\\theta \\in [ 0 , 1 ]$ . In PDLP, we use $\\theta = 0 . 5$ . ",
+        "bbox": [
+            173,
+            619,
+            825,
+            698
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "There are several important differences between our primal weight heuristic and literature [36, 37]. For example, [36,37] make relatively small changes to the primal weights at each iteration, attempting to balance the primal and dual residual. These changes have to be diminishingly small because, in our experience, PDHG may be unstable if they are too big. In contrast, in our method the primal weight is only updated during restarts, which in practice allows for much larger changes without instability issues. Moreover, our scheme tries to balance the weighted distance traveled in the primal and dual rather than the residuals [36, 37]. ",
+        "bbox": [
+            173,
+            703,
+            825,
+            801
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.4 Presolve ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            809,
+            272,
+            824
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Presolving refers to transformation steps that simplify the input problem before starting the optimization solver. These steps span from relatively easy transformations such as detecting inconsistent bounds, removing empty rows and columns of $K$ , and removing variables whose lower and upper bounds are equal, to more complex operations such as detecting duplicate rows in $K$ and tightening bounds. Presolve is a standard component of traditional LP solvers [44]. We are not aware of presolve being combined with PDHG for LP. However, [41, 42] combine presolve with other FOMs. ",
+        "bbox": [
+            174,
+            827,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As an experiment to measure the impact of presolve, we used PaPILO [29], an open-source presolving library. For technical reasons, it was easier to use PaPILO as a standalone executable than as a library. We simulate its effect by simply solving the preprocessed instances. Convergence criteria are evaluated with respect to the presolved instance, not the original problem. ",
+        "bbox": [
+            174,
+            90,
+            825,
+            147
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.5 Diagonal Preconditioning ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            160,
+            392,
+            175
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Preconditioning is a popular heuristic in optimization for improving the convergence of FOMs. To avoid factorizations, we only consider diagonal preconditioners. Our goal is to rescale the constraint matrix $K = ( G , A )$ to $\\tilde { K } = ( \\tilde { G } , \\tilde { A } ) = \\tilde { D _ { 1 } K } D _ { 2 }$ with positive diagonal matrices $D _ { 1 }$ and $D _ { 2 }$ , so that the resulting matrix $\\tilde { K }$ is “well balanced”. Such preconditioning creates a new LP instance that replaces $A , G , c , b , h , u$ , and $l$ in (1) with $\\tilde { G } , \\tilde { A }$ , $\\hat { x } = D _ { 2 } ^ { - 1 } x$ , $\\tilde { c } = D _ { 2 } c$ , $( \\tilde { b } , \\tilde { h } ) = D _ { 1 } ( b , h )$ , $\\tilde { u } = D _ { 2 } ^ { - 1 } u$ and $\\tilde { l } = D _ { 2 } ^ { - 1 } l$ . Common choices for $D _ { 1 }$ and $D _ { 2 }$ include: ",
+        "bbox": [
+            173,
+            180,
+            825,
+            272
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "• No scaling: Solve the original LP instance (1) without additional scaling, namely $D _ { 1 } = D _ { 2 } = I$ . • Pock-Chambolle [59]: Pock and Chambolle proposed a family of diagonal preconditioners3 for PDHG parameterized by $\\alpha$ , where the diagonal matrices are defined by $( D _ { 1 } ) _ { j j } = \\sqrt { \\| K _ { j , \\cdot } \\| _ { 2 - \\alpha } }$ for $j = 1 , . . . , m _ { 1 } + m _ { 2 }$ and $( D _ { 2 } ) _ { i i } = \\sqrt { \\| K _ { \\cdot , i } \\| _ { \\alpha } }$ for $i = 1 , . . . , n$ . We use $\\alpha = 1$ in PDLP (we also tested $\\alpha = 0$ and $\\alpha = 2$ ). This is the baseline diagonal preconditioner in the PDHG literature. • Ruiz [63]: Ruiz scaling is a popular algorithm in numerical linear algebra to equilibrate matrices. In an iteration of Ruiz scaling, the diagonal matrices are defined as $( D _ { 1 } ) _ { j j } = \\sqrt { \\| K _ { j , \\cdot } \\| _ { \\infty } }$ for $j = 1 , . . . , m _ { 1 } + m _ { 2 }$ and $( D _ { 2 } ) _ { i i } = \\sqrt { \\| K _ { \\cdot , i } \\| _ { \\infty } }$ for $i = 1 , . . . , n$ . Ruiz [63] shows that if this rescaling is applied iteratively, the infinity norm of each row and each column converge to 1. ",
+        "bbox": [
+            173,
+            281,
+            826,
+            436
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For the default PDLP settings, we apply a combination of Ruiz rescaling [63] and the preconditioning technique proposed by Pock and Chambolle [59]. In particular, we apply 10 iterations of Ruiz scaling and then apply the Pock-Chambolle scaling. To illustrate the effectiveness of our proposed scaling technique, we compare it against these three common techniques in Appendix C.5. ",
+        "bbox": [
+            173,
+            446,
+            825,
+            502
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.6 Theoretical guarantees for the above enhancements ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            515,
+            570,
+            530
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "While PDLP’s enhancements are motivated by theory, some of them may not preserve theoretical guarantees as discussed below: ",
+        "bbox": [
+            174,
+            535,
+            825,
+            564
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "• We do not have a proof of convergence for the adaptive step size rule (Section 3.1).   \n• One can show our restart criteria (Section 3.2) preserve convergence guarantees by modifying the proof of [7] to a more general setting.   \n• Primal weight updates (Section 3.3) do not readily preserve convergence guarantees, but we conjecture that a proof of convergence is possible if they are updated infrequently.   \n• Presolve (Section 3.4) and diagonal preconditioning (Section 3.5) preserve theoretical guarantees because they can be viewed as applying PDHG to an LP instance with different data. ",
+        "bbox": [
+            215,
+            573,
+            825,
+            715
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 Numerical experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            731,
+            400,
+            750
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Our numerical experiments study the effectiveness of PDLP primarily with respect to traditional LP applications and benchmark sets. Section 4.1 describes the setup for the experiments. Section 4.2 demonstrates PDLP’s improvements over baseline PDHG. Section 4.3 compares PDLP with other FOMs. Section 4.4 highlights benchmark instances where PDLP outperforms a commercial LP solver. Finally, Section 4.5 illustrates the ability of PDLP to scale to a large application where barrier and simplex-based solvers run out of memory. The supplemental materials contain extensive ablation studies and additional instructions for reproducing the experiments. ",
+        "bbox": [
+            173,
+            757,
+            825,
+            856
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.1 Experimental setup ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            92,
+            349,
+            106
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Optimality termination criteria. PDLP terminates with an approximately optimal solution when the primal-dual iterates $x \\in X$ , $y \\in Y$ , $\\lambda \\in \\Lambda$ , satisfy: ",
+        "bbox": [
+            174,
+            109,
+            821,
+            138
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/36669c2e6fbedd209de8145239cf1be7df5ab95fcb5ad51aab6663d3523af302.jpg",
+        "text": "$$\n\\begin{array} { r l } & { | q ^ { \\top } y + l ^ { \\top } \\lambda ^ { + } - u ^ { \\top } \\lambda ^ { - } - c ^ { \\top } x | \\leq \\epsilon ( 1 + | q ^ { \\top } y + l ^ { \\top } \\lambda ^ { + } - u ^ { \\top } \\lambda ^ { - } | + | c ^ { \\top } x | ) } \\\\ & { \\qquad \\| ( { A x } - b ) \\| _ { 2 } \\leq \\epsilon ( 1 + \\| q \\| _ { 2 } ) } \\\\ & { \\qquad \\| c - K ^ { \\top } y - \\lambda \\| _ { 2 } \\leq \\epsilon ( 1 + \\| c \\| _ { 2 } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            253,
+            143,
+            743,
+            224
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "where $\\epsilon \\in ( 0 , \\infty )$ is the termination tolerance. Note that if (6) is satisfied with $\\epsilon = 0$ , then by LP duality we have found an optimal solution [35]. Indeed, (6a) is the duality gap, (6b) is primal feasibility, and (6c) is dual feasibility. We use these criteria to be consistent with those of SCS [54]. The PDHG algorithm does not explicitly include a reduced costs variable $\\lambda$ . Therefore, to evaluate the optimality termination criteria we compute $\\lambda = \\mathbf { p r o j } _ { \\Lambda } ( c - K ^ { \\top } y )$ . All instances considered have an optimal primal-dual solution. We use $\\epsilon = 1 0 ^ { - 8 }$ as a benchmark for high-quality solutions and $\\epsilon = \\dot { 1 } 0 ^ { - 4 }$ for moderately accurate solutions. ",
+        "bbox": [
+            173,
+            229,
+            825,
+            327
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Benchmark datasets. We use three datasets to compare algorithmic performance. One is the LP benchmark dataset of 56 problems, formed by merging the instances from “Benchmark of Simplex LP Solvers”, “Benchmark of Barrier LP solvers”, and “Large Network-LP Benchmark” from [45]. We also created a larger benchmark of 383 instances curated from LP relaxations of mixed-integer programming problems from the MIPLIB2017 collection [34] (see Appendix B) that we label MIP Relaxations. MIP Relaxations was used extensively during algorithmic development, e.g., for hyperparameter choices; we held out LP benchmark as a test set. Finally, we also performed some experiments on the Netlib LP benchmark [31], an historically important benchmark that is no longer state of the art for large-scale LP. ",
+        "bbox": [
+            174,
+            335,
+            825,
+            460
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Software. PDLP is implemented in an open-source Julia [15] module available at https: //github.com/google-research/FirstOrderLp.jl. The module also contains a baseline implementation of the extragradient method with many of the same enhancements as PDLP (labeled ‘Enh. Extragradient’). We compare with two external packages: SCS [54] version 2.1.3, an opensource generic cone solver based on ADMM, and Gurobi version 9.0.1, a state-of-the-art commercial LP solver. SCS supports two modes for solving the linear system that arises at each iteration, a direct method based on a cached LDL factorization (which is the default ‘SCS’) and an indirect method based on the conjugate gradient method (which we label ‘SCS (matrix-free)’). All solvers are run single-threaded. SCS and Gurobi are provided the same presolved instances as PDLP. ",
+        "bbox": [
+            173,
+            468,
+            825,
+            593
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Computing environment. We used two computing environments for our experiments: 1) e2-highmem-2 virtual machines (VMs) on Google Cloud Platform (GCP). Each VM provides two virtual CPUs and 16GB RAM. 2) A dedicated workstation with an Intel Xeon E5-2669 v3 processor and 128 GB RAM. This workstation has a license for Gurobi that permits at most one concurrent solve. Total compute time on GCP for all preliminary and final experiments was approximately 72, 000 virtual CPU hours. ",
+        "bbox": [
+            174,
+            603,
+            825,
+            685
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Initialization. All first-order methods use all-zero vectors as the initial starting points. ",
+        "bbox": [
+            173,
+            695,
+            750,
+            710
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Metrics. We use the term KKT passes to refer to the number of matrix multiplications by both $K$ and $K ^ { \\top }$ . Given that the most expensive operation in our algorithm is matrix-vector multiplication, this metric is less noisy than runtime for comparing performance between matrix-free solvers. SGM10 stands for shifted geometric mean with shift 10, which is computed by adding 10 to all data points, taking the geometric mean, and then subtracting 10. Unsolved instances are assigned values corresponding to the limits specified in the next paragraph. ",
+        "bbox": [
+            174,
+            719,
+            825,
+            803
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Time and KKT pass limits. For Section 4.2 we impose a limit on the KKT passes of 100, 000.   \nFor Section 4.3 we impose a time limit of 1 hour. ",
+        "bbox": [
+            174,
+            810,
+            825,
+            839
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.2 Impact of PDLP’s improvements ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            849,
+            441,
+            866
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The y-axes of Figure 1 display the SGM10 of the KKT passes normalized by the value for baseline PDHG. We can see, with the exception of presolve for LP benchmark at tolerance $1 0 ^ { - 4 }$ , each of our modifications described in Section 3 improves the performance of PDHG. ",
+        "bbox": [
+            176,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/cf07ba9149d88bf36db5d069d5bfdb95182df7c308b1a0cf6b0f32d746d94b6c.jpg",
+        "image_caption": [
+            "Figure 1: Summary of relative impact of PDLP’s improvements "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            88,
+            825,
+            207
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/495c51e32202a8940dcaf7bd76eccbc8cbf088dad2e040d7d6474b010e4021d0.jpg",
+        "image_caption": [
+            "Figure 2: Number of problems solved for MIP Relaxations (top), LP benchmark (middle), and Netlib (bottom) datasets. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            251,
+            802,
+            558
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.3 Comparison with other first-order baselines ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            635,
+            517,
+            650
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We compared PDLP with several other first-order baselines: SCS [54], in both direct (default) mode and matrix-free mode, and our enhanced implementation of the extragradient method [39, 48]. For SCS in matrix-free mode, we include the KKT passes from the conjugate gradient solves; for SCS in direct mode there is no reasonable measure of KKT passes for the factorization and direct solve, so we only measure running time. The comparisons are summarized in Figure 2. ",
+        "bbox": [
+            174,
+            659,
+            825,
+            728
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.4 PDLP versus simplex and barrier ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            750,
+            444,
+            763
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this section, we test the performance of PDLP against the three methods available in Gurobi: barrier, primal simplex, and dual simplex. By default when provided multiple threads, Gurobi runs these three methods concurrently and terminates when the first method completes. We used default termination for Gurobi and set $\\epsilon = 1 0 ^ { - 8 }$ for PDLP. We ran experiments with instances from the MIP Relaxations and LP benchmark. Although, for most instances, Gurobi outperforms PDLP, we found problems for which PDLP exhibits moderate to significant gains. Table 1 gives examples of instances where our prototype implementation is within a factor of two of the best of the three Gurobi methods. While further improvements are needed for PDLP to truly compete with the portfolio of methods that Gurobi offers, we interpret these results as evidence that PDLP itself could be of value in this portfolio. ",
+        "bbox": [
+            173,
+            772,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/03926aeccfdafaa57941a177e5ad67df90e0f7b1aa2296522e047623f9ac51ce.jpg",
+        "table_caption": [
+            "Table 1: Instances from MIP Relaxations (top) and LP benchmark (bottom) where PDLP is within a factor of 2 of the best of all Gurobi methods. Time to solve in seconds. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Instance</td><td>PDLP</td><td>Gurobi Barrier</td><td>Gurobi Primal Simp.</td><td>Gurobi Dual Simp.</td></tr><tr><td>ex9</td><td>1.6</td><td>102.6</td><td>181.3</td><td>47.6</td></tr><tr><td>genus-sym-g62-2</td><td>2.1</td><td>10.7</td><td>6.7</td><td>33.2</td></tr><tr><td>highschooll-aigio</td><td>72.6</td><td>243.8</td><td>&gt;3600</td><td>&gt;3600</td></tr><tr><td>neos-578379</td><td>1.4</td><td>0.7</td><td>1.7</td><td>1.8</td></tr><tr><td>rwth-timetable</td><td>1870.3</td><td>&gt;3600</td><td>&gt;3600</td><td>&gt;3600</td></tr><tr><td>ex10</td><td>4.9</td><td>63.1</td><td>16.8</td><td>7.9</td></tr><tr><td>nug08-3rd</td><td>2.2</td><td>3.2</td><td>2219.2</td><td>24.1</td></tr><tr><td>savsched1</td><td>35.9</td><td>25.9</td><td>56.0</td><td>261.3</td></tr></table>",
+        "bbox": [
+            186,
+            126,
+            810,
+            271
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/6caaae77cb46da9d3c70ac37e56359c405474d84c4f67589ca792d51ba399bc8.jpg",
+        "table_caption": [
+            "Table 2: Solve time for PageRank instances. Gurobi barrier has crossover disabled, 1 thread. PDLP and SCS solve to $1 0 ^ { - 8 }$ relative accuracy. SCS is matrix-free. Baseline PDHG is unable to solve any instances. Presolve not applied. $\\mathrm { O O M } = \\cdot$ Out of Memory. The number of nonzero coefficients per instance is $8 \\times$ (# nodes) − 18. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td># nodes</td><td>PDLP</td><td>SCS</td><td>Gurobi Barrier</td><td>Gurobi Primal Simp.</td><td>Gurobi Dual Simp.</td></tr><tr><td>104</td><td>7.4 sec.</td><td>1.3 sec.</td><td>36 sec.</td><td>37 sec.</td><td>114 sec.</td></tr><tr><td>105</td><td>35 sec.</td><td>38 sec.</td><td>7.8 hr.</td><td>9.3 hr.</td><td>&gt;24 hr.</td></tr><tr><td>106</td><td>11 min.</td><td>25 min.</td><td>0OM</td><td>&gt;24 hr.</td><td>1</td></tr><tr><td>107</td><td>5.4 hr.</td><td>3.8 hr.</td><td>1</td><td>1</td><td>1</td></tr></table>",
+        "bbox": [
+            183,
+            348,
+            813,
+            435
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "4.5 Large-scale application: PageRank ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            460,
+            457,
+            476
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nesterov [50, equation (7.3)] gives an LP formulation of the standard “PageRank” problem. Although the LP formulation is not the best approach to computing PageRank, it is a source of very large instances. For a random scalable collection of PageRank instances, we used Barabási-Albert [9] preferential attachment graphs with approximately three edges per node; see Appendix D for details. The results are summarized in Table 2. ",
+        "bbox": [
+            174,
+            479,
+            826,
+            549
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 Conclusions and future work ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            560,
+            446,
+            578
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We find our experimental results encouraging for the application of FOMs like PDHG to LP. At a minimum, they provide evidence against the claim that FOMs are useful only when moderately accurate solutions are desired. The practical success of our heuristics that lack theoretical guarantees provides fresh motivation for theoreticians to study these methods. It is important, as well, to understand what drives the difficulty of some instances and how they could be transformed to solve more quickly. We hope the community will use the benchmarks and baselines released with this work as a starting point for further investigating new FOMs for LP. With additional algorithmic and implementation refinements, we believe that PDLP or similar approaches could become part of the standard toolkit for linear programming. ",
+        "bbox": [
+            173,
+            585,
+            825,
+            710
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments and Disclosure of Funding ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            722,
+            555,
+            739
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We thank Yura Malitsky for advice on parameter choices for the linesearch rule of [43]. ",
+        "bbox": [
+            174,
+            747,
+            743,
+            762
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The authors have no third-party funding or competing interests to declare. ",
+        "bbox": [
+            176,
+            767,
+            656,
+            782
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References   \n[1] T. Achterberg, R. E. Bixby, Z. Gu, E. Rothberg, and D. Weninger. Presolve reductions in mixed integer programming. INFORMS Journal on Computing, 32(2):473–506, 2020.   \n[2] J. Adler, H. Kohr, and O. Öktem. Operator discretization library (ODL), Jan. 2017.   \n[3] A. Alacaoglu, O. Fercoq, and V. Cevher. On the convergence of stochastic primal-dual hybrid gradient. arXiv preprint arXiv:1911.00799, 2019.   \n[4] A. Ali, E. Wong, and J. Z. Kolter. A semismooth Newton method for fast, generic convex programming. In International Conference on Machine Learning, pages 70–79. PMLR, 2017.   \n[5] B. Amos and J. Z. Kolter. OptNet: Differentiable optimization as a layer in neural networks. In D. Precup and Y. W. Teh, editors, Proceedings of the 34th International Conference on Machine Learning, volume 70 of Proceedings of Machine Learning Research, pages 136–145. PMLR, 06–11 Aug 2017.   \n[6] D. Applegate, M. Díaz, H. Lu, and M. Lubin. Infeasibility detection with primal-dual hybrid gradient for large-scale linear programming. arXiv preprint arXiv:2102.04592, 2021.   \n[7] D. Applegate, O. Hinder, H. Lu, and M. Lubin. Faster First-Order Primal-Dual Methods for Linear Programming using Restarts and Sharpness. arXiv preprint arXiv:2105.12715, 2021.   \n[8] K. J. Arrow, L. Hurwicz, and H. Uzawa. Studies in linear and non-linear programming. Stanford University Press, 1958.   \n[9] A.-L. Barabási and R. Albert. Emergence of scaling in random networks. Science, 286(5439):509–512, 1999.   \n[10] K. Basu, A. Ghoting, R. Mazumder, and Y. Pan. ECLIPSE: An extreme-scale linear program solver for web-applications. In H. D. III and A. Singh, editors, Proceedings of the 37th International Conference on Machine Learning, volume 119 of Proceedings of Machine Learning Research, pages 704–714, Virtual, 13–18 Jul 2020. PMLR.   \n[11] H. H. Bauschke and P. L. Combettes. Convex analysis and monotone operator theory in Hilbert spaces, volume 408. Springer, 2 edition, 2017.   \n[12] A. Beck. First-Order Methods in Optimization. Society for Industrial and Applied Mathematics, Philadelphia, PA, 2017.   \n[13] A. Beck and N. Guttmann-Beck. FOM–a MATLAB toolbox of first-order methods for solving convex optimization problems. Optimization Methods and Software, 34(1):172–193, 2019.   \n[14] S. R. Becker, E. J. Candès, and M. C. Grant. Templates for convex cone problems with applications to sparse signal recovery. Mathematical programming computation, 3(3):165, 2011.   \n[15] J. Bezanson, A. Edelman, S. Karpinski, and V. B. Shah. Julia: A fresh approach to numerical computing. SIAM Review, 59(1):65–98, 2017.   \n[16] S. Boyd, N. Parikh, E. Chu, B. Peleato, and J. Eckstein. Distributed optimization and statistical learning via the alternating direction method of multipliers. Foundations and Trends $\\textsuperscript { \\textregistered }$ in Machine learning, 3(1):1–122, 2011.   \n[17] S. Boyd and L. Vandenberghe. Convex optimization. Cambridge university press, 2004.   \n[18] A. Chambolle, M. J. Ehrhardt, P. Richtárik, and C.-B. Schonlieb. Stochastic primal-dual hybrid gradient algorithm with arbitrary sampling and imaging applications. SIAM Journal on Optimization, 28(4):2783–2808, 2018.   \n[19] A. Chambolle and T. Pock. A first-order primal-dual algorithm for convex problems with applications to imaging. Journal of mathematical imaging and vision, 40(1):120–145, 2011.   \n[20] A. Chambolle and T. Pock. On the ergodic convergence rates of a first-order primal–dual algorithm. Mathematical Programming, 159(1):253–287, 2016.   \n[21] L. Condat. A primal–dual splitting method for convex optimization involving Lipschitzian, proximable and linear composite terms. Journal of Optimization Theory and Applications, 158(2):460–479, 2013.   \n[22] G. Dantzig. Linear programming and extensions. Princeton university press, 2016.   \n[23] G. B. Dantzig. Origins of the simplex method. In A history of scientific computing, pages 141–151. Association for Computing Machinery, New York, NY, USA, 1990.   \n[24] J. Eckstein and D. P. Bertsekas. An alternating direction method for linear programming. Technical Report LIDS-P-1967, Laboratory for Information and Decision Systems, Massachusetts Institute of Technology, 1990.   \n[25] J. Eckstein and D. P. Bertsekas. On the Douglas–Rachford splitting method and the proximal point algorithm for maximal monotone operators. Mathematical Programming, 55(1-3):293– 318, 1992.   \n[26] J. Eckstein and G. Matyasfalvi. Efficient distributed-memory parallel matrix-vector multiplication with wide or tall unstructured sparse matrices. arXiv preprint arXiv:1812.00904, 2018.   \n[27] E. Esser, X. Zhang, and T. F. Chan. A general framework for a class of first order primal-dual algorithms for convex optimization in imaging science. SIAM Journal on Imaging Sciences, 3(4):1015–1046, 2010.   \n[28] C. Fougner and S. Boyd. Parameter selection and preconditioning for a graph form solver. In Emerging Applications of Control and Systems Theory, pages 41–61. Springer, 2018.   \n[29] G. Gamrath, D. Anderson, K. Bestuzheva, W.-K. Chen, L. Eifler, M. Gasse, P. Gemander, A. Gleixner, L. Gottwald, K. Halbig, et al. The SCIP optimization suite 7.0. ZIB-Report 20-10, Zuse Institut Berlin, 2020.   \n[30] M. Garstka, M. Cannon, and P. Goulart. COSMO: A conic operator splitting method for large convex problems. In European Control Conference, 2019.   \n[31] D. M. Gay. Electronic mail distribution of linear programming test problems. Mathematical Programming Society COAL Newsletter, 13:10–12, 1985.   \n[32] A. Gilpin, J. Pena, and T. Sandholm. First-order algorithm with $\\mathcal { O } ( \\ln ( 1 / \\epsilon ) )$ convergence for $\\epsilon$ -equilibrium in two-person zero-sum games. Mathematical programming, 133(1):279–298, 2012.   \n[33] P. Giselsson and S. Boyd. Linear convergence and metric selection for Douglas-Rachford splitting and ADMM. IEEE Transactions on Automatic Control, 62(2):532–544, 2016.   \n[34] A. Gleixner, G. Hendel, G. Gamrath, T. Achterberg, M. Bastubbe, T. Berthold, P. M. Christophel, K. Jarck, T. Koch, J. Linderoth, M. Lübbecke, H. D. Mittelmann, D. Ozyurt, T. K. Ralphs, D. Salvagnin, and Y. Shinano. MIPLIB 2017: Data-Driven Compilation of the 6th Mixed-Integer Programming Library. Mathematical Programming Computation, 2021.   \n[35] A. J. Goldman and A. W. Tucker. Theory of linear programming. Linear inequalities and related systems, 38:53–97, 1956.   \n[36] T. Goldstein, M. Li, and X. Yuan. Adaptive primal-dual splitting methods for statistical learning and image processing. In Advances in Neural Information Processing Systems, pages 2089–2097, 2015.   \n[37] T. Goldstein, M. Li, X. Yuan, E. Esser, and R. Baraniuk. Adaptive primal-dual hybrid gradient methods for saddle-point problems. arXiv preprint arXiv:1305.0546, 2013.   \n[38] B. He and X. Yuan. Convergence analysis of primal-dual algorithms for a saddle-point problem: from contraction perspective. SIAM Journal on Imaging Sciences, 5(1):119–149, 2012.   \n[39] G. M. Korpelevich. The extragradient method for finding saddle points and other problems. Matecon, 12:747–756, 1976.   \n[40] G. Lan, Z. Lu, and R. D. C. Monteiro. Primal-dual first-order methods with $\\mathcal { O } ( 1 / \\epsilon )$ iterationcomplexity for cone programming. Mathematical Programming, 126(1):1–29, Jan 2011.   \n[41] X. Li, D. Sun, and K.-C. Toh. An asymptotically superlinearly convergent semismooth newton augmented lagrangian method for linear programming. SIAM Journal on Optimization, 30(3):2410–2440, 2020.   \n[42] T. Lin, S. Ma, Y. Ye, and S. Zhang. An ADMM-based interior-point method for large-scale linear programming. Optimization Methods and Software, 36(2-3):389–424, 2021.   \n[43] Y. Malitsky and T. Pock. A first-order primal-dual algorithm with linesearch. SIAM Journal on Optimization, 28(1):411–432, 2018.   \n[44] I. Maros. Computational Techniques of the Simplex Method. International Series in Operations Research & Management Science. Springer US, 2002.   \n[45] H. Mittelmann. Decision tree for optimization software. http://plato.asu.edu/guide. html, 2021.   \n[46] V. Nair, S. Bartunov, F. Gimeno, I. von Glehn, P. Lichocki, I. Lobov, B. O’Donoghue, N. Sonnerat, C. Tjandraatmadja, P. Wang, R. Addanki, T. Hapuarachchi, T. Keck, J. Keeling, P. Kohli, I. Ktena, Y. Li, O. Vinyals, and Y. Zwols. Solving Mixed Integer Programs Using Neural Networks. arXiv preprint arXiv:2012.13349, Dec. 2020.   \n[47] I. Necoara, Y. Nesterov, and F. Glineur. Linear convergence of first order methods for nonstrongly convex optimization. Mathematical Programming, 175(1):69–107, May 2019.   \n[48] A. Nemirovski. Prox-method with rate of convergence $O ( 1 / t )$ for variational inequalities with Lipschitz continuous monotone operators and smooth convex-concave saddle point problems. SIAM Journal on Optimization, 15(1):229–251, 2004.   \n[49] Y. Nesterov. A method of solving a convex programming problem with convergence rate $O ( 1 / k ^ { 2 } )$ . Soviet Mathematics Doklady, 27(2):372–376, 1983.   \n[50] Y. Nesterov. Subgradient methods for huge-scale optimization problems. Mathematical Programming, 146:275–297, 2014.   \n[51] Y. Nesterov and A. Nemirovskii. Interior-point polynomial algorithms in convex programming, volume 13. SIAM, 1994.   \n[52] B. O’Donoghue. Operator splitting for a homogeneous embedding of the monotone linear complementarity problem. arXiv preprint arXiv:2004.02177, 2020.   \n[53] B. O’Donoghue, E. Chu, N. Parikh, and S. Boyd. Conic optimization via operator splitting and homogeneous self-dual embedding. Journal of Optimization Theory and Applications, 169(3):1042–1068, June 2016.   \n[54] B. O’Donoghue, E. Chu, N. Parikh, and S. Boyd. SCS: Splitting conic solver, version 2.1.0. https://github.com/cvxgrp/scs, Nov. 2017.   \n[55] W. Orchard-Hays. History of mathematical programming systems. IEEE Annals of the History of Computing, 6(3):296–312, 1984.   \n[56] D. O’Connor and L. Vandenberghe. On the equivalence of the primal-dual hybrid gradient method and Douglas–Rachford splitting. Mathematical Programming, 179(1):85–108, 2020.   \n[57] B. O’Donoghue and E. Candes. Adaptive restart for accelerated gradient schemes. Foundations of computational mathematics, 15(3):715–732, 2015.   \n[58] N. Parikh and S. Boyd. Proximal algorithms. Foundations and Trends $\\textsuperscript { \\textregistered }$ in Optimization, 1(3):127–239, 2014.   \n[59] T. Pock and A. Chambolle. Diagonal preconditioning for first order primal-dual algorithms in convex optimization. In 2011 International Conference on Computer Vision, pages 1762–1769. IEEE, 2011.   \n[60] T. Pock, D. Cremers, H. Bischof, and A. Chambolle. An algorithm for minimizing the mumfordshah functional. In 2009 IEEE 12th International Conference on Computer Vision, pages 1133–1140. IEEE, 2009.   \n[61] J. Renegar. Accelerated first-order methods for hyperbolic programming. Mathematical Programming, 173(1):1–35, Jan 2019.   \n[62] R. T. Rockafellar. Monotone operators and the proximal point algorithm. SIAM journal on control and optimization, 14(5):877–898, 1976.   \n[63] D. Ruiz. A scaling algorithm to equilibrate both rows and columns norms in matrices. Technical report, CM-P00040415, 2001.   \n[64] E. K. Ryu and S. Boyd. Primer on monotone operator methods. Appl. Comput. Math, 15(1):3–43, 2016.   \n[65] A. Schrijver. Theory of linear and integer programming. John Wiley & Sons, 1998.   \n[66] M. Souto, J. D. Garcia, and Á. Veiga. Exploiting low-rank structure in semidefinite programming by approximate operator splitting. Optimization, pages 1–28, 2020.   \n[67] B. Stellato, G. Banjac, P. Goulart, A. Bemporad, and S. Boyd. OSQP: an operator splitting solver for quadratic programs. Mathematical Programming Computation, 12(4):637–672, 2020.   \n[68] Y. M. Tsai, T. Cojean, and H. Anzt. Sparse linear algebra on AMD and NVIDIA GPUs – the race is on. In P. Sadayappan, B. L. Chamberlain, G. Juckeland, and H. Ltaief, editors, High Performance Computing, pages 309–327, Cham, 2020. Springer International Publishing.   \n[69] R. J. Vanderbei et al. Linear programming, volume 3. Springer, 2015.   \n[70] S. Wang and N. Shroff. A new alternating direction method for linear programming. In I. Guyon, U. V. Luxburg, S. Bengio, H. Wallach, R. Fergus, S. Vishwanathan, and R. Garnett, editors, Advances in Neural Information Processing Systems, volume 30. Curran Associates, Inc., 2017.   \n[71] T. Yang and Q. Lin. RSG: Beating subgradient method without smoothness and strong convexity. The Journal of Machine Learning Research, 19(1):236–268, 2018.   \n[72] M. Zhu and T. Chan. An efficient primal-dual hybrid gradient algorithm for total variation image restoration. UCLA CAM Report, 34:8–34, 2008. ",
+        "bbox": [
+            171,
+            68,
+            828,
+            920
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            65,
+            828,
+            916
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            65,
+            828,
+            917
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            93,
+            828,
+            469
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Checklist ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            483,
+            254,
+            500
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            507,
+            339,
+            521
+        ],
+        "page_idx": 13
+    },
+    {
+        "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] Our comparisons with baselines show that PDLP is not always the best, hence demonstrating its limitations. We also note which of our heuristics are lacking theoretical guarantees.   \n(c) Did you discuss any potential negative societal impacts of your work? [No] As a purely algorithmic paper, we do not believe such a discussion is relevant. Linear programming is a mature area whose societal impact is well understood.   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            238,
+            529,
+            825,
+            688
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            695,
+            493,
+            710
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [Yes] The only theoretical result appear in the appendix (Proposition 1). (b) Did you include complete proofs of all theoretical results? [Yes] ",
+        "bbox": [
+            236,
+            715,
+            823,
+            766
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            214,
+            772,
+            393,
+            786
+        ],
+        "page_idx": 13
+    },
+    {
+        "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] Code, data, and instructions needed to reproduce the main experimental results are publicly released in an open source repository at https://github.com/google-research/ FirstOrderLp.jl. Additional instructions are included in the supplementary materials.   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] We discussed that we used MIP Relaxations to build our algorithm ",
+        "bbox": [
+            236,
+            794,
+            825,
+            912
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "and LP benchmark and Netlib as held out evaluation sets. We run a large ablation study to justify algorithmic decisions and most hyperparameter settings. ",
+        "bbox": [
+            261,
+            90,
+            821,
+            119
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [No] We used large datasets that would have been computational intensive to run multiple times. When possible, we use the “KKT pass” metric that’s reproducible and not subject to measurement noise. Only the PageRank instances use a random seed, and these are too large to run multiple times because we have a single concurrent license for Gurobi.   \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] See Section 4.1. ",
+        "bbox": [
+            238,
+            126,
+            825,
+            244
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            215,
+            250,
+            821,
+            265
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes] We use LP Benchmark, MIP Relaxations, and Netlib datasets. We cite the sources for the datasets.   \n(b) Did you mention the license of the assets? [No] Although these datasets are widely used in the community, we were unable to find explicit licenses.   \n(c) Did you include any new assets either in the supplemental material or as a URL? [Yes] We include our code and data processing scripts in the supplemental material.   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [No]   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] ",
+        "bbox": [
+            238,
+            270,
+            825,
+            450
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            214,
+            457,
+            705,
+            472
+        ],
+        "page_idx": 14
+    },
+    {
+        "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,
+            477,
+            825,
+            575
+        ],
+        "page_idx": 14
+    }
+]

parse/train/f4jw35Vrk6d/f4jw35Vrk6d.md

@@ -0,0 +1,358 @@
+# Improving Entropic Out-of-Distribution Detection using Isometric Distances and the Minimum Distance Score
+
+Anonymous Author(s)   
+Affiliation   
+Address   
+email
+
+# Abstract
+
+1 Current out-of-distribution detection approaches usually present special require  
+2 ments (e.g., collecting outlier data and hyperparameter validation) and produce   
+3 side effects (classification accuracy drop and slow/inefficient inferences). Recently,   
+4 entropic out-of-distribution detection has been proposed as a seamless approach   
+5 (i.e., a solution that avoids all the previously mentioned drawbacks). The entropic   
+6 out-of-distribution detection solution comprises the IsoMax loss for training and   
+7 the entropic score for out-of-distribution detection. The IsoMax loss works as a   
+8 SoftMax loss drop-in replacement because swapping the SoftMax loss with the   
+9 IsoMax loss requires no changes in the model’s architecture or training proce  
+10 dures/hyperparameters. In this paper, we propose to perform what we call an   
+11 isometrization of the distances used in the IsoMax loss. Additionally, we propose   
+12 to replace the entropic score with the minimum distance score. Our experiments   
+13 showed that these simple modifications increase out-of-distribution detection per  
+14 formance while keeping the solution seamless.
+
+# 15 1 Introduction
+
+16 Neural networks have been used in classification tasks in many real-world applications [4]. In such   
+17 cases, the system usually needs to be able to identify whether a given input belongs to any of the   
+18 classes on which it was trained. Hendrycks & Gimpel [9] called this capability out-of-distribution   
+19 (OOD) detection and proposed datasets and metrics to allow standardized performance evaluation   
+20 and comparison. However, current OOD detection solutions still present limitations (e.g., special   
+21 requirements and side effects) that prevent a more general use of OOD detection capabilities in   
+22 practical real-world applications [27] (Table 1).   
+23 First, OOD detection solutions commonly present hyperparameters that usually presume access to   
+24 out-of-distribution samples to be defined [23, 22, 19, 18, 3]. A consequence of presuming access to   
+25 OOD samples to validate hyperparameters and using the same distribution to evaluate OOD detection   
+26 results is producing overestimated performance estimations [32]. To avoid unrealistic access to OOD   
+27 samples and overestimated performance, Lee et al. [19] proposed to validate hyperparameters using   
+28 adversarial samples. However, this requires the generation of adversarial examples. Moreover, this   
+29 procedure requires the determination of hyperparameters (e.g., maximum adversarial perturbation)   
+30 typically unknown when dealing with novel datasets. Similar arguments hold for solutions based on   
+31 adversarial training [8, 17, 21, 14, 18], which also result in higher training time. Approaches based   
+32 on the generation of adversarial examples or the use of adversarial training may also have limited   
+33 scalability when dealing with large images such as those presented in the ImageNet [2].   
+34 Many solutions make use of the so-called input preprocessing technique introduced in ODIN [23].   
+35 However, the use of the mentioned technique increases at least four times the inference delay and   
+36 power consumption [27] since a combination of a first forward pass, backpropagation operation, and   
+37 second forward pass is required [23, 19, 11, 3] for a single useful inference. Actually, approaches   
+38 that may be applied directly to pretrained models and altogether avoid training or fine-tuning the   
+39 model [23, 19, 30] usually produce inefficient inferences and/or additional computational complexity   
+40 to perform OOD detection [26, Section IV, D]. From a practical point of view, this is a drawback, as   
+41 inferences may be performed thousands or millions of times in the field. Hence, such approaches may   
+42 be prohibitive (not sustainable) from environmental $[ 3 1 ] ^ { 1 }$ and real-world cost-based perspectives.   
+43 Another harmful common side effect is the so-called classification accuracy drop2 [34, 11]. In such   
+44 cases, higher OOD detection performance is achieved at the expense of a drop in the classification   
+45 accuracy compared with models trained using the usual SoftMax loss (i.e., the combination of the   
+46 SoftMax activation and the cross-entropy loss [24]). From a practical perspective, this situation is   
+47 undesired because the detection of out-of-distribution samples may be a rare event. At the same time,   
+48 the classification is the main aim of the designed system [1].   
+49 Hsu et al. [11] proposed to use the in-distribution validation set to avoid the need for accessing   
+50 OOD samples to determine the hyperparameters required by the solution. However, considering that   
+51 CIFAR10 and CIFAR100 do not have separated sets for validation and testing, the results may also be   
+52 overestimated because the validation sets used to define the hyperparameters were reused for OOD   
+53 detection performance estimation. A more realistic OOD detection performance estimation could   
+54 have been achieved by removing the in-distribution validation set from in-distribution training data.   
+55 However, this would probably produce an even higher classification accuracy drop. Additionally, the   
+56 solution proposed in [11] is expensive and not environment-friendly, as it uses input preprocessing   
+57 and, consequently, produces slow and energy-inefficient inferences [27, 26]. Recently, many OOD   
+58 detection approaches have used additional/extra/outlier data [10, 25, 5]. The Gram matrices solution   
+59 calculates values produced by the model during inference [30] to perform OOD detection.
+
+Table 1: Out-of-distribution detection approaches: special requirements and side effects.   
+
+<table><tr><td rowspan="2">Approach</td><td colspan="2">Special Requirement</td><td colspan="2">Side Effect</td></tr><tr><td>Hyperparameter Tuning</td><td>Outlier Data</td><td>Slow/Inefficient Inference</td><td>Classification Accuracy Drop</td></tr><tr><td>ODIN [23]</td><td>Required</td><td> Not Required</td><td>Present</td><td>Not Present</td></tr><tr><td>Mahalanobis [19]</td><td>Required</td><td>Not Required</td><td>Present</td><td>Not Present</td></tr><tr><td>ACET [8]</td><td>Required</td><td>Not Required</td><td>Not Present</td><td>Present</td></tr><tr><td>Outlier Exposure [10]</td><td>Not Required</td><td>Required</td><td>Not Present</td><td>Not Present</td></tr><tr><td>Generalized ODIN [11]</td><td>Required</td><td>Not Required</td><td>Present</td><td>Present</td></tr><tr><td>Gram Matrices [30]</td><td>Not Required</td><td>Not Required</td><td>Present</td><td>Not Present</td></tr><tr><td>Scaled Cosine [34]</td><td>Not Required</td><td>Not Required</td><td>Not Present</td><td>Present</td></tr><tr><td>Energy-based [25]</td><td>Required</td><td>Required</td><td>Not Present</td><td>Not Present</td></tr><tr><td>Entropic (Seamless) [27,26] IsoMax + Entropic Score</td><td>Not Required</td><td>Not Required</td><td>Not Present</td><td>Not Present</td></tr><tr><td>Entropic (Seamless) [ours] IsoMaxz + MinDistance Score</td><td>Not Required</td><td>Not Required</td><td>Not Present</td><td>Not Present</td></tr></table>
+
+In some cases, an ensemble of classifiers is used [35]. For deep ensembles, Lakshminarayanan et al. [17] proposed an ensemble of same-architecture models trained with different random initial weights. Some proposals required model structural changes to tackle OOD detection [37], and certain trials used uncertainty or confidence estimation/calibration techniques [13, 20, 28, 16, 33]. However, Bayesian neural networks used in most of these are usually harder to implement and require
+
+65 much more computational resorces to train. Moreover, computational constraints usually require   
+66 approximations that compromise the performance, which is also affected by the prior distribution   
+67 used [17]. For example, MC-dropout uses pretrained models with dropout activated during the test   
+68 time. An average of many inferences is used to perform a single decision [6].   
+69 The entropic out-of-distribution detection approach, which is composed of the IsoMax loss for training   
+70 and the entropic score for OOD detection, avoids all mentioned special requirements and side effects   
+71 [27]. Indeed, no hyperparameter tuning is required because the entropic scale is a global constant   
+72 kept equal to ten for all combinations of datasets and models. Even if we call the entropic scale a   
+73 “hyperparameter”, the IsoMax does not involve hyperparameter tuning, as the same constant value of   
+74 entropic scale is used in all situations. This is possible because Macêdo et al. experimentally showed   
+75 in [27, Fig. 3] and in [26, Section IV, A] that the OOD detection performance presents a well-behaved   
+76 dependence on the entropic scale regardless of the dataset and model. No additional/extra/outlier   
+77 data are necessary. Models trained using IsoMax loss produce inferences as fast and energy-efficient   
+78 as the inferences produced by SoftMax-loss-trained networks. The OOD detection requires only a   
+79 speedy entropy calculation. Finally, no classification accuracy drop is observed.   
+80 Contributions Our contribution in this paper is threefold: First, in addition to minor changes, we   
+81 perform what we call an isometrization of the feature-prototype distances used by the IsoMax loss.   
+82 We call our modified version of IsoMax the isometric isotropy maximization loss or isometric IsoMax   
+83 loss $\operatorname { ( I s o M a x } _ { \mathbb { Z } }$ loss). Second, we propose to use the minimum feature-prototype distance as the score   
+84 to perform OOD detection. Considering that the minimum feature-prototype distance is calculated   
+85 to perform the classification, the OOD detection task presents essentially zero computational cost   
+86 because we simply reuse this value as the score to perform OOD detection. Third, in addition to   
+87 experimental evidence, we provide insights into why a combination of training using the isometric   
+88 distances provided by $\operatorname { I s o M a x } _ { \mathbb { Z } }$ and performing OOD detection using the minimum distance scores   
+89 produces a substantial performance increase in OOD detection compared to IsoMax combined with   
+90 the entropic score. Our approach keeps the solution seamless (i.e., it avoids the previously mentioned   
+91 special requirements and side effects) while significantly increasing the OOD detection performance.   
+92 Similar to IsoMax loss, $\operatorname { I s o M a x } _ { \mathbb { Z } }$ works as a SoftMax loss drop-in replacement, as no procedures   
+93 other than regular neural network training are required.
+
+# 94 2 Isometric Distances and Minimum Distance Score
+
+95 Isometric Distances Consider an input $_ { \textbf { \em x } }$ applied to a neural network that performs a parametrized   
+96 transformation ${ f } _ { \boldsymbol { \theta } } ( \boldsymbol { x } )$ . Moreover, consider $p _ { \phi } ^ { j }$ be the learnable prototype associated with the class $j$ .   
+97 Additionally, let the expression $\| f _ { \theta } ( \pmb { x } ) - \pmb { p } _ { \phi } ^ { j } \|$ represent the nonsquared Euclidean distance between   
+98 ${ f } _ { \theta } ( { \pmb x } )$ and $ { p _ { \phi } ^ { j } }$ . Finally, consider $ { p _ { \phi } ^ { k } }$ as a learnable prototype associated with the correct class for the   
+99 input $_ { \textbf { \em x } }$ . Hence, we write the IsoMax loss [27] for a batch of $N$ examples using the equation below:
+
+$$
+\mathcal { L } _ { \sf l s o M a x } = - \frac { 1 } { N } \sum _ { k = 1 } ^ { N } \log \left( \frac { \exp ( - E _ { s } \| \mathbf { \cdot } \mathbf { \boldsymbol { f } } _ { \theta } ( x ) - \mathbf { \boldsymbol { p } } _ { \phi } ^ { k } \| ) } { \sum _ { j } \exp ( - E _ { s } \| \mathbf { \cdot } \mathbf { \boldsymbol { f } } _ { \theta } ( x ) - \mathbf { \boldsymbol { p } } _ { \phi } ^ { j } \| ) } \right)
+$$
+
+100 In the above equation, the $E _ { s }$ represents the entropic scale. From Equation (1), we observe that   
+101 the distances from IsoMax loss are given by the expression $\mathcal { D } = \| f _ { \theta } ( \pmb { x } ) - \pmb { p } _ { \phi } ^ { j } \|$ . During inference,   
+102 probabilities calculated based on these distances are used to produce the negative entropy, which   
+103 serves as a score to perform OOD detection. However, as the features ${ f } _ { \theta } ( { \pmb x } )$ are unnormalized,   
+104 examples with low norms are unjustifiably favored to be considered OOD examples since they tend   
+105 to produce high entropy. Additionally, as the weights $ { p _ { \phi } ^ { j } }$ are unnormalized, examples from classes   
+106 that present prototypes with low norms are unjustifiably favored to be considered OOD examples for   
+107 the same reason.
+
+108 Hence, we propose to replace ${ f } _ { \theta } ( { \pmb x } )$ with its normalized version given by $\widehat { { f _ { \theta } ( \mathbf { x } ) } } { = } f _ { \theta } ( \mathbf { x } ) / \| f _ { \theta } ( \mathbf { \boldsymbol { x } } ) \|$ . Additionally, we propose to replace 109 $ { p _ { \phi } ^ { j } }$ with its normalized version given by $\scriptstyle { p _ { \phi } ^ { j } = p _ { \phi } ^ { j } / \| p _ { \phi } ^ { j } \| }$ . The 110 expression $\lVert \boldsymbol { v } \rVert$ represents the 2-norm of a given vector $\textbf {  { v } }$ .
+
+Table 2: Classification accuracy of models trained using SoftMax, IsoMax, and $\mathbf { I s o M a x } _ { \mathcal { T } }$ losses. In addition to avoiding classification accuracy drop compared with SoftMax-loss- and IsoMax-losstrained networks, IsoMax $\boldsymbol { \mathcal { Z } }$ -loss-trained models show higher OOD detection performance (Table 3).   
+
+<table><tr><td>Model</td><td>Data</td><td>Train Accuracy (%) [↑] SoftMax Loss / IsoMax Loss / IsoMaxz Loss</td><td>Test Accuracy (%)[↑]</td></tr><tr><td rowspan="3">DenseNetBC100</td><td>CIFAR10</td><td>99.9 / 99.9 / 99.9</td><td>95.4 /95.2 /95.2</td></tr><tr><td>CIFAR100</td><td>99.9 /99.0 / 99.9</td><td>77.5 / 77.5 / 76.8</td></tr><tr><td>SVHN</td><td>96.9 / 97.6 /97.1</td><td>96.6 /96.6 /96.6</td></tr><tr><td rowspan="3">ResNet110</td><td>CIFAR10</td><td>99.9 / 99.9 / 99.9</td><td>94.5 /94.6 /94.6</td></tr><tr><td>CIFAR100</td><td>99.5 / 99.9 / 99.8</td><td>72.7 /74.1/ 73.9</td></tr><tr><td>SVHN</td><td>99.8 / 99.9 / 99.5</td><td>96.7 /96.9 /96.9</td></tr></table>
+
+111 However, while the distances in the original IsoMax loss may vary from zero to infinity, the distance   
+112 between two normalized vectors is always equal to or lower than two. To avoid this unjustifiable and   
+113 unreasonable restriction, we introduce the distance scale $d _ { s }$ , which is a scalar learnable parameter.   
+114 Naturally, we require the distance scale to always be positive by taking its absolute value $| d _ { s } |$ .   
+115 The feature normalization makes the solution isometric regardless of the norm of the features produced   
+116 by the examples. The distance scale is class independent, as it is a single scalar value regularly   
+117 learnable during training. The weight normalization and the class independence of the distance scale   
+118 make the solution isometric regarding all classes. Hence, the proposed distance is isometric because   
+119 it produces an isometric treatment of all features, prototypes, and classes. Therefore, we can write   
+120 the expression for the isometric distances used by the $\operatorname { I s o M a x } _ { \mathcal { T } }$ loss as:
+
+$$
+\mathcal { D } _ { \mathcal { T } } = \left| d _ { s } \right| \widehat { \| f _ { \theta } ( x ) } - \widehat { p _ { \phi } ^ { j } } \|
+$$
+
+121 Returning to Equation (1), we can write the expression for the $\operatorname { I s o M a x } _ { \mathbb { Z } }$ loss as follows:
+
+$$
+\mathcal { L } _ { \mathsf { l s o M a x } _ { \boldsymbol { \tau } } } = - \frac { 1 } { N } \sum _ { k = 1 } ^ { N } \log \left( \frac { \exp ( - E _ { s } \left| \boldsymbol { d } _ { s } \right| \left\| \widehat { \pmb { f _ { \theta } ( x ) } } - \widehat { \pmb { p _ { \phi } ^ { k } } } \right\| ) } { \sum _ { j } \exp ( - E _ { s } \left| \boldsymbol { d } _ { s } \right| \left\| \widehat { \pmb { f _ { \theta } ( x ) } } - \widehat { \pmb { p _ { \phi } ^ { j } } } \right\| ) } \right)
+$$
+
+122 Applying the entropy maximization trick (i.e., the removal of the entropic score $E _ { s }$ for inference) [27],   
+123 we can write the expression for the $\operatorname { I s o M a x } _ { \mathcal { T } }$ loss probabilities used during inference for performing   
+124 OOD detection when using the entropic score [27]:
+
+$$
+\mathcal { P } _ { \mathsf { l s o M a x } _ { \mathcal { Z } } } ( y ^ { ( i ) } | x ) = \frac { \exp ( - \left| d _ { s } \right| \sqrt { f _ { \theta } ( x ) } - \widehat { p _ { \phi } ^ { i } } \| ) } { \sum _ { j } \exp ( - \left| d _ { s } \right| \| \widehat { f _ { \theta } ( x ) } - \widehat { p _ { \phi } ^ { j } } \| ) }
+$$
+
+125 Different from IsoMax loss where the prototypes are initialized to a zero vector, we initialized all   
+126 prototypes using a normal distribution with a mean of zero and standard deviation of one. This   
+127 approach is necessary because we normalize the prototypes when using $\operatorname { I s o M a x } _ { \mathcal { T } }$ loss. The distance   
+128 scale is initialized to one. We add no hyperparameters to the solution.   
+129 Minimum Distance Score Motivated by the desired characteristics of the isometric distances used   
+130 in $\operatorname { I s o M a x } _ { \mathbb { Z } }$ , we propose to use what we call the minimum distance as the score for performing OOD   
+131 detection. Naturally, the minimum distance score for the $\operatorname { I s o M a x } _ { \mathcal { Z } }$ is given by:
+
+$$
+S _ { \mathrm { M i n D i s t a n c e } } = \operatorname* { m i n } _ { j } \left( \| { \widehat { \mathbf { f } _ { \theta } ( x ) } } - { \widehat { \mathbf { p } _ { \phi } ^ { j } } } \| \right)
+$$
+
+Table 3: Fair comparison of seamless approaches: No hyperparameter tuning, no additional/extra/outlier data, no classification accuracy drop, and no slow/inefficient inferences. SoftMax+ES means training using SoftMax loss and performing OOD detection using the entropic score (ES). IsoMax+ES means training using IsoMax loss and performing OOD detection using the entropic score (ES). $\operatorname { I s o M a x } _ { \mathbb { Z } } { + } \mathbf { M } \mathbf { D } \mathbf { S }$ means training using $\operatorname { I s o M a x } _ { \mathcal { Z } }$ loss and performing OOD detection using minimum distance score (MDS). The best results are in bold ( $0 . 5 \%$ tolerance).   
+
+<table><tr><td rowspan="2">Model</td><td rowspan="2">Data (training)</td><td rowspan="2">OOD (unseen)</td><td colspan="2">Out-of-Distribution Detection: Seamless Approaches.</td></tr><tr><td>TNR@TPR95 (%) [↑] SoftMax+ES /IsoMax+ES /IsoMaxx+MDS (ours)</td><td>AUROC (%) [↑]</td></tr><tr><td rowspan="5">DenseNetBC100</td><td>CIFAR10</td><td>SVHN TinyImageNet LSUN</td><td>33.2 / 77.0 /97.2 59.8 / 88.0 / 92.5</td><td>86.9 / 96.6 / 99.5 94.2/97.8/98.6</td></tr><tr><td>CIFAR100</td><td>SVHN TinyImageNet</td><td>69.5 / 94.5 /95.3 24.9/ 23.4/ 78.6 23.7 / 49.1 / 85.6</td><td>95.9 / 98.8 / 99.1 81.9 / 88.6 / 96.5 78.8 / 92.6 / 97.6</td></tr><tr><td rowspan="2"></td><td>LSUN</td><td>24.4 / 63.0 / 83.4</td><td>77.9 /94.7 / 97.4</td></tr><tr><td>CIFAR10</td><td>83.7 / 94.1 /95.3</td><td>96.9 / 98.5 /99.1</td></tr><tr><td rowspan="2">SVHN</td><td>TinyImageNet LSUN</td><td>90.0 / 97.0/98.3</td><td>98.1/99.1/99.7</td></tr><tr><td>SVHN</td><td></td><td>88.4 / 96.8 /97.8</td><td>97.8 / 99.1 / 99.7</td></tr><tr><td rowspan="6">ResNet110</td><td>CIFAR10</td><td>TinyImageNet</td><td>37.8/ 73.0/83.6 43.7 /73.7/75.5</td><td>89.6 / 95.1 / 97.3</td></tr><tr><td rowspan="2"></td><td>LSUN</td><td>52.1 / 82.8 /86.3</td><td>90.6 / 95.9/96.0 92.8 /96.9 / 97.7</td></tr><tr><td>SVHN</td><td></td><td></td></tr><tr><td rowspan="2">CIFAR100</td><td>TinyImageNet</td><td>15.4 / 18.7 /30.7</td><td>67.5 / 84.7 / 85.8</td></tr><tr><td>LSUN</td><td>18.8 /26.3 /42.9</td><td>73.5/ 84.5 / 87.9</td></tr><tr><td rowspan="2">SVHN</td><td>CIFAR10</td><td>21.3 / 30.2/46.9</td><td>76.4 / 87.1 / 89.4</td></tr><tr><td rowspan="2"></td><td>TinyImageNet</td><td>68.6 / 80.4 / 72.0 71.7 / 84.4 / 83.1</td><td>91.7 / 95.2/93.3</td></tr><tr><td>LSUN</td><td>69.1/ 80.4/ 76.3</td><td>93.1 / 95.8/96.2 91.8 /94.3/94.3</td></tr></table>
+
+132 In the previous equation, $| d _ { s } |$ was removed because it is a scale factor that does not change after   
+133 the training is completed. The minimum distance is computed to perform the classification, as the   
+134 predicted class is the one that presents the lowest feature-prototype distance. Therefore, when using   
+135 this score, the OOD detection presents essentially zero latency and computational cost, as we simply   
+136 reuse the minimum distance already calculated.
+
+# 137 3 Experiments
+
+138 To allow standardized comparison, we used the datasets, training procedures, and metrics that were   
+139 established in Hendrycks & Gimpel [9] and adopted in many subsequent OOD detection papers   
+140 [23, 19, 8]. We did not compare to approaches that produce classification accuracy drop (e.g.,   
+141 [34, 11]), as this is a substantial limitation from a practical perspective [1]. The code to reproduce the   
+142 results is available as supplementary material.   
+143 We trained many 100-layer DenseNetBCs with growth rate $k = 1 2$ (i.e., 0.8M parameters) [12],   
+144 110-layer ResNets $[ 7 ] ^ { 3 }$ , and 34-layer ResNets $[ 7 ] ^ { \overline { { 4 } } }$ on CIFAR10 [15], CIFAR100 [15], and SVHN   
+145 [29] datasets with SoftMax, IsoMax, and $\operatorname { I s o M a x } _ { \mathbb { Z } }$ losses using the same procedures (e.g., initial   
+146 learning rate, learning rate schedule, weight decay) presented in Lee et al. [19].
+
+We used SGD with the Nesterov moment equal to 0.9 during 300 epochs with a batch size of 64, and an initial learning rate of 0.1 with a learning rate decay rate equal to ten applied in the epoch number 150, 200, and 250. The weight decay was 0.0001. We did not use dropout. We used a computer with CPU Intel i7-4790K, 4.00GHz, x64, octa-core, 32Gb RAM, and a GPU Nvidia GTX 1080 Ti.
+
+Table 4: Unfair comparison with approaches that use input preprocessing and produce slow/inefficient inferences in addition to requiring validation using adversarial examples. ODIN and Mahalanobis were applied to models trained using SoftMax loss. These approaches present at least four times slower and less power efficient inferences [27], as they use input preprocessing. Their hyperparameters were validated using adversarial examples. $\operatorname { I s o M a x } _ { \mathbb { Z } } { + } \mathbf { M } \mathbf { D } \mathbf { S }$ (ours) means training using $\operatorname { I s o M a x } _ { \mathbb { Z } }$ loss and performing OOD detection using minimum distance score (MDS). The best results are in bold ( $0 . 5 \%$ tolerance).   
+
+<table><tr><td rowspan="2">Model</td><td rowspan="2">Data (training)</td><td rowspan="2">0OD (unseen)</td><td colspan="2">Comparison with approaches that use input preprocessing and adversarial validation.</td></tr><tr><td>AUROC (%) [↑] ODIN /Mahalanobis /IsoMaxx+MDS (ours)</td><td>DTACC (%) [↑]</td></tr><tr><td rowspan="3">DenseNetBC100</td><td rowspan="2">CIFAR10</td><td>SVHN</td><td>92.8 / 97.6 / 99.5</td><td>86.5 / 92.6 / 96.3</td></tr><tr><td>TinyImageNet</td><td>97.2 / 98.8 / 98.6</td><td>92.1 / 95.0 / 93.9</td></tr><tr><td></td><td>LSUN</td><td>98.5 / 99.2 / 99.1</td><td>94.3 / 96.2 / 95.2</td></tr><tr><td rowspan="3"></td><td rowspan="2">CIFAR100</td><td>SVHN TinyImageNet</td><td>88.2 / 91.8 /96.5 85.3 / 97.0 /97.6</td><td>80.7 / 84.6 /90.0 77.2 / 91.8 / 91.6</td></tr><tr><td>LSUN</td><td>85.7 / 97.9 / 97.4</td><td>77.3 / 93.8 / 90.8</td></tr><tr><td></td><td>SVHN</td><td>86.5 / 95.5 / 98.2</td><td></td></tr><tr><td rowspan="3">ResNet34</td><td>CIFAR10</td><td>TinyImageNet</td><td>93.9 / 99.0 /94.8</td><td>77.8 / 89.1 / 93.0 86.0 / 95.4 / 88.5</td></tr><tr><td rowspan="2"></td><td>LSUN</td><td>93.7 / 99.5 / 96.6</td><td>85.8 / 97.2 / 91.0</td></tr><tr><td>SVHN</td><td></td><td></td></tr><tr><td rowspan="2"></td><td rowspan="2">CIFAR100</td><td>TinyImageNet</td><td>72.0 / 84.4 / 88.3 83.6 / 87.9 / 90.5</td><td>67.7 / 76.5 / 82.6</td></tr><tr><td>LSUN</td><td>81.9 / 82.3 / 88.3</td><td>75.9 / 84.6 / 84.4 74.6 / 79.7 / 82.6</td></tr></table>
+
+Table 5: Unfair comparison of outlier exposure-enhanced SoftMax loss with IsoMax loss and $\mathbf { I s o M a x } _ { \mathcal { T } }$ loss without using extra data. SoftMax $\mathrm { \Lambda } ^ { \mathrm { O E } } { + } \mathrm { E } { S }$ means training using SoftMax loss enhanced during training by using outlier exposure [10], which requires the collection of outlier data, and performing OOD detection using the entropic score (ES). We used the same outlier data used in [10]. In each case, we collected the same amount of outlier data as the number of training examples present in the training set used to train SoftMaxOE. Despite being possible [26], the IsoMax loss and $\operatorname { I s o M a x } _ { \mathbb { Z } }$ loss were not enhanced with outlier exposure to keep the solution seamless. IsoMax $+ \mathrm { E S }$ means training using IsoMax loss and performing OOD detection using the entropic score (ES). $\operatorname { I s o M a x } _ { \mathbb { Z } } { + } \mathbf { M } \mathbf { D } \mathbf { S }$ (ours) means training using $\operatorname { I s o M a x } _ { \mathbb { Z } }$ loss and performing OOD detection using minimum distance score (MDS). The values of the performance metrics TNR $@$ TPR95 and AUROC were averaged over all out-of-distribution. The best values are in bold ( $0 . 5 \%$ tolerance).   
+
+<table><tr><td rowspan="2">Model</td><td rowspan="2">Data (training)</td><td colspan="2">Comparison of IsoMax loss variants without using extra data with outlier exposure-enhanced SoftMax loss.</td></tr><tr><td>TNR@TPR95 （%) [↑] SoftMaxOE+ES /IsoMax+ES /IsoMaxz+MDS (ours)</td><td>AUROC (%) [↑]</td></tr><tr><td rowspan="2">DenseNetBC100</td><td>CIFAR10</td><td>93.8 / 84.1 / 95.0</td><td>98.5 / 97.3 / 99.1</td></tr><tr><td>CIFAR100</td><td>23.0 / 45.1 / 82.5</td><td>80.5 / 91.9 / 97.0</td></tr><tr><td rowspan="2">ResNet110</td><td>CIFAR10</td><td>92.6 / 76.5 / 81.8</td><td>98.0 /96.0 / 97.0</td></tr><tr><td>CIFAR100</td><td>36.1 / 25.1 / 40.2</td><td>83.2 / 85.5 / 87.7</td></tr></table>
+
+![](images/19d3c6ca06a641259d05f06d12b5f22aafd23767a690f75e943dc89e4eb4816a.jpg)  
+Figure 1: (a) The no isometric distances used by the IsoMax loss make detecting out-of-distribution examples difficult using the minimum distance score. Consequently, the minimum distance score is not competitive with the entropic score in this case. (b) The isometric distances used by the $\operatorname { I s o M a x } _ { \mathbb { Z } }$ loss make detecting out-of-distribution examples easy using the minimum distance score. Consequently, the minimum distance score usually overcomes the entropic score in this situation.
+
+151 We used resized images from the datasets TinyImageNet $[ 2 ] ^ { 5 }$ and the Large-scale Scene UNderstand  
+152 ing dataset (LSUN) $\overline { { [ 3 6 ] } } ^ { 5 }$ following Lee et al. [19] to create out-of-distribution samples. We added   
+153 these out-of-distribution images to the validation sets presented in the CIFAR10, CIFAR100, and   
+154 SVHN to form the test sets and evaluate the OOD detection performance.   
+155 We evaluated the OOD detection performance using the true negative rate at $9 5 \%$ true positive   
+156 rate (TNR $@$ TPR95), the area under the receiver operating characteristic curve (AUROC), and the   
+157 detection accuracy (DTACC), which corresponds to the maximum classification probability over all   
+158 possible thresholds $\delta$ :
+
+$$
+1 - \operatorname* { m i n } _ { \delta } \left\{ P _ { \mathrm { i n } } \left( o \left( \mathbf { x } \right) \leq \delta \right) P \left( \mathbf { x } \mathrm { i s } \mathrm { f r o m } P _ { \mathrm { i n } } \right) + P _ { \mathrm { o u t } } \left( o \left( \mathbf { x } \right) > \delta \right) P \left( \mathbf { x } \mathrm { i s } \mathrm { f r o m } P _ { \mathrm { o u t } } \right) \right\} ,
+$$
+
+159 where $o ( \mathbf { x } )$ is the OOD detection score. It is assumed that both positive and negative samples have   
+160 an equal probability of being in the test set, i.e., $P$ ( $\mathbf { \bar { x } }$ is from $P _ { \mathrm { i n } } ) = P$ ( $\mathbf { x }$ is from $P _ { \mathrm { { o u t } } }$ ). All the   
+161 mentioned metrics follow the calculation procedures specified in Lee et al. [19].
+
+# 62 4 Results and Discussion
+
+Classification Accuracy Table 2 presents the classification accuracy results. It shows that $\operatorname { I s o M a x } _ { \mathcal { T } }$ loss does not present classification accuracy drop compared to SoftMax loss or IsoMax loss for all datasets and models. We observe that the IsoMax loss variants present more than one percent $( \% 1 )$ better accuracy than the SoftMax loss when using ResNet110 on the CIFAR100 dataset.
+
+167 Out-of-Distribution Detection We report the results using the entropic score for SoftMax loss   
+168 (SoftMax+ES), outlier exposure-enhanced SoftMax loss (SoftMax $\mathrm { ^ { O E } + E S }$ ), and IsoMax loss (Iso  
+169 Max $+ \mathrm { E S }$ ) because it always overcame the maximum probability score and minimum distance score in   
+170 these cases. For $\operatorname { I s o M a x } _ { \mathcal { T } }$ , we report the values using the minimum distance score $( \mathrm { I s o M a x } _ { \mathcal { T } } { + } \mathrm { M D S } )$ ),   
+171 as it usually overcame the maximum probability and the entropic score in this situation.   
+172 The Table 3 summarizes the results of the fair OOD detection comparison. In the mentioned table,   
+173 all approaches are accurate (no classification accuracy drop), fast and power-efficient (inferences   
+174 are performed without input preprocessing), and no validation is required to define hyperparameters.   
+175 Additionally, no additional/extra/outlier data are needed. In most cases, $\operatorname { I s o M a x } _ { \mathbb { Z } } { + } \mathbf { M } \mathbf { D } \mathbf { S }$ overcomes   
+176 IsoMax $+ \mathrm { E S }$ performance, regardless of the model, dataset, and out-of-distribution.   
+177 The minimum distance score produces high OOD detection performance when combined with the   
+178 $\operatorname { I s o M a x } _ { \mathcal { T } }$ , which evidences that the isometrization of the distances indeed work in this case. However,   
+179 the same minimum distance score produced low OOD detection performance when combined with   
+180 the original IsoMax loss. The Fig. 1 provides an explanation for this fact.   
+181 Table 4 summarizes the results of an unfair OOD detection comparison, as the methods present differ  
+182 ent requirements and produce distinct side effects. ODIN [23] and the Mahalanobis [19] approaches   
+183 require adversarial samples to be generated to validate hyperparameters for each combination of   
+184 dataset and model. Moreover, these approaches use input preprocessing, which makes inferences   
+185 at least four times slower and at least four times less energy-efficient. Validation using adversarial   
+186 examples may be a cumbersome procedure to be performed from scratch on novel datasets, as hyper  
+187 parameters such as optimal adversarial perturbations may be unknown in such cases. $\operatorname { I s o M a x } _ { \mathbb { Z } } { + } \mathbf { M } \mathbf { D } \mathbf { S }$   
+188 does not present these special requirements and does not produce the mentioned side effects.   
+189 Nevertheless, $\operatorname { I s o M a x } _ { \mathcal { Z } } { + } \mathbf { M } \mathbf { D } \mathbf { S }$ provides higher performance than ODIN. Usually, this occurs by a   
+190 large margin. In addition to the changes between the entropy maximization trick and temperature   
+191 calibrations present in [27, 26], we emphasize that training with entropic scale affects the learning of   
+192 all weights while changing the temperature during inference affects only the last layer. Hence, the fact   
+193 that the proposed solution overcomes ODIN by a safe margin is additional evidence that the entropy   
+194 maximization trick often produces much higher OOD detection performance than temperature cali  
+195 bration, even when the latter is combined with input preprocessing. Besides, the entropy maximization   
+196 trick does not require access to validation data to tune the temperature. In addition to being seamless   
+197 and avoiding the Mahalanobis approach drawbacks, $\operatorname { I s o M a x } _ { \mathbb { Z } } { + } \operatorname { M D S }$ usually overcomes it in terms of   
+198 AUROC and produces similar performance when considering the DTACC.   
+199 Table 5 unfairly compares the performance of the proposed approach with the outlier exposure   
+200 solution. Similar to IsoMax variants, the outlier exposure approach does not require hyperparameters   
+201 tuning and produces efficient inferences. However, it requires collecting outlier data, while our   
+202 approach does not. It is important to emphasize that outlier exposure may also be combined with   
+203 IsoMax loss variants to increase the OOD detection performance further [26]. Nevertheless, in   
+204 the mentioned table, we preferred to present the IsoMax loss variants without outlier exposure to   
+205 show that the outlier exposure-enhanced SoftMax loss usually present lower OOD detection than   
+206 $\operatorname { I s o M a x } _ { \mathbb { Z } } { + } \mathbf { M } \mathbf { D } \mathbf { S }$ even without using outlier exposure.
+
+# 5 Conclusion
+
+In this paper, we improved the IsoMax loss by replacing its original distance with what we call the isometric distance. Additionally, we proposed a zero computational cost minimum distance score. The experiments showed that these modifications produce higher OOD detection performance while keeping desired benefits of IsoMax loss (absence of hyperparameters to tune, no reliance on additional/extra/outlier data, fast and power-efficient inference, and no classification accuracy drop).
+
+213 Similar to IsoMax loss, after training using the proposed $\operatorname { I s o M a x } _ { \mathcal { Z } }$ loss, we may apply inference-based   
+214 approaches (e.g., Gram matrices, outlier exposure, energy-based) to the pretrained model to eventually   
+215 increase even more the overall OOD detection performance. Therefore, instead of competitors, the   
+216 OOD detection approaches that may be applied to pretrained models are actually complementary to   
+217 our approach [27, 26]. Hence, there is no drawback in training a model using $\operatorname { I s o M a x } _ { \mathbb { Z } }$ loss instead   
+218 of SoftMax loss or IsoMax loss, regardless of planning to subsequently use an inference-based OOD   
+219 detection approach to increase the OOD detection performance further.   
+220 In future works, considering its simplicity, we plan to verify whether our approach scales satisfactorily   
+221 to large-scale image datasets such as ImageNet. We also intend to verify the performance of our   
+222 solution using text datasets.
+
+# References
+
+[1] Carlini, N., Athalye, A., Papernot, N., Brendel, W., Rauber, J., Tsipras, D., Goodfellow, I. J., Madry, A., and Kurakin, A. On evaluating adversarial robustness. CoRR, abs/1902.06705, 2019.   
+[2] Deng, J., Dong, W., Socher, R., Li, L., Li, K., and Li, F. ImageNet: A large-scale hierarchical image database. Computer Vision and Pattern Recognition, 2009.   
+[3] DeVries, T. and Taylor, G. W. Learning confidence for out-of-distribution detection in neural networks. CoRR, abs/1802.04865, 2018.   
+[4] DeVries, T. and Taylor, G. W. Leveraging uncertainty estimates for predicting segmentation quality. CoRR, abs/1807.00502, 2018.   
+[5] Dhamija, A. R., Günther, M., and Boult, T. E. Reducing network agnostophobia. Neural Information Processing Systems, 2018.   
+[6] Gal, Y. and Ghahramani, Z. Dropout as a bayesian approximation: Representing model uncertainty in deep learning. International Conference on Machine Learning, 2016.   
+[7] He, K., Zhang, X., Ren, S., and Sun, J. Identity mappings in deep residual networks. European Conference on Computer Vision, 2016.   
+[8] Hein, M., Andriushchenko, M., and Bitterwolf, J. Why ReLU networks yield high-confidence predictions far away from the training data and how to mitigate the problem. Computer Vision and Pattern Recognition, 2018.   
+[9] Hendrycks, D. and Gimpel, K. A baseline for detecting misclassified and out-of-distribution examples in neural networks. International Conference on Learning Representations, 2017.   
+[10] Hendrycks, D., Mazeika, M., and Dietterich, T. Deep anomaly detection with outlier exposure. International Conference on Learning Representations, 2019.   
+[11] Hsu, Y.-C., Shen, Y., Jin, H., and Kira, Z. Generalized ODIN: Detecting out-of-distribution image without learning from out-of-distribution data. Computer Vision and Pattern Recognition, 2020.   
+[12] Huang, G., Liu, Z., Maaten, L. v. d., and Weinberger, K. Q. Densely connected convolutional networks. Computer Vision and Pattern Recognition, 2017.   
+[13] Kendall, A. and Gal, Y. What uncertainties do we need in bayesian deep learning for computer vision? Neural Information Processing Systems, 2017.   
+[14] Kliger, M. and Fleishman, S. Novelty detection with GAN. CoRR, abs/1802.10560, 2018.   
+[15] Krizhevsky, A. Learning multiple layers of features from tiny images. Science Department, University of Toronto, 2009.   
+[16] Kuleshov, V., Fenner, N., and Ermon, S. Accurate uncertainties for deep learning using calibrated regression. International Conference on Machine Learning, 2018.   
+[17] Lakshminarayanan, B., Pritzel, A., and Blundell, C. Simple and scalable predictive uncertainty estimation using deep ensembles. Neural Information Processing Systems, 2017.   
+[18] Lee, K., Lee, H., Lee, K., and Shin, J. Training confidence-calibrated classifiers for detecting out-of-distribution samples. International Conference on Learning Representations, 2018.   
+[19] Lee, K., Lee, K., Lee, H., and Shin, J. A simple unified framework for detecting out-ofdistribution samples and adversarial attacks. Neural Information Processing Systems, 2018.   
+[20] Leibig, C., Allken, V., Ayhan, M. S., Berens, P., and Wahl, S. Leveraging uncertainty information from deep neural networks for disease detection. Scientific Reports, 7, 2017.   
+[21] Li, D., Chen, D., Goh, J., and Ng, S. Anomaly detection with generative adversarial networks for multivariate time series. CoRR, abs/1809.04758, 2018.   
+[22] Liang, S., Li, Y., and Srikant, R. Principled detection of out-of-distribution examples in neural networks. CoRR, abs/1706.02690, 2017.   
+[23] Liang, S., Li, Y., and Srikant, R. Enhancing the reliability of out-of-distribution image detection in neural networks. International Conference on Learning Representations, 2018.   
+[24] Liu, W., Wen, Y., Yu, Z., and Yang, M. Large-margin softmax loss for convolutional neural networks. International Conference on Machine Learning, 2016.   
+[25] Liu, W., Wang, X., Owens, J. D., and Li, Y. Energy-based out-of-distribution detection. Neural Information Processing Systems, 2020.   
+[26] Macêdo, D., Ren, T. I., Zanchettin, C., Oliveira, A. L. I., and Ludermir, T. B. Entropic out-ofdistribution detection: Seamless detection of unknown examples. CoRR, abs/2006.04005, 2021. URL https://arxiv.org/abs/2006.04005.   
+[27] Macêdo, D., Ren, T. I., Zanchettin, C., Oliveira, A. L. I., and Ludermir, T. B. Entropic outof-distribution detection. Accepted for publication in The International Joint Conference on Neural Networks (IJCNN), 2021. URL https://arxiv.org/abs/1908.05569.   
+[28] Malinin, A. and Gales, M. Predictive uncertainty estimation via prior networks. Neural Information Processing Systems, 2018.   
+[29] Netzer, Y. and Wang, T. Reading digits in natural images with unsupervised feature learning. Neural Information Processing Systems, 2011.   
+[30] Sastry, C. S. and Oore, S. Detecting out-of-distribution examples with gram matrices. International Conference on Machine Learning, 2020.   
+[31] Schwartz, R., Dodge, J., Smith, N. A., and Etzioni, O. Green AI. Communications of the ACM, 63(12):54–63, 2020.   
+[32] Shafaei, A., Schmidt, M., and Little, J. J. A less biased evaluation of out-of-distribution sample detectors. British Machine Vision Conference, 2019.   
+[33] Subramanya, A., Srinivas, S., and Babu, R. V. Confidence estimation in deep neural networks via density modelling. CoRR, abs/1707.07013, 2017.   
+[34] Techapanurak, E., Suganuma, M., and Okatani, T. Hyperparameter-free out-of-distribution detection using cosine similarity. Asian Conference on Computer Vision (ACCV), November 2020.   
+[35] Vyas, A., Jammalamadaka, N., Zhu, X., Das, D., Kaul, B., and Willke, T. L. Out-of-distribution detection using an ensemble of self supervised leave-out classifiers. European Conference on Computer Vision, 2018.   
+[36] Yu, F., Zhang, Y., Song, S., Seff, A., and Xiao, J. LSUN: construction of a large-scale image dataset using deep learning with humans in the loop. CoRR, abs/1506.03365, 2015.   
+[37] Yu, Q. and Aizawa, K. Unsupervised out-of-distribution detection by maximum classifier discrepancy. International Conference on Computer Vision, 2019.
+
+1. For all authors...
+
+(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes] All claims are demonstrated using argumentation and substantial experiments.   
+(b) Did you describe the limitations of your work? [Yes] Please, see the last paragraph of the conclusion.   
+(c) Did you discuss any potential negative societal impacts of your work? [N/A] Actually, our approach is much more energy-efficient and environment-friendly than most competing approaches (see the third and the fifth paragraphs of the introduction).   
+(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]   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes]   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [N/A] We applied a tolerance to indicate the best approaches.   
+(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]
+
+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]   
+(b) Did you mention the license of the assets? [Yes]   
+(c) Did you include any new assets either in the supplemental material or as a URL? [Yes]   
+(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/f4jw35Vrk6d/f4jw35Vrk6d_content_list.json

@@ -0,0 +1,821 @@
+[
+    {
+        "type": "text",
+        "text": "Improving Entropic Out-of-Distribution Detection using Isometric Distances and the Minimum Distance Score ",
+        "text_level": 1,
+        "bbox": [
+            194,
+            122,
+            803,
+            196
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous Author(s)   \nAffiliation   \nAddress   \nemail ",
+        "bbox": [
+            423,
+            247,
+            578,
+            301
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            338,
+            535,
+            354
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Current out-of-distribution detection approaches usually present special require  \n2 ments (e.g., collecting outlier data and hyperparameter validation) and produce   \n3 side effects (classification accuracy drop and slow/inefficient inferences). Recently,   \n4 entropic out-of-distribution detection has been proposed as a seamless approach   \n5 (i.e., a solution that avoids all the previously mentioned drawbacks). The entropic   \n6 out-of-distribution detection solution comprises the IsoMax loss for training and   \n7 the entropic score for out-of-distribution detection. The IsoMax loss works as a   \n8 SoftMax loss drop-in replacement because swapping the SoftMax loss with the   \n9 IsoMax loss requires no changes in the model’s architecture or training proce  \n10 dures/hyperparameters. In this paper, we propose to perform what we call an   \n11 isometrization of the distances used in the IsoMax loss. Additionally, we propose   \n12 to replace the entropic score with the minimum distance score. Our experiments   \n13 showed that these simple modifications increase out-of-distribution detection per  \n14 formance while keeping the solution seamless. ",
+        "bbox": [
+            148,
+            375,
+            766,
+            568
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "15 1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            604,
+            312,
+            621
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "16 Neural networks have been used in classification tasks in many real-world applications [4]. In such   \n17 cases, the system usually needs to be able to identify whether a given input belongs to any of the   \n18 classes on which it was trained. Hendrycks & Gimpel [9] called this capability out-of-distribution   \n19 (OOD) detection and proposed datasets and metrics to allow standardized performance evaluation   \n20 and comparison. However, current OOD detection solutions still present limitations (e.g., special   \n21 requirements and side effects) that prevent a more general use of OOD detection capabilities in   \n22 practical real-world applications [27] (Table 1).   \n23 First, OOD detection solutions commonly present hyperparameters that usually presume access to   \n24 out-of-distribution samples to be defined [23, 22, 19, 18, 3]. A consequence of presuming access to   \n25 OOD samples to validate hyperparameters and using the same distribution to evaluate OOD detection   \n26 results is producing overestimated performance estimations [32]. To avoid unrealistic access to OOD   \n27 samples and overestimated performance, Lee et al. [19] proposed to validate hyperparameters using   \n28 adversarial samples. However, this requires the generation of adversarial examples. Moreover, this   \n29 procedure requires the determination of hyperparameters (e.g., maximum adversarial perturbation)   \n30 typically unknown when dealing with novel datasets. Similar arguments hold for solutions based on   \n31 adversarial training [8, 17, 21, 14, 18], which also result in higher training time. Approaches based   \n32 on the generation of adversarial examples or the use of adversarial training may also have limited   \n33 scalability when dealing with large images such as those presented in the ImageNet [2].   \n34 Many solutions make use of the so-called input preprocessing technique introduced in ODIN [23].   \n35 However, the use of the mentioned technique increases at least four times the inference delay and   \n36 power consumption [27] since a combination of a first forward pass, backpropagation operation, and   \n37 second forward pass is required [23, 19, 11, 3] for a single useful inference. Actually, approaches   \n38 that may be applied directly to pretrained models and altogether avoid training or fine-tuning the   \n39 model [23, 19, 30] usually produce inefficient inferences and/or additional computational complexity   \n40 to perform OOD detection [26, Section IV, D]. From a practical point of view, this is a drawback, as   \n41 inferences may be performed thousands or millions of times in the field. Hence, such approaches may   \n42 be prohibitive (not sustainable) from environmental $[ 3 1 ] ^ { 1 }$ and real-world cost-based perspectives.   \n43 Another harmful common side effect is the so-called classification accuracy drop2 [34, 11]. In such   \n44 cases, higher OOD detection performance is achieved at the expense of a drop in the classification   \n45 accuracy compared with models trained using the usual SoftMax loss (i.e., the combination of the   \n46 SoftMax activation and the cross-entropy loss [24]). From a practical perspective, this situation is   \n47 undesired because the detection of out-of-distribution samples may be a rare event. At the same time,   \n48 the classification is the main aim of the designed system [1].   \n49 Hsu et al. [11] proposed to use the in-distribution validation set to avoid the need for accessing   \n50 OOD samples to determine the hyperparameters required by the solution. However, considering that   \n51 CIFAR10 and CIFAR100 do not have separated sets for validation and testing, the results may also be   \n52 overestimated because the validation sets used to define the hyperparameters were reused for OOD   \n53 detection performance estimation. A more realistic OOD detection performance estimation could   \n54 have been achieved by removing the in-distribution validation set from in-distribution training data.   \n55 However, this would probably produce an even higher classification accuracy drop. Additionally, the   \n56 solution proposed in [11] is expensive and not environment-friendly, as it uses input preprocessing   \n57 and, consequently, produces slow and energy-inefficient inferences [27, 26]. Recently, many OOD   \n58 detection approaches have used additional/extra/outlier data [10, 25, 5]. The Gram matrices solution   \n59 calculates values produced by the model during inference [30] to perform OOD detection. ",
+        "bbox": [
+            147,
+            640,
+            825,
+            737
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            743,
+            825,
+            895
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "table",
+        "img_path": "images/a4d8b6c5f67a1e69f5ef77931cbea2b621742a79ee86e6c1398efaa8e83fcf9d.jpg",
+        "table_caption": [
+            "Table 1: Out-of-distribution detection approaches: special requirements and side effects. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Approach</td><td colspan=\"2\">Special Requirement</td><td colspan=\"2\">Side Effect</td></tr><tr><td>Hyperparameter Tuning</td><td>Outlier Data</td><td>Slow/Inefficient Inference</td><td>Classification Accuracy Drop</td></tr><tr><td>ODIN [23]</td><td>Required</td><td> Not Required</td><td>Present</td><td>Not Present</td></tr><tr><td>Mahalanobis [19]</td><td>Required</td><td>Not Required</td><td>Present</td><td>Not Present</td></tr><tr><td>ACET [8]</td><td>Required</td><td>Not Required</td><td>Not Present</td><td>Present</td></tr><tr><td>Outlier Exposure [10]</td><td>Not Required</td><td>Required</td><td>Not Present</td><td>Not Present</td></tr><tr><td>Generalized ODIN [11]</td><td>Required</td><td>Not Required</td><td>Present</td><td>Present</td></tr><tr><td>Gram Matrices [30]</td><td>Not Required</td><td>Not Required</td><td>Present</td><td>Not Present</td></tr><tr><td>Scaled Cosine [34]</td><td>Not Required</td><td>Not Required</td><td>Not Present</td><td>Present</td></tr><tr><td>Energy-based [25]</td><td>Required</td><td>Required</td><td>Not Present</td><td>Not Present</td></tr><tr><td>Entropic (Seamless) [27,26] IsoMax + Entropic Score</td><td>Not Required</td><td>Not Required</td><td>Not Present</td><td>Not Present</td></tr><tr><td>Entropic (Seamless) [ours] IsoMaxz + MinDistance Score</td><td>Not Required</td><td>Not Required</td><td>Not Present</td><td>Not Present</td></tr></table>",
+        "bbox": [
+            173,
+            111,
+            826,
+            383
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            410,
+            825,
+            536
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            541,
+            825,
+            625
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            631,
+            825,
+            784
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In some cases, an ensemble of classifiers is used [35]. For deep ensembles, Lakshminarayanan et al. [17] proposed an ensemble of same-architecture models trained with different random initial weights. Some proposals required model structural changes to tackle OOD detection [37], and certain trials used uncertainty or confidence estimation/calibration techniques [13, 20, 28, 16, 33]. However, Bayesian neural networks used in most of these are usually harder to implement and require ",
+        "bbox": [
+            173,
+            790,
+            825,
+            859
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "65 much more computational resorces to train. Moreover, computational constraints usually require   \n66 approximations that compromise the performance, which is also affected by the prior distribution   \n67 used [17]. For example, MC-dropout uses pretrained models with dropout activated during the test   \n68 time. An average of many inferences is used to perform a single decision [6].   \n69 The entropic out-of-distribution detection approach, which is composed of the IsoMax loss for training   \n70 and the entropic score for OOD detection, avoids all mentioned special requirements and side effects   \n71 [27]. Indeed, no hyperparameter tuning is required because the entropic scale is a global constant   \n72 kept equal to ten for all combinations of datasets and models. Even if we call the entropic scale a   \n73 “hyperparameter”, the IsoMax does not involve hyperparameter tuning, as the same constant value of   \n74 entropic scale is used in all situations. This is possible because Macêdo et al. experimentally showed   \n75 in [27, Fig. 3] and in [26, Section IV, A] that the OOD detection performance presents a well-behaved   \n76 dependence on the entropic scale regardless of the dataset and model. No additional/extra/outlier   \n77 data are necessary. Models trained using IsoMax loss produce inferences as fast and energy-efficient   \n78 as the inferences produced by SoftMax-loss-trained networks. The OOD detection requires only a   \n79 speedy entropy calculation. Finally, no classification accuracy drop is observed.   \n80 Contributions Our contribution in this paper is threefold: First, in addition to minor changes, we   \n81 perform what we call an isometrization of the feature-prototype distances used by the IsoMax loss.   \n82 We call our modified version of IsoMax the isometric isotropy maximization loss or isometric IsoMax   \n83 loss $\\operatorname { ( I s o M a x } _ { \\mathbb { Z } }$ loss). Second, we propose to use the minimum feature-prototype distance as the score   \n84 to perform OOD detection. Considering that the minimum feature-prototype distance is calculated   \n85 to perform the classification, the OOD detection task presents essentially zero computational cost   \n86 because we simply reuse this value as the score to perform OOD detection. Third, in addition to   \n87 experimental evidence, we provide insights into why a combination of training using the isometric   \n88 distances provided by $\\operatorname { I s o M a x } _ { \\mathbb { Z } }$ and performing OOD detection using the minimum distance scores   \n89 produces a substantial performance increase in OOD detection compared to IsoMax combined with   \n90 the entropic score. Our approach keeps the solution seamless (i.e., it avoids the previously mentioned   \n91 special requirements and side effects) while significantly increasing the OOD detection performance.   \n92 Similar to IsoMax loss, $\\operatorname { I s o M a x } _ { \\mathbb { Z } }$ works as a SoftMax loss drop-in replacement, as no procedures   \n93 other than regular neural network training are required. ",
+        "bbox": [
+            147,
+            90,
+            825,
+            147
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            154,
+            825,
+            306
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            319,
+            826,
+            513
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "94 2 Isometric Distances and Minimum Distance Score ",
+        "text_level": 1,
+        "bbox": [
+            151,
+            531,
+            622,
+            549
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "95 Isometric Distances Consider an input $_ { \\textbf { \\em x } }$ applied to a neural network that performs a parametrized   \n96 transformation ${ f } _ { \\boldsymbol { \\theta } } ( \\boldsymbol { x } )$ . Moreover, consider $p _ { \\phi } ^ { j }$ be the learnable prototype associated with the class $j$ .   \n97 Additionally, let the expression $\\| f _ { \\theta } ( \\pmb { x } ) - \\pmb { p } _ { \\phi } ^ { j } \\|$ represent the nonsquared Euclidean distance between   \n98 ${ f } _ { \\theta } ( { \\pmb x } )$ and $ { p _ { \\phi } ^ { j } }$ . Finally, consider $ { p _ { \\phi } ^ { k } }$ as a learnable prototype associated with the correct class for the   \n99 input $_ { \\textbf { \\em x } }$ . Hence, we write the IsoMax loss [27] for a batch of $N$ examples using the equation below: ",
+        "bbox": [
+            145,
+            561,
+            831,
+            647
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cb8d3086573b9798d57a11824fc2d4106aca52e0d67bdb55c0f9ec3ebf4ef2de.jpg",
+        "text": "$$\n\\mathcal { L } _ { \\sf l s o M a x } = - \\frac { 1 } { N } \\sum _ { k = 1 } ^ { N } \\log \\left( \\frac { \\exp ( - E _ { s } \\| \\mathbf { \\cdot } \\mathbf { \\boldsymbol { f } } _ { \\theta } ( x ) - \\mathbf { \\boldsymbol { p } } _ { \\phi } ^ { k } \\| ) } { \\sum _ { j } \\exp ( - E _ { s } \\| \\mathbf { \\cdot } \\mathbf { \\boldsymbol { f } } _ { \\theta } ( x ) - \\mathbf { \\boldsymbol { p } } _ { \\phi } ^ { j } \\| ) } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            312,
+            666,
+            684,
+            724
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "100 In the above equation, the $E _ { s }$ represents the entropic scale. From Equation (1), we observe that   \n101 the distances from IsoMax loss are given by the expression $\\mathcal { D } = \\| f _ { \\theta } ( \\pmb { x } ) - \\pmb { p } _ { \\phi } ^ { j } \\|$ . During inference,   \n102 probabilities calculated based on these distances are used to produce the negative entropy, which   \n103 serves as a score to perform OOD detection. However, as the features ${ f } _ { \\theta } ( { \\pmb x } )$ are unnormalized,   \n104 examples with low norms are unjustifiably favored to be considered OOD examples since they tend   \n105 to produce high entropy. Additionally, as the weights $ { p _ { \\phi } ^ { j } }$ are unnormalized, examples from classes   \n106 that present prototypes with low norms are unjustifiably favored to be considered OOD examples for   \n107 the same reason. ",
+        "bbox": [
+            140,
+            733,
+            825,
+            853
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "108 Hence, we propose to replace ${ f } _ { \\theta } ( { \\pmb x } )$ with its normalized version given by $\\widehat { { f _ { \\theta } ( \\mathbf { x } ) } } { = } f _ { \\theta } ( \\mathbf { x } ) / \\| f _ { \\theta } ( \\mathbf { \\boldsymbol { x } } ) \\|$ . Additionally, we propose to replace 109 $ { p _ { \\phi } ^ { j } }$ with its normalized version given by $\\scriptstyle { p _ { \\phi } ^ { j } = p _ { \\phi } ^ { j } / \\| p _ { \\phi } ^ { j } \\| }$ . The 110 expression $\\lVert \\boldsymbol { v } \\rVert$ represents the 2-norm of a given vector $\\textbf {  { v } }$ . ",
+        "bbox": [
+            142,
+            858,
+            826,
+            912
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/214f711d4d4e6e15419f917a413796223cdc220799e501395a3cc5d76dd7ee56.jpg",
+        "table_caption": [
+            "Table 2: Classification accuracy of models trained using SoftMax, IsoMax, and $\\mathbf { I s o M a x } _ { \\mathcal { T } }$ losses. In addition to avoiding classification accuracy drop compared with SoftMax-loss- and IsoMax-losstrained networks, IsoMax $\\boldsymbol { \\mathcal { Z } }$ -loss-trained models show higher OOD detection performance (Table 3). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Data</td><td>Train Accuracy (%) [↑] SoftMax Loss / IsoMax Loss / IsoMaxz Loss</td><td>Test Accuracy (%)[↑]</td></tr><tr><td rowspan=\"3\">DenseNetBC100</td><td>CIFAR10</td><td>99.9 / 99.9 / 99.9</td><td>95.4 /95.2 /95.2</td></tr><tr><td>CIFAR100</td><td>99.9 /99.0 / 99.9</td><td>77.5 / 77.5 / 76.8</td></tr><tr><td>SVHN</td><td>96.9 / 97.6 /97.1</td><td>96.6 /96.6 /96.6</td></tr><tr><td rowspan=\"3\">ResNet110</td><td>CIFAR10</td><td>99.9 / 99.9 / 99.9</td><td>94.5 /94.6 /94.6</td></tr><tr><td>CIFAR100</td><td>99.5 / 99.9 / 99.8</td><td>72.7 /74.1/ 73.9</td></tr><tr><td>SVHN</td><td>99.8 / 99.9 / 99.5</td><td>96.7 /96.9 /96.9</td></tr></table>",
+        "bbox": [
+            173,
+            140,
+            825,
+            265
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "111 However, while the distances in the original IsoMax loss may vary from zero to infinity, the distance   \n112 between two normalized vectors is always equal to or lower than two. To avoid this unjustifiable and   \n113 unreasonable restriction, we introduce the distance scale $d _ { s }$ , which is a scalar learnable parameter.   \n114 Naturally, we require the distance scale to always be positive by taking its absolute value $| d _ { s } |$ .   \n115 The feature normalization makes the solution isometric regardless of the norm of the features produced   \n116 by the examples. The distance scale is class independent, as it is a single scalar value regularly   \n117 learnable during training. The weight normalization and the class independence of the distance scale   \n118 make the solution isometric regarding all classes. Hence, the proposed distance is isometric because   \n119 it produces an isometric treatment of all features, prototypes, and classes. Therefore, we can write   \n120 the expression for the isometric distances used by the $\\operatorname { I s o M a x } _ { \\mathcal { T } }$ loss as: ",
+        "bbox": [
+            142,
+            287,
+            826,
+            344
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            349,
+            825,
+            435
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b75cf586a172945e69371f880b5ede1f0fe21319caa217d329a234a6e6e8fa6a.jpg",
+        "text": "$$\n\\mathcal { D } _ { \\mathcal { T } } = \\left| d _ { s } \\right| \\widehat { \\| f _ { \\theta } ( x ) } - \\widehat { p _ { \\phi } ^ { j } } \\|\n$$",
+        "text_format": "latex",
+        "bbox": [
+            415,
+            455,
+            583,
+            482
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "121 Returning to Equation (1), we can write the expression for the $\\operatorname { I s o M a x } _ { \\mathbb { Z } }$ loss as follows: ",
+        "bbox": [
+            135,
+            492,
+            746,
+            508
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/180d22f3e92474660840eaa6bc422edf9ec192d6d2c6201b0f557b1fcee869c8.jpg",
+        "text": "$$\n\\mathcal { L } _ { \\mathsf { l s o M a x } _ { \\boldsymbol { \\tau } } } = - \\frac { 1 } { N } \\sum _ { k = 1 } ^ { N } \\log \\left( \\frac { \\exp ( - E _ { s } \\left| \\boldsymbol { d } _ { s } \\right| \\left\\| \\widehat { \\pmb { f _ { \\theta } ( x ) } } - \\widehat { \\pmb { p _ { \\phi } ^ { k } } } \\right\\| ) } { \\sum _ { j } \\exp ( - E _ { s } \\left| \\boldsymbol { d } _ { s } \\right| \\left\\| \\widehat { \\pmb { f _ { \\theta } ( x ) } } - \\widehat { \\pmb { p _ { \\phi } ^ { j } } } \\right\\| ) } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            292,
+            530,
+            702,
+            597
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "122 Applying the entropy maximization trick (i.e., the removal of the entropic score $E _ { s }$ for inference) [27],   \n123 we can write the expression for the $\\operatorname { I s o M a x } _ { \\mathcal { T } }$ loss probabilities used during inference for performing   \n124 OOD detection when using the entropic score [27]: ",
+        "bbox": [
+            142,
+            607,
+            825,
+            650
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c68e1a7716b9bf87315449f996e5bd4a88ef09ca241fae00330c4ec5dc83bd0c.jpg",
+        "text": "$$\n\\mathcal { P } _ { \\mathsf { l s o M a x } _ { \\mathcal { Z } } } ( y ^ { ( i ) } | x ) = \\frac { \\exp ( - \\left| d _ { s } \\right| \\sqrt { f _ { \\theta } ( x ) } - \\widehat { p _ { \\phi } ^ { i } } \\| ) } { \\sum _ { j } \\exp ( - \\left| d _ { s } \\right| \\| \\widehat { f _ { \\theta } ( x ) } - \\widehat { p _ { \\phi } ^ { j } } \\| ) }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            333,
+            671,
+            666,
+            729
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "125 Different from IsoMax loss where the prototypes are initialized to a zero vector, we initialized all   \n126 prototypes using a normal distribution with a mean of zero and standard deviation of one. This   \n127 approach is necessary because we normalize the prototypes when using $\\operatorname { I s o M a x } _ { \\mathcal { T } }$ loss. The distance   \n128 scale is initialized to one. We add no hyperparameters to the solution.   \n129 Minimum Distance Score Motivated by the desired characteristics of the isometric distances used   \n130 in $\\operatorname { I s o M a x } _ { \\mathbb { Z } }$ , we propose to use what we call the minimum distance as the score for performing OOD   \n131 detection. Naturally, the minimum distance score for the $\\operatorname { I s o M a x } _ { \\mathcal { Z } }$ is given by: ",
+        "bbox": [
+            142,
+            739,
+            825,
+            796
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            810,
+            825,
+            853
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/664890d3324f85236f1fb00f5c55419fc0d2a4d3a492db89912bbb4a3aa82a09.jpg",
+        "text": "$$\nS _ { \\mathrm { M i n D i s t a n c e } } = \\operatorname* { m i n } _ { j } \\left( \\| { \\widehat { \\mathbf { f } _ { \\theta } ( x ) } } - { \\widehat { \\mathbf { p } _ { \\phi } ^ { j } } } \\| \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            379,
+            875,
+            619,
+            910
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/0524ffb958915b7630c7d1db716561516b7104cee3d8e42d6a1b610972e94b64.jpg",
+        "table_caption": [
+            "Table 3: Fair comparison of seamless approaches: No hyperparameter tuning, no additional/extra/outlier data, no classification accuracy drop, and no slow/inefficient inferences. SoftMax+ES means training using SoftMax loss and performing OOD detection using the entropic score (ES). IsoMax+ES means training using IsoMax loss and performing OOD detection using the entropic score (ES). $\\operatorname { I s o M a x } _ { \\mathbb { Z } } { + } \\mathbf { M } \\mathbf { D } \\mathbf { S }$ means training using $\\operatorname { I s o M a x } _ { \\mathcal { Z } }$ loss and performing OOD detection using minimum distance score (MDS). The best results are in bold ( $0 . 5 \\%$ tolerance). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Model</td><td rowspan=\"2\">Data (training)</td><td rowspan=\"2\">OOD (unseen)</td><td colspan=\"2\">Out-of-Distribution Detection: Seamless Approaches.</td></tr><tr><td>TNR@TPR95 (%) [↑] SoftMax+ES /IsoMax+ES /IsoMaxx+MDS (ours)</td><td>AUROC (%) [↑]</td></tr><tr><td rowspan=\"5\">DenseNetBC100</td><td>CIFAR10</td><td>SVHN TinyImageNet LSUN</td><td>33.2 / 77.0 /97.2 59.8 / 88.0 / 92.5</td><td>86.9 / 96.6 / 99.5 94.2/97.8/98.6</td></tr><tr><td>CIFAR100</td><td>SVHN TinyImageNet</td><td>69.5 / 94.5 /95.3 24.9/ 23.4/ 78.6 23.7 / 49.1 / 85.6</td><td>95.9 / 98.8 / 99.1 81.9 / 88.6 / 96.5 78.8 / 92.6 / 97.6</td></tr><tr><td rowspan=\"2\"></td><td>LSUN</td><td>24.4 / 63.0 / 83.4</td><td>77.9 /94.7 / 97.4</td></tr><tr><td>CIFAR10</td><td>83.7 / 94.1 /95.3</td><td>96.9 / 98.5 /99.1</td></tr><tr><td rowspan=\"2\">SVHN</td><td>TinyImageNet LSUN</td><td>90.0 / 97.0/98.3</td><td>98.1/99.1/99.7</td></tr><tr><td>SVHN</td><td></td><td>88.4 / 96.8 /97.8</td><td>97.8 / 99.1 / 99.7</td></tr><tr><td rowspan=\"6\">ResNet110</td><td>CIFAR10</td><td>TinyImageNet</td><td>37.8/ 73.0/83.6 43.7 /73.7/75.5</td><td>89.6 / 95.1 / 97.3</td></tr><tr><td rowspan=\"2\"></td><td>LSUN</td><td>52.1 / 82.8 /86.3</td><td>90.6 / 95.9/96.0 92.8 /96.9 / 97.7</td></tr><tr><td>SVHN</td><td></td><td></td></tr><tr><td rowspan=\"2\">CIFAR100</td><td>TinyImageNet</td><td>15.4 / 18.7 /30.7</td><td>67.5 / 84.7 / 85.8</td></tr><tr><td>LSUN</td><td>18.8 /26.3 /42.9</td><td>73.5/ 84.5 / 87.9</td></tr><tr><td rowspan=\"2\">SVHN</td><td>CIFAR10</td><td>21.3 / 30.2/46.9</td><td>76.4 / 87.1 / 89.4</td></tr><tr><td rowspan=\"2\"></td><td>TinyImageNet</td><td>68.6 / 80.4 / 72.0 71.7 / 84.4 / 83.1</td><td>91.7 / 95.2/93.3</td></tr><tr><td>LSUN</td><td>69.1/ 80.4/ 76.3</td><td>93.1 / 95.8/96.2 91.8 /94.3/94.3</td></tr></table>",
+        "bbox": [
+            173,
+            180,
+            825,
+            513
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "132 In the previous equation, $| d _ { s } |$ was removed because it is a scale factor that does not change after   \n133 the training is completed. The minimum distance is computed to perform the classification, as the   \n134 predicted class is the one that presents the lowest feature-prototype distance. Therefore, when using   \n135 this score, the OOD detection presents essentially zero latency and computational cost, as we simply   \n136 reuse the minimum distance already calculated. ",
+        "bbox": [
+            142,
+            544,
+            825,
+            614
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "137 3 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            143,
+            638,
+            312,
+            656
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "138 To allow standardized comparison, we used the datasets, training procedures, and metrics that were   \n139 established in Hendrycks & Gimpel [9] and adopted in many subsequent OOD detection papers   \n140 [23, 19, 8]. We did not compare to approaches that produce classification accuracy drop (e.g.,   \n141 [34, 11]), as this is a substantial limitation from a practical perspective [1]. The code to reproduce the   \n142 results is available as supplementary material.   \n143 We trained many 100-layer DenseNetBCs with growth rate $k = 1 2$ (i.e., 0.8M parameters) [12],   \n144 110-layer ResNets $[ 7 ] ^ { 3 }$ , and 34-layer ResNets $[ 7 ] ^ { \\overline { { 4 } } }$ on CIFAR10 [15], CIFAR100 [15], and SVHN   \n145 [29] datasets with SoftMax, IsoMax, and $\\operatorname { I s o M a x } _ { \\mathbb { Z } }$ losses using the same procedures (e.g., initial   \n146 learning rate, learning rate schedule, weight decay) presented in Lee et al. [19]. ",
+        "bbox": [
+            143,
+            672,
+            825,
+            742
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            747,
+            825,
+            804
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We used SGD with the Nesterov moment equal to 0.9 during 300 epochs with a batch size of 64, and an initial learning rate of 0.1 with a learning rate decay rate equal to ten applied in the epoch number 150, 200, and 250. The weight decay was 0.0001. We did not use dropout. We used a computer with CPU Intel i7-4790K, 4.00GHz, x64, octa-core, 32Gb RAM, and a GPU Nvidia GTX 1080 Ti. ",
+        "bbox": [
+            171,
+            810,
+            825,
+            866
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/cb1317dd72b8ab03d7815bc9bff27ee9cc94013e86ca5c11dce34e50d888a661.jpg",
+        "table_caption": [
+            "Table 4: Unfair comparison with approaches that use input preprocessing and produce slow/inefficient inferences in addition to requiring validation using adversarial examples. ODIN and Mahalanobis were applied to models trained using SoftMax loss. These approaches present at least four times slower and less power efficient inferences [27], as they use input preprocessing. Their hyperparameters were validated using adversarial examples. $\\operatorname { I s o M a x } _ { \\mathbb { Z } } { + } \\mathbf { M } \\mathbf { D } \\mathbf { S }$ (ours) means training using $\\operatorname { I s o M a x } _ { \\mathbb { Z } }$ loss and performing OOD detection using minimum distance score (MDS). The best results are in bold ( $0 . 5 \\%$ tolerance). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Model</td><td rowspan=\"2\">Data (training)</td><td rowspan=\"2\">0OD (unseen)</td><td colspan=\"2\">Comparison with approaches that use input preprocessing and adversarial validation.</td></tr><tr><td>AUROC (%) [↑] ODIN /Mahalanobis /IsoMaxx+MDS (ours)</td><td>DTACC (%) [↑]</td></tr><tr><td rowspan=\"3\">DenseNetBC100</td><td rowspan=\"2\">CIFAR10</td><td>SVHN</td><td>92.8 / 97.6 / 99.5</td><td>86.5 / 92.6 / 96.3</td></tr><tr><td>TinyImageNet</td><td>97.2 / 98.8 / 98.6</td><td>92.1 / 95.0 / 93.9</td></tr><tr><td></td><td>LSUN</td><td>98.5 / 99.2 / 99.1</td><td>94.3 / 96.2 / 95.2</td></tr><tr><td rowspan=\"3\"></td><td rowspan=\"2\">CIFAR100</td><td>SVHN TinyImageNet</td><td>88.2 / 91.8 /96.5 85.3 / 97.0 /97.6</td><td>80.7 / 84.6 /90.0 77.2 / 91.8 / 91.6</td></tr><tr><td>LSUN</td><td>85.7 / 97.9 / 97.4</td><td>77.3 / 93.8 / 90.8</td></tr><tr><td></td><td>SVHN</td><td>86.5 / 95.5 / 98.2</td><td></td></tr><tr><td rowspan=\"3\">ResNet34</td><td>CIFAR10</td><td>TinyImageNet</td><td>93.9 / 99.0 /94.8</td><td>77.8 / 89.1 / 93.0 86.0 / 95.4 / 88.5</td></tr><tr><td rowspan=\"2\"></td><td>LSUN</td><td>93.7 / 99.5 / 96.6</td><td>85.8 / 97.2 / 91.0</td></tr><tr><td>SVHN</td><td></td><td></td></tr><tr><td rowspan=\"2\"></td><td rowspan=\"2\">CIFAR100</td><td>TinyImageNet</td><td>72.0 / 84.4 / 88.3 83.6 / 87.9 / 90.5</td><td>67.7 / 76.5 / 82.6</td></tr><tr><td>LSUN</td><td>81.9 / 82.3 / 88.3</td><td>75.9 / 84.6 / 84.4 74.6 / 79.7 / 82.6</td></tr></table>",
+        "bbox": [
+            173,
+            217,
+            826,
+            512
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/cb2093c8e91321984073fbb0d121c791a159f4a071b2fe13fe8e9fae625ec96b.jpg",
+        "table_caption": [
+            "Table 5: Unfair comparison of outlier exposure-enhanced SoftMax loss with IsoMax loss and $\\mathbf { I s o M a x } _ { \\mathcal { T } }$ loss without using extra data. SoftMax $\\mathrm { \\Lambda } ^ { \\mathrm { O E } } { + } \\mathrm { E } { S }$ means training using SoftMax loss enhanced during training by using outlier exposure [10], which requires the collection of outlier data, and performing OOD detection using the entropic score (ES). We used the same outlier data used in [10]. In each case, we collected the same amount of outlier data as the number of training examples present in the training set used to train SoftMaxOE. Despite being possible [26], the IsoMax loss and $\\operatorname { I s o M a x } _ { \\mathbb { Z } }$ loss were not enhanced with outlier exposure to keep the solution seamless. IsoMax $+ \\mathrm { E S }$ means training using IsoMax loss and performing OOD detection using the entropic score (ES). $\\operatorname { I s o M a x } _ { \\mathbb { Z } } { + } \\mathbf { M } \\mathbf { D } \\mathbf { S }$ (ours) means training using $\\operatorname { I s o M a x } _ { \\mathbb { Z } }$ loss and performing OOD detection using minimum distance score (MDS). The values of the performance metrics TNR $@$ TPR95 and AUROC were averaged over all out-of-distribution. The best values are in bold ( $0 . 5 \\%$ tolerance). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Model</td><td rowspan=\"2\">Data (training)</td><td colspan=\"2\">Comparison of IsoMax loss variants without using extra data with outlier exposure-enhanced SoftMax loss.</td></tr><tr><td>TNR@TPR95 （%) [↑] SoftMaxOE+ES /IsoMax+ES /IsoMaxz+MDS (ours)</td><td>AUROC (%) [↑]</td></tr><tr><td rowspan=\"2\">DenseNetBC100</td><td>CIFAR10</td><td>93.8 / 84.1 / 95.0</td><td>98.5 / 97.3 / 99.1</td></tr><tr><td>CIFAR100</td><td>23.0 / 45.1 / 82.5</td><td>80.5 / 91.9 / 97.0</td></tr><tr><td rowspan=\"2\">ResNet110</td><td>CIFAR10</td><td>92.6 / 76.5 / 81.8</td><td>98.0 /96.0 / 97.0</td></tr><tr><td>CIFAR100</td><td>36.1 / 25.1 / 40.2</td><td>83.2 / 85.5 / 87.7</td></tr></table>",
+        "bbox": [
+            173,
+            728,
+            825,
+            885
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/19d3c6ca06a641259d05f06d12b5f22aafd23767a690f75e943dc89e4eb4816a.jpg",
+        "image_caption": [
+            "Figure 1: (a) The no isometric distances used by the IsoMax loss make detecting out-of-distribution examples difficult using the minimum distance score. Consequently, the minimum distance score is not competitive with the entropic score in this case. (b) The isometric distances used by the $\\operatorname { I s o M a x } _ { \\mathbb { Z } }$ loss make detecting out-of-distribution examples easy using the minimum distance score. Consequently, the minimum distance score usually overcomes the entropic score in this situation. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            92,
+            810,
+            430
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "151 We used resized images from the datasets TinyImageNet $[ 2 ] ^ { 5 }$ and the Large-scale Scene UNderstand  \n152 ing dataset (LSUN) $\\overline { { [ 3 6 ] } } ^ { 5 }$ following Lee et al. [19] to create out-of-distribution samples. We added   \n153 these out-of-distribution images to the validation sets presented in the CIFAR10, CIFAR100, and   \n154 SVHN to form the test sets and evaluate the OOD detection performance.   \n155 We evaluated the OOD detection performance using the true negative rate at $9 5 \\%$ true positive   \n156 rate (TNR $@$ TPR95), the area under the receiver operating characteristic curve (AUROC), and the   \n157 detection accuracy (DTACC), which corresponds to the maximum classification probability over all   \n158 possible thresholds $\\delta$ : ",
+        "bbox": [
+            142,
+            532,
+            825,
+            589
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            595,
+            825,
+            651
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/145c34532d056d4f5256d13096fa735b5f375d97b33f63ce4daede95b1cfa474.jpg",
+        "text": "$$\n1 - \\operatorname* { m i n } _ { \\delta } \\left\\{ P _ { \\mathrm { i n } } \\left( o \\left( \\mathbf { x } \\right) \\leq \\delta \\right) P \\left( \\mathbf { x } \\mathrm { i s } \\mathrm { f r o m } P _ { \\mathrm { i n } } \\right) + P _ { \\mathrm { o u t } } \\left( o \\left( \\mathbf { x } \\right) > \\delta \\right) P \\left( \\mathbf { x } \\mathrm { i s } \\mathrm { f r o m } P _ { \\mathrm { o u t } } \\right) \\right\\} ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            217,
+            655,
+            776,
+            679
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "159 where $o ( \\mathbf { x } )$ is the OOD detection score. It is assumed that both positive and negative samples have   \n160 an equal probability of being in the test set, i.e., $P$ ( $\\mathbf { \\bar { x } }$ is from $P _ { \\mathrm { i n } } ) = P$ ( $\\mathbf { x }$ is from $P _ { \\mathrm { { o u t } } }$ ). All the   \n161 mentioned metrics follow the calculation procedures specified in Lee et al. [19]. ",
+        "bbox": [
+            142,
+            684,
+            825,
+            727
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "62 4 Results and Discussion ",
+        "text_level": 1,
+        "bbox": [
+            155,
+            744,
+            395,
+            762
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Classification Accuracy Table 2 presents the classification accuracy results. It shows that $\\operatorname { I s o M a x } _ { \\mathcal { T } }$ loss does not present classification accuracy drop compared to SoftMax loss or IsoMax loss for all datasets and models. We observe that the IsoMax loss variants present more than one percent $( \\% 1 )$ better accuracy than the SoftMax loss when using ResNet110 on the CIFAR100 dataset. ",
+        "bbox": [
+            173,
+            775,
+            825,
+            832
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "167 Out-of-Distribution Detection We report the results using the entropic score for SoftMax loss   \n168 (SoftMax+ES), outlier exposure-enhanced SoftMax loss (SoftMax $\\mathrm { ^ { O E } + E S }$ ), and IsoMax loss (Iso  \n169 Max $+ \\mathrm { E S }$ ) because it always overcame the maximum probability score and minimum distance score in   \n170 these cases. For $\\operatorname { I s o M a x } _ { \\mathcal { T } }$ , we report the values using the minimum distance score $( \\mathrm { I s o M a x } _ { \\mathcal { T } } { + } \\mathrm { M D S } )$ ),   \n171 as it usually overcame the maximum probability and the entropic score in this situation.   \n172 The Table 3 summarizes the results of the fair OOD detection comparison. In the mentioned table,   \n173 all approaches are accurate (no classification accuracy drop), fast and power-efficient (inferences   \n174 are performed without input preprocessing), and no validation is required to define hyperparameters.   \n175 Additionally, no additional/extra/outlier data are needed. In most cases, $\\operatorname { I s o M a x } _ { \\mathbb { Z } } { + } \\mathbf { M } \\mathbf { D } \\mathbf { S }$ overcomes   \n176 IsoMax $+ \\mathrm { E S }$ performance, regardless of the model, dataset, and out-of-distribution.   \n177 The minimum distance score produces high OOD detection performance when combined with the   \n178 $\\operatorname { I s o M a x } _ { \\mathcal { T } }$ , which evidences that the isometrization of the distances indeed work in this case. However,   \n179 the same minimum distance score produced low OOD detection performance when combined with   \n180 the original IsoMax loss. The Fig. 1 provides an explanation for this fact.   \n181 Table 4 summarizes the results of an unfair OOD detection comparison, as the methods present differ  \n182 ent requirements and produce distinct side effects. ODIN [23] and the Mahalanobis [19] approaches   \n183 require adversarial samples to be generated to validate hyperparameters for each combination of   \n184 dataset and model. Moreover, these approaches use input preprocessing, which makes inferences   \n185 at least four times slower and at least four times less energy-efficient. Validation using adversarial   \n186 examples may be a cumbersome procedure to be performed from scratch on novel datasets, as hyper  \n187 parameters such as optimal adversarial perturbations may be unknown in such cases. $\\operatorname { I s o M a x } _ { \\mathbb { Z } } { + } \\mathbf { M } \\mathbf { D } \\mathbf { S }$   \n188 does not present these special requirements and does not produce the mentioned side effects.   \n189 Nevertheless, $\\operatorname { I s o M a x } _ { \\mathcal { Z } } { + } \\mathbf { M } \\mathbf { D } \\mathbf { S }$ provides higher performance than ODIN. Usually, this occurs by a   \n190 large margin. In addition to the changes between the entropy maximization trick and temperature   \n191 calibrations present in [27, 26], we emphasize that training with entropic scale affects the learning of   \n192 all weights while changing the temperature during inference affects only the last layer. Hence, the fact   \n193 that the proposed solution overcomes ODIN by a safe margin is additional evidence that the entropy   \n194 maximization trick often produces much higher OOD detection performance than temperature cali  \n195 bration, even when the latter is combined with input preprocessing. Besides, the entropy maximization   \n196 trick does not require access to validation data to tune the temperature. In addition to being seamless   \n197 and avoiding the Mahalanobis approach drawbacks, $\\operatorname { I s o M a x } _ { \\mathbb { Z } } { + } \\operatorname { M D S }$ usually overcomes it in terms of   \n198 AUROC and produces similar performance when considering the DTACC.   \n199 Table 5 unfairly compares the performance of the proposed approach with the outlier exposure   \n200 solution. Similar to IsoMax variants, the outlier exposure approach does not require hyperparameters   \n201 tuning and produces efficient inferences. However, it requires collecting outlier data, while our   \n202 approach does not. It is important to emphasize that outlier exposure may also be combined with   \n203 IsoMax loss variants to increase the OOD detection performance further [26]. Nevertheless, in   \n204 the mentioned table, we preferred to present the IsoMax loss variants without outlier exposure to   \n205 show that the outlier exposure-enhanced SoftMax loss usually present lower OOD detection than   \n206 $\\operatorname { I s o M a x } _ { \\mathbb { Z } } { + } \\mathbf { M } \\mathbf { D } \\mathbf { S }$ even without using outlier exposure. ",
+        "bbox": [
+            143,
+            847,
+            825,
+            888
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            92,
+            825,
+            119
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            126,
+            826,
+            195
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            200,
+            825,
+            257
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            263,
+            825,
+            375
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            381,
+            825,
+            518
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            525,
+            825,
+            636
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            165,
+            655,
+            299,
+            672
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we improved the IsoMax loss by replacing its original distance with what we call the isometric distance. Additionally, we proposed a zero computational cost minimum distance score. The experiments showed that these modifications produce higher OOD detection performance while keeping desired benefits of IsoMax loss (absence of hyperparameters to tune, no reliance on additional/extra/outlier data, fast and power-efficient inference, and no classification accuracy drop). ",
+        "bbox": [
+            173,
+            686,
+            825,
+            756
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "213 Similar to IsoMax loss, after training using the proposed $\\operatorname { I s o M a x } _ { \\mathcal { Z } }$ loss, we may apply inference-based   \n214 approaches (e.g., Gram matrices, outlier exposure, energy-based) to the pretrained model to eventually   \n215 increase even more the overall OOD detection performance. Therefore, instead of competitors, the   \n216 OOD detection approaches that may be applied to pretrained models are actually complementary to   \n217 our approach [27, 26]. Hence, there is no drawback in training a model using $\\operatorname { I s o M a x } _ { \\mathbb { Z } }$ loss instead   \n218 of SoftMax loss or IsoMax loss, regardless of planning to subsequently use an inference-based OOD   \n219 detection approach to increase the OOD detection performance further.   \n220 In future works, considering its simplicity, we plan to verify whether our approach scales satisfactorily   \n221 to large-scale image datasets such as ImageNet. We also intend to verify the performance of our   \n222 solution using text datasets. ",
+        "bbox": [
+            147,
+            762,
+            825,
+            859
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            866,
+            826,
+            907
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            143,
+            90,
+            267,
+            106
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "[1] Carlini, N., Athalye, A., Papernot, N., Brendel, W., Rauber, J., Tsipras, D., Goodfellow, I. J., Madry, A., and Kurakin, A. On evaluating adversarial robustness. CoRR, abs/1902.06705, 2019.   \n[2] Deng, J., Dong, W., Socher, R., Li, L., Li, K., and Li, F. ImageNet: A large-scale hierarchical image database. Computer Vision and Pattern Recognition, 2009.   \n[3] DeVries, T. and Taylor, G. W. Learning confidence for out-of-distribution detection in neural networks. CoRR, abs/1802.04865, 2018.   \n[4] DeVries, T. and Taylor, G. W. Leveraging uncertainty estimates for predicting segmentation quality. CoRR, abs/1807.00502, 2018.   \n[5] Dhamija, A. R., Günther, M., and Boult, T. E. Reducing network agnostophobia. Neural Information Processing Systems, 2018.   \n[6] Gal, Y. and Ghahramani, Z. Dropout as a bayesian approximation: Representing model uncertainty in deep learning. International Conference on Machine Learning, 2016.   \n[7] He, K., Zhang, X., Ren, S., and Sun, J. Identity mappings in deep residual networks. European Conference on Computer Vision, 2016.   \n[8] Hein, M., Andriushchenko, M., and Bitterwolf, J. Why ReLU networks yield high-confidence predictions far away from the training data and how to mitigate the problem. Computer Vision and Pattern Recognition, 2018.   \n[9] Hendrycks, D. and Gimpel, K. A baseline for detecting misclassified and out-of-distribution examples in neural networks. International Conference on Learning Representations, 2017.   \n[10] Hendrycks, D., Mazeika, M., and Dietterich, T. Deep anomaly detection with outlier exposure. International Conference on Learning Representations, 2019.   \n[11] Hsu, Y.-C., Shen, Y., Jin, H., and Kira, Z. Generalized ODIN: Detecting out-of-distribution image without learning from out-of-distribution data. Computer Vision and Pattern Recognition, 2020.   \n[12] Huang, G., Liu, Z., Maaten, L. v. d., and Weinberger, K. Q. Densely connected convolutional networks. Computer Vision and Pattern Recognition, 2017.   \n[13] Kendall, A. and Gal, Y. What uncertainties do we need in bayesian deep learning for computer vision? Neural Information Processing Systems, 2017.   \n[14] Kliger, M. and Fleishman, S. Novelty detection with GAN. CoRR, abs/1802.10560, 2018.   \n[15] Krizhevsky, A. Learning multiple layers of features from tiny images. Science Department, University of Toronto, 2009.   \n[16] Kuleshov, V., Fenner, N., and Ermon, S. Accurate uncertainties for deep learning using calibrated regression. International Conference on Machine Learning, 2018.   \n[17] Lakshminarayanan, B., Pritzel, A., and Blundell, C. Simple and scalable predictive uncertainty estimation using deep ensembles. Neural Information Processing Systems, 2017.   \n[18] Lee, K., Lee, H., Lee, K., and Shin, J. Training confidence-calibrated classifiers for detecting out-of-distribution samples. International Conference on Learning Representations, 2018.   \n[19] Lee, K., Lee, K., Lee, H., and Shin, J. A simple unified framework for detecting out-ofdistribution samples and adversarial attacks. Neural Information Processing Systems, 2018.   \n[20] Leibig, C., Allken, V., Ayhan, M. S., Berens, P., and Wahl, S. Leveraging uncertainty information from deep neural networks for disease detection. Scientific Reports, 7, 2017.   \n[21] Li, D., Chen, D., Goh, J., and Ng, S. Anomaly detection with generative adversarial networks for multivariate time series. CoRR, abs/1809.04758, 2018.   \n[22] Liang, S., Li, Y., and Srikant, R. Principled detection of out-of-distribution examples in neural networks. CoRR, abs/1706.02690, 2017.   \n[23] Liang, S., Li, Y., and Srikant, R. Enhancing the reliability of out-of-distribution image detection in neural networks. International Conference on Learning Representations, 2018.   \n[24] Liu, W., Wen, Y., Yu, Z., and Yang, M. Large-margin softmax loss for convolutional neural networks. International Conference on Machine Learning, 2016.   \n[25] Liu, W., Wang, X., Owens, J. D., and Li, Y. Energy-based out-of-distribution detection. Neural Information Processing Systems, 2020.   \n[26] Macêdo, D., Ren, T. I., Zanchettin, C., Oliveira, A. L. I., and Ludermir, T. B. Entropic out-ofdistribution detection: Seamless detection of unknown examples. CoRR, abs/2006.04005, 2021. URL https://arxiv.org/abs/2006.04005.   \n[27] Macêdo, D., Ren, T. I., Zanchettin, C., Oliveira, A. L. I., and Ludermir, T. B. Entropic outof-distribution detection. Accepted for publication in The International Joint Conference on Neural Networks (IJCNN), 2021. URL https://arxiv.org/abs/1908.05569.   \n[28] Malinin, A. and Gales, M. Predictive uncertainty estimation via prior networks. Neural Information Processing Systems, 2018.   \n[29] Netzer, Y. and Wang, T. Reading digits in natural images with unsupervised feature learning. Neural Information Processing Systems, 2011.   \n[30] Sastry, C. S. and Oore, S. Detecting out-of-distribution examples with gram matrices. International Conference on Machine Learning, 2020.   \n[31] Schwartz, R., Dodge, J., Smith, N. A., and Etzioni, O. Green AI. Communications of the ACM, 63(12):54–63, 2020.   \n[32] Shafaei, A., Schmidt, M., and Little, J. J. A less biased evaluation of out-of-distribution sample detectors. British Machine Vision Conference, 2019.   \n[33] Subramanya, A., Srinivas, S., and Babu, R. V. Confidence estimation in deep neural networks via density modelling. CoRR, abs/1707.07013, 2017.   \n[34] Techapanurak, E., Suganuma, M., and Okatani, T. Hyperparameter-free out-of-distribution detection using cosine similarity. Asian Conference on Computer Vision (ACCV), November 2020.   \n[35] Vyas, A., Jammalamadaka, N., Zhu, X., Das, D., Kaul, B., and Willke, T. L. Out-of-distribution detection using an ensemble of self supervised leave-out classifiers. European Conference on Computer Vision, 2018.   \n[36] Yu, F., Zhang, Y., Song, S., Seff, A., and Xiao, J. LSUN: construction of a large-scale image dataset using deep learning with humans in the loop. CoRR, abs/1506.03365, 2015.   \n[37] Yu, Q. and Aizawa, K. Unsupervised out-of-distribution detection by maximum classifier discrepancy. International Conference on Computer Vision, 2019. ",
+        "bbox": [
+            171,
+            102,
+            830,
+            917
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            160,
+            89,
+            828,
+            747
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            116,
+            339,
+            130
+        ],
+        "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] All claims are demonstrated using argumentation and substantial experiments.   \n(b) Did you describe the limitations of your work? [Yes] Please, see the last paragraph of the conclusion.   \n(c) Did you discuss any potential negative societal impacts of your work? [N/A] Actually, our approach is much more energy-efficient and environment-friendly than most competing approaches (see the third and the fifth paragraphs of the introduction).   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            238,
+            135,
+            825,
+            281
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            215,
+            285,
+            493,
+            300
+        ],
+        "page_idx": 10
+    },
+    {
+        "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": [
+            236,
+            304,
+            738,
+            335
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            214,
+            339,
+            393,
+            354
+        ],
+        "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)? [Yes]   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes]   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [N/A] We applied a tolerance to indicate the best approaches.   \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] ",
+        "bbox": [
+            238,
+            358,
+            825,
+            477
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            212,
+            481,
+            823,
+            496
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes]   \n(b) Did you mention the license of the assets? [Yes]   \n(c) Did you include any new assets either in the supplemental material or as a URL? [Yes]   \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,
+            500,
+            823,
+            608
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            212,
+            611,
+            705,
+            626
+        ],
+        "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,
+            630,
+            825,
+            719
+        ],
+        "page_idx": 10
+    }
+]

parse/train/rylrdxHFDr/rylrdxHFDr.md

@@ -0,0 +1,442 @@
+# STATE ALIGNMENT-BASED IMITATION LEARNING
+
+Fangchen Liu Zhan Ling Tongzhou Mu Hao Su
+
+University of California San Diego La Jolla, CA 92093, USA {fliu,z6ling,t3mu,haosu}@eng.ucsd.edu
+
+# ABSTRACT
+
+Consider an imitation learning problem that the imitator and the expert have different dynamics models. Most of the current imitation learning methods fail because they focus on imitating actions. We propose a novel state alignment based imitation learning method to train the imitator to follow the state sequences in expert demonstrations as much as possible. The state alignment comes from both local and global perspectives and we combine them into a reinforcement learning framework by a regularized policy update objective. We show the superiority of our method on standard imitation learning settings and imitation learning settings where the expert and imitator have different dynamics models.
+
+# 1 INTRODUCTION
+
+Learning from demonstrations (imitation learning, abbr. as IL) is a basic strategy to train agents for solving complicated tasks. Imitation learning methods can be generally divided into two categories: behavior cloning (BC) and inverse reinforcement learning (IRL). Behavior cloning (Ross et al., 2011b) formulates a supervised learning problem to learn a policy that maps states to actions using demonstration trajectories. Inverse reinforcement learning (Russell, 1998; $\mathrm { N g }$ et al., 2000) tries to find a proper reward function that can induce the given demonstration trajectories. GAIL (Ho & Ermon, 2016) and its variants (Fu et al.; Qureshi et al., 2018; Xiao et al., 2019) are the recently proposed IRL-based methods, which uses a GAN-based reward to align the distribution of stateaction pairs between the expert and the imitator.
+
+Although state-of-the-art BC and IRL methods have demonstrated compelling performance in standard imitation learning settings, e.g. control tasks (Ho & Ermon, 2016; Fu et al.; Qureshi et al., 2018; Xiao et al., 2019) and video games (Aytar et al., 2018b), these approaches are developed based on a strong assumption: the expert and the imitator share the same dynamics model; specifically, they have the same action space, and any feasible state-action pair leads to the same next state in probability for both agents. The assumption brings severe limitation in practical scenarios: Imagine that a robot with a low speed limit navigates through a maze by imitating another robot which moves fast, then, it is impossible for the slow robot to execute the exact actions as the fast robot. However, the demonstration from the fast robot should still be useful because it shows the path to go through the maze.
+
+We are interested in the imitation learning problem under a relaxed assumption: Given an imitator that shares the same state space with the expert but their dynamics may be different, we train the imitator to follow the state sequence in expert demonstrations as much as possible. This is a more general formulation since it poses fewer requirements on the experts and makes demonstration collection easier. Due to the dynamics mismatch, the imitator becomes more likely to deviate from the demonstrations compared with the traditional imitation learning setting. Therefore, it is very important that the imitator should be able to resume to the demonstration trajectory by itself. Note that neither BC-based methods nor GAIL-based IRL methods have learned to handle dynamics misalignment and deviation correction.
+
+To address the issues, we propose a novel approach with four main features: 1) State-based. Compared to the majority of literature in imitation learning, our approach is state-based rather than action-based. Not like BC and IRL that essentially match state-action pairs between the expert and the imitator, we only match states. An inverse model of the imitator dynamics is learned to recover the action; 2) Deviation Correction. A state-based $\beta$ -VAE (Higgins et al., 2017) is learned as the prior for the next state to visit. Compared with ordinary behavior cloning, this VAE-based next state predictor can advise the imitator to return to the demonstration trajectory when it deviates. The robustness benefits from VAE’s latent stochastic sampling; 3) Global State Alignment. While the VAE can help the agent to correct its trajectory to some extent, the agent may still occasionally enter states that are far away from demonstrations, where the VAE has no clue how to correct it. So we have to add a global constraint to align the states in demonstration and imitation. Inspired by GAIL that uses reward to align the distribution of state-action pairs, we also formulate an IRL problem whose maximal cumulative reward is the Wasserstein Distance between states of demonstration and imitation. Note that we choose not to involve state-action pairs as in GAIL(Ho & Ermon, 2016), or state-state pairs as in an observation-based GAIL (Torabi et al., 2018a), because our state-only formulation imposes weaker constraints than the two above options, thus providing more flexibility to handle different agent dynamics; 4) Regularized Policy Update. We combine the prior for next state learned from VAE and the Wasserstein distance-based global constraint from IRL in a unified framework, by imposing a Kullback-Leibler divergence based regularizer to the policy update in the Proximal Policy Optimization algorithm.
+
+To empirically justify our ideas, we conduct experiments in two different settings. We first show that our approach can achieve similar or better results on the standard imitation learning setting, which assumes the same dynamics between the expert and the imitator. We then evaluate our approach in the more challenging setting that the dynamics of the expert and the imitator are different. In a number of control tasks, we either change the physics properties of the imitators or cripple them by changing their geometries. Existing approaches either fail or can only achieve very low rewards, but our approach can still exhibit decent performance. Finally, we show that even for imitation across agents of completely different actuators, it is still possible for the state-alignment based method to work. Surprisingly, a point mass and an ant in MuJoCo (Todorov et al., 2012) can imitate each other to navigate in a maze environment.
+
+Our contributions can be summarized as follows:
+
+• Propose to use a state alignment based method in the imitation learning problems where the expert’s and the imitator’s dynamics are different.   
+• Propose a local state alignment method based on $\beta$ -VAE and a global state alignment method based on Wasserstein distance. Combine the local alignment and global alignment components into a reinforcement learning framework by a regularized policy update objective.
+
+# 2 RELATED WORK
+
+Imitation learning is widely used in solving complicated tasks where pure reinforcement learning might suffer from high sample complexity, like robotics control (Le et al., 2017; Ye & Alterovitz, 2017; Pathak et al., 2018), autonomous vehicle (Fu et al.; Pomerleau, 1989), and playing video game (Hester et al., 2018; Pohlen et al., 2018; Aytar et al., 2018a). Behavioral cloning (Bain & Sommut, 1999) is a straight-forward method to learn a policy in a supervised way. However, behavioral cloning suffers from the problem of compounding errors as shown by (Ross & Bagnell, 2010), and this can be somewhat alleviated by interactive learning, such as DAGGER (Ross et al., 2011b). Another important line in imitation learning is inverse reinforcement learning (Russell, 1998; Ng et al., 2000; Abbeel & Ng, 2004; Ziebart et al., 2008; Fu et al.), which finds a cost function under which the expert is uniquely optimal.
+
+Since IRL can be connected to min-max formulations, works like GAIL, SAM (Ho & Ermon, 2016; Blonde & Kalousis, 2018) utilize this to directly recover policies. Its connections with GANs (Good- ´ fellow et al., 2014) also lead to $f$ -divergence minimization (Ke et al., 2019; Nowozin et al., 2016) and Wasserstein distance minimization (Xiao et al., 2019). One can also extend the framework from matching state-action pairs to state distribution matching, such as Torabi et al. (2018a); Sun et al. (2019); Schroecker & Isbell (2017). Other works (Aytar et al., 2018b; Liu et al., 2018; Peng et al., 2018) also learn from observation alone, by defining reward on state and using IRL to solve the tasks. Works like (Lee et al., 2019; Lee et al.) also use state-based reward for exploration. Torabi et al. (2018b); Edwards et al. (2018) will recover actions from observations by learning an inverse model or latent actions. However, our work aims to combine the advantage of global state distribution matching and local state transition alignment, which combines the advantage of BC and IRL through a novel framework.
+
+# 3 BACKGROUNDS
+
+Variational Autoencoders Kingma & Welling (2013); Rezende et al. (2014) provides a framework to learn both a probabilistic generative model $p _ { \boldsymbol { \theta } } ( \mathbf { x } | \mathbf { z } )$ as well as an approximated posterior
+
+![](images/8f713a57a3b582c724f49c73d421b5634ed57391836fea1855a0f42d78faf61f.jpg)  
+Figure 2: Visualization of state alignment
+
+distribution $q _ { \phi } ( { \bf z } | { \bf x } )$ . $\beta$ -VAE is a variant VAE that introduces an adjustable hyperparameter $\beta$ to the original objective:
+
+$$
+\mathcal { L } ( \boldsymbol { \theta } , \boldsymbol { \phi } ; \mathbf { x } , \mathbf { z } , \boldsymbol { \beta } ) = \mathbb { E } _ { q _ { \phi } ( \mathbf { z } | \mathbf { x } ) } \left[ \log p _ { \theta } ( \mathbf { x } | \mathbf { z } ) \right] - \beta D _ { K L } \left( q _ { \phi } ( \mathbf { z } | \mathbf { x } ) \| p ( \mathbf { z } ) \right)
+$$
+
+Larger $\beta$ will penalize the total correlation (Chen et al., 2018) to encourage more disentangled latent representations, while smaller $\beta$ often results in sharper and more precise reconstructions.
+
+Wasserstein distance The Wasserstein distance between two density functions $p ( x )$ and $q ( x )$ with support on a compact metric space $( M , d )$ has an alternative form due to Kantorovich-Rubenstein duality (Villani, 2008):
+
+$$
+\mathcal { W } ( p , q ) = \operatorname* { s u p } _ { \phi \in \mathcal { L } _ { 1 } } \mathbb { E } _ { p ( x ) } [ \phi ( x ) ] - \mathbb { E } _ { q ( x ) } [ \phi ( x ) ]
+$$
+
+Here, $\mathcal { L } _ { 1 }$ is the set of all 1-Lipschitz functions from $\mathcal { M }$ to $\mathbb { R }$ . Compared with the prevalent KLdivergence and its extension, the f-divergence family, Wasserstein distance has a number of advantages theoretically and numerically. Please refer to Arjovsky et al. (2017) and Solomon (2018) for a detailed discussion.
+
+# 4 SAIL: STATE ALIGNMENT BASED IMITATION LEARNING
+
+# 4.1 OVERVIEW
+
+Our imitation learning method is based on state alignment from both local and global perspectives. For local alignment, the goal is to follow the transition of the demonstration as much as possible, and allow the return to the demonstration trajectory whenever the imitation deviates. To achieve both goals, we use a $\beta$ - VAE (Higgins et al., 2017) to generate the next state (Figure 2 Left). For global alignment, we set up an objective to minimize the Wasserstein distance between the states in the current trajectory and the demonstrations (Figure 2 Right). There has to be a framework to naturally combine the local alignment and global alignment components. We resort to the reinforcement learning framework by encoding the local alignment as policy prior and encoding the global alignment as reward over states. Using Proximal Policy Optimization (PPO) by Schulman et al. (2017) as the backbone
+
+![](images/bb04f74d535c7df95d8e43e3ca6c2ebaad133059d55f6f0861254be0462d0a9c.jpg)  
+Figure 1: Using VAE as a state predictive model will be more self-correctable because of the stochastic sampling mechanism. But this won’t happen when we use VAE to predict actions.
+
+RL solver, we derive a regularized policy update. To maximally exploit the knowledge from demonstrations and reduce interactions with the environment, we adopt a pre-training stage to produce a good initialization based on the same policy prior induced by the local alignment. Our method is summarized in Algorithm 1. In the rest parts of this section, we will introduce all the components of our method in details.
+
+# 4.2 LOCAL ALIGNMENT BY STATE PREDICTIVE VAE
+
+To align the transition of states locally, we need a predictive model to generate the next state which the agent should target at. And then we can train an inverse dynamics model to recover the cor
+
+Require: Expert trajectories $\tau _ { e } : [ s _ { 1 } , a _ { 1 } , s _ { 2 } , a _ { 2 } , . . . ] \sim \pi _ { e }$ , initial policy $\pi$ , inverse dynamics model   
+$g$ , discriminator $\phi$ , total episode $T$ , memory capacity $S$   
+1: if Imitator and Expert have the same dynamics model then   
+2: Pre-train $g$ using $\tau _ { e }$ and transitions collected by a random policy   
+3 : else   
+4: Pre-train $g$ using transitions collected by a random policy   
+5: end if   
+6: Pre-train VAE using $\tau _ { e }$ , and obtain the policy prior $\triangleright$ Pre-train VAE and obtain policy prior   
+7: Pretrain $\pi$ using policy prior as described in Sec 4.5   
+8: while episode $\leq \mathrm { T }$ do   
+9: while $| \tau | \leq S$ do . $\tau$ is the collected trajectories   
+10: Collect trajectory $\left\{ \left( s , a , s ^ { \prime } , r , d o n e \right) \right\}$ using $\pi$   
+11: Update $r$ using (4)   
+12: Add $\{ ( s , a , s ^ { \prime } , r , d o n e ) \}$ to $\tau$   
+13: end while   
+14: Train $\phi$ using $\begin{array} { r } { \operatorname* { m a x } _ { \phi \in \mathcal { L } _ { 1 } } E _ { s \sim \tau _ { e } } [ \phi ( s ) ] - E _ { s \sim \tau } [ \phi ( s ) ] } \end{array}$ . Calculate Wasserstein Distance   
+15: Update inverse dynamics model $g$   
+16: Update policy using (5)   
+17: end while
+
+responding action, so as to provide a direct supervision for policy. It is worth-noting that, while training an inverse dynamics model is generally challenging, it is not so hard if we only focus on the agent dynamics, especially when the low-dimensional control states are accessible as in many practical scenarios. The problem of how to learn high-quality inverse/forward dynamics models is an active research topic.
+
+Instead of using an ordinary network to memorize the subsequent states, which will suffer from the same issue of compounding errors as behavioral cloning (Ross & Bagnell, 2010; Ross et al., 2011a), we propose to use VAE to generate the next state based on the following two reasons. First, as shown in (Dai et al., 2018), VAE is more robust to outliers and regularize itself to find the support set of a data manifold, so it will generalize better for unseen data. Second, because of the latent stochastic sampling, the local neighborhood of a data point will have almost the same prediction, which is self-correctable when combined with a precise inverse dynamics model as illustrated in Figure 1.
+
+We can also use a VAE to generate action based on the current state. But if the agent deviated from the demonstration trajectory a little bit, this predicted action is not necessarily guide the agent back to the trajectory, as shown in Figure 1. And in $\mathrm { S e c } ~ 5 . 3 . 2 $ , we conduct experiments to compare the state predictive VAE and the action predictive VAE.
+
+Instead of the vanilla VAE, we use $\beta$ -VAE to balance the KL penalty and prediction error, with formulation shown in (1). In Sec 5, we discuss the effects of the hyper-parameter $\beta$ in different experiment settings as one of the ablation studies.
+
+# 4.3 GLOBAL ALIGNMENT BY WASSERSTEIN DISTANCE
+
+Due to the difference of dynamics between the expert and the imitator, the VAE-based local alignment cannot fully prevent the imitator from deviating from demonstrations. In such circumstances, we still need to assess whether the imitator is making progress in learning from the demonstrations. We, therefore, seek to control the difference between the state visitation distribution of the demonstration and imitator trajectories, which is a global constraint.
+
+Note that using this global constraint alone will not induce policies that follow from the demonstration. Consider the simple case of learning an imitator from experts of the same dynamics. The expert takes cyclic actions. If the expert runs for 100 cycles with a high velocity and the imitator runs for only 10 cycles with a low velocity within the same time span, their state distribution would still roughly align. That is why existing work such as GAIL aligns state-action occupancy measure. However, as shown later, our state-based distribution matching will be combined with the local alignment component, which will naturally resolve this issue. The advantage of this state-based distribution matching over state-action pair matching as in GAIL or state-next-state pair matching in (Torabi et al., 2018a) is that the constraint becomes loosened.
+
+We use IRL approach to achieve the state distribution matching by introducing a reinforcement learning problem. Our task is to design the reward to train an imitator that matches the state distribution of the expert.
+
+Before introducing the reward design, we first explain the computation of the Wasserstein distance between the expert trajectories $\{ \tau _ { e } \}$ and imitator trajectory $\{ \tau \}$ using the Kantorovich duality:
+
+$$
+\mathcal { W } ( \tau _ { e } , \tau ) = \operatorname* { s u p } _ { \phi \in \mathcal { L } _ { 1 } } \mathbb { E } _ { s \sim \tau _ { e } } [ \phi ( s ) ] - \mathbb { E } _ { s \sim \tau } [ \phi ( s ) ]
+$$
+
+where $\phi$ is the Kantorovich’s potential, and serves as the discriminator in WGAN (Arjovsky et al., 2017). $\phi$ is trained with a gradient penalty term as WGAN-GP introduced in (Gulrajani et al., 2017)
+
+After the rollout of imitator policy is obtained, the potential $\phi$ will be updated by (3). Assume a transition among an imitation policy rollout of length $T$ is $( s _ { i } , s _ { i + 1 } )$ . To provide a dense signal every timestep, we assign the reward as:
+
+$$
+r ( s _ { i } , s _ { i + 1 } ) = \frac { 1 } { T } [ \phi ( s _ { i + 1 } ) - \mathbb { E } _ { s \sim \tau _ { e } } \phi ( s ) ]
+$$
+
+We now explain the intuition of the above reward. By solving (3), those states of higher probability in demonstration will have a larger $\phi$ value. The reward in (4) will thus encourage the imitator to visit such states.
+
+Maximizing the curriculum reward will be equivalent to
+
+$$
+J ( \pi ) = \sum _ { t = 1 } ^ { T } \mathbb { E } _ { s _ { t } , s _ { t + 1 } \sim \pi } [ r ( s _ { t } , s _ { t + 1 } ) ] = \sum _ { t = 1 } ^ { T } \frac { \mathbb { E } _ { s _ { t + 1 } } [ \phi ( s _ { t + 1 } ) - \mathbb { E } _ { s \sim \tau _ { e } } [ \phi ( s ) ] ] } { T } = - \mathcal { W } ( \tau _ { e } , \tau )
+$$
+
+In other words, the optimal policy of this MDP best matches the state visitation distributions w.r.t Wasserstein distance.
+
+Compared with AIRL (Fu et al.) that also defines rewards on states only, our approach indeed enjoys certain advantages in certain cases. We provide a theoretical justification in the Appendix D.
+
+# 4.4 REGULARIZED PPO POLICY UPDATE OBJECTIVE
+
+As mentioned in the second paragraph of Sec 4.3, the global alignment has to be combined with local alignment. This is achieved by adding a prior to the original clipped PPO objective.
+
+We maximize the following unified objective function:
+
+$$
+J ( \pi _ { \boldsymbol { \theta } } ) = L ^ { C L I P } ( \boldsymbol { \theta } ) - \lambda D _ { K L } \left( \pi _ { \boldsymbol { \theta } } ( \cdot \left| \boldsymbol { s } _ { t } ) \right| \bigg | p _ { a } \right)
+$$
+
+We will explain the two terms in detail. $L ^ { C L I P } ( \theta )$ denotes the clipped surrogate objective used in the original PPO algorithm:
+
+$$
+L ^ { C L I P } \left( \theta \right) = \hat { \mathbb { E } } _ { t } \left[ \operatorname* { m i n } \left( \frac { \pi _ { \theta } ( a \vert s ) } { \pi _ { \theta _ { o l d } } ( a \vert s ) } \hat { A } _ { t } , \operatorname { c l i p } \left( \frac { \pi _ { \theta } ( a \vert s ) } { \pi _ { \theta _ { o l d } } ( a \vert s ) } , 1 - \epsilon , 1 + \epsilon \right) \hat { A } _ { t } \right) \right] ,
+$$
+
+where $\hat { A } _ { t }$ is an estimator of the advantage function at timestep $t$ . The advantage function is calculated based on a reward function described in Sec 4.3.
+
+The $D _ { K L }$ term in (5) serves as a regularizer to keep the policy close to a learned policy prior $p _ { a }$ . This policy prior $p _ { a }$ is derived from the state predictive VAE and an inverse dynamics model. Assume the $\beta$ -VAE is $f ( s _ { t } ) = s _ { t + 1 }$ and the inverse dynamics model is $g _ { i n v } ( s _ { t } , \dot { s } _ { t + 1 } ) = a$ . To solve the case when the agents have different dynamics, we learn a state prediction network and use a learned inverse dynamics to decode the action. We define the action prior as
+
+$$
+p _ { a } ( a _ { t } | s _ { t } ) \propto \mathrm { e x p } \left( - \bigg | \Big | \frac { g _ { i n v } ( s _ { t } , f ( s _ { t } ) ) - a _ { t } } { \sigma } \Big | \Big | ^ { 2 } \right)
+$$
+
+where the RHS is a pre-defined policy prior, a Gaussian distribution centered at $g _ { i n v } { \left( s _ { t } , f ( s _ { t } ) \right) }$ . $\sigma$ controls how strong the action prior is when regularizing the policy update, which is a hyperparameter. Note that the inverse model can be further adjusted during interactions.
+
+$L ^ { C L I P }$ is computed through the advantage $\hat { A } _ { t }$ and reflects the global alignment. The policy prior is obtained from the inverse model and local $\beta$ -VAE, which makes the $D _ { K L }$ serve as a local alignment constraint. Furthermore, our method can be regard as a combination of BC and IRL because our KLdivergence based action prior encodes the BC policy and we update the policy leveraging reward.
+
+We would note that our state-alignment method augments state distribution matching by taking relationships of two consecutive states into account with robustness concern.
+
+# 4.5 PRE-TRAINING
+
+We pretrain the state predictive VAE and the inverse dynamics model, and then obtain the policy prior in (7), which is a Gaussian distribution. For pre-training, we want to initialize PPO’s Gaussian policy $\pi$ by this prior $p _ { a }$ , by minimizing the KL-divergence between them. Practically, we use direct supervision from $\hat { g _ { i n v } } ( s _ { t } , \mathbf { \hat { \boldsymbol { f } } } ( s _ { t } ) )$ and $\sigma$ in (7) to directly train both the mean and variance of the policy network, which is more efficient during the pre-training stage. During the online interaction, the update rule of PPO’s policy is by optimizing (5), and the variance will be further adjusted for all the dimensions of the action space.
+
+# 5 EXPERIMENTS
+
+We conduct two different kinds of experiments to show the superiority of our method. In Sec 5.1, we compare our method with behavior cloning (Bain & Sommut, 1999), GAIL (Ho & Ermon, 2016), and AIRL (Fu et al.) in control setting where the expert and the imitator have different dynamics model, e.g., both of them are ant robots but the imitator has shorter legs. In Sec 5.1, we further evaluate in the traditional imitation learning setting. Finally, in Sec 5.3, we conduct ablation study to show the contribution of the components.
+
+# 5.1 IMITATION LEARNING ACROSS AGENTS OF DIFFERENT ACTION DYNAMICS
+
+# 5.1.1 ACTORS OF MODIFIED PHYSICS AND GEOMETRY PROPERTIES
+
+We create environments using MuJoCo (Todorov et al., 2012) by changing some properties of experts, such as density and geometry of the body. We choose 2 environments, Ant and Swimmer, and augment them to 6 different environments: Heavy/Light/Disabled Ant/Swimmer. The Heavy/Light agents have modified density, and the disabled agents have modified head/tail/leg lengths. The demonstrations are collected from the standard Ant-v2 and Swimmer-v2. More descriptions of the environments and the demonstration collection process can be founded in the Appendix.
+
+We then evaluate our method on them.
+
+![](images/6d9f58378786fc1a4ae6f2d7092d4d32f56b716b914c0640900090fe6e7e7253.jpg)  
+Figure 3: Comparison with BC, GAIL and AIRL when dynamics are different from experts.
+
+Figure 3 demonstrates the superiority of our methods over all the baselines. Our approach is the most stable in all the 6 environments and shows the leading performance in each of them. GAIL seems to be the most sensitive to dynamics difference. AIRL, which is designed to solve imitation learning for actors of different dynamics, can perform on par with our method in two swimmerbased environments (DisabledSwimmer and HeavySwimmer) that have relatively lower dimensional action space (2D for swimmer versus 8D for ants).
+
+Interestingly, the stability and performance of vanilla behavior cloning are quite reasonable in 4 of the environments, although it failed to move about in the DisabledAnt and HeavyAnt environments. For these two tasks, the agent will reach dangerous states by cloning actions, yet our method will not approach these states by using state-based imitation. In the other four games, BC agents do not die but just move less efficiently, so they have a sub-optimal yet still reasonable score.
+
+# 5.1.2 ACTORS OF HETEROGENEOUS ACTION DYNAMICS
+
+We consider an extremely challenging setting that the imitator and demonstrator are functionally different. One typical example of expert/imitator pair in practice would be a human and a humanoid robot. We consider a much simplified version but with similar nature – a Point and an Ant in MuJoCo. In this task, even if the state space cannot be exactly matched, there are still some shared dimensions across the state space of the imitator and the actor, e.g., the location of the center of mass, and the demonstration should still teach the imitator in these dimensions.
+
+We use the same setting as many hierarchical RL papers, such as HIRO and Near-Optimal RL (Nachum et al., 2018a;b). The agent need to reach a goal position in a maze, which is represented by (x,y) coordinates. We also know that the first two dimensions of states are the position of the agent. The prior knowledge includes: (1) the goal space (or the common space that need to be matched) (2) the projection from the state space to the goal space (select the first two dimensions of the states).
+
+![](images/ccd5c1239ca9d5ea869d72b30546620697406dffe201e7855b12b04bc6d22b43.jpg)  
+Figure 4: Imitation Learning of Actors with Heterogeneous Action Dynamics.
+
+The first task is that the Ant should reach the other side of the maze from several successful demonstrations of a Point robot. As shown in Figure 4(c) and Figure 4(d), the maze structure for the ant and point mass is exactly the same.
+
+To solve this problem, we first pre-train an VAE on the demonstrations, and use this VAE to propose the next “subgoal” for the Ant. This VAE is trained on the goal space (i.e. the first two dimensions) of the Point robot’s trajectory. Then we train an inverse model for Ant, which will generate an action based on the Ant’s current state (high dimensional) and goal predicted by VAE (2 dimensional).
+
+Our performance is shown in Figure 5(c). After 1M training steps, the agent has success rate of 0.8 to reach the other side of the maze.
+
+# 5.2 ACTORS OF THE SAME DYNAMICS (STANDARD IMITATION LEARNING)
+
+We also evaluate our algorithm on 6 non-trivial control tasks in MuJoCo: Swimmer, Hopper, Walker, Ant, HalfCheetach, and Humanoid. We first collect demonstration trajectories with Soft ActorCritic, which can learn policies that achieve high scores in most of these environments2. For comparison, we evaluate our method against 3 baselines: behavior cloning, GAIL, and AIRL3. Also, to create even stronger baselines for the cumulative reward and imitator run-time sample complexity, we initialize GAIL with behavior cloning, which would obtain higher scores in Swimmer and Walker. Lastly, to evaluate how much each algorithm depends on the amount of demonstrations, we sampled demonstration trajectories of ten and fifty episodes.
+
+Table 1 depicts representative results in Hopper and HalfCheetah4. The advantage of our methods over BC should be attributed to the inherent data augmentation by VAE. On Hopper-v2, we are significantly better with 10 demos but are just on par if the demos are increased to 50. On HalfCheetah-v2, the demo cheetah runs almost perfectly ( 12294 scores); in other words, the demo provides limited instruction when the imitator is even slightly off the demo states, thus the robustness from VAE becomes critical.
+
+Table 1: Performance on Hopper-v2 and HalfCheetah-v2   
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=2>Hopper-v2</td><td rowspan=1 colspan=2>HalfCheetah-v2</td></tr><tr><td rowspan=1 colspan=1>#Demo</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>50</td><td rowspan=1 colspan=2>10                  50</td></tr><tr><td rowspan=1 colspan=1>Expert</td><td rowspan=1 colspan=2>3566± 1.24</td><td rowspan=1 colspan=2>12294.22 ± 273.59</td></tr><tr><td rowspan=1 colspan=1>BC</td><td rowspan=1 colspan=1>1318.76± 804.36</td><td rowspan=1 colspan=1>3525.87 ± 160.74</td><td rowspan=1 colspan=1>971.42 ± 249.62</td><td rowspan=1 colspan=1>4813.20± 1949.26</td></tr><tr><td rowspan=1 colspan=1>GAIL</td><td rowspan=1 colspan=1>3372.66 ± 130.75</td><td rowspan=1 colspan=1>3363.97± 262.77</td><td rowspan=1 colspan=1>474.42 ± 389.30</td><td rowspan=1 colspan=1>-175.83± 26.76</td></tr><tr><td rowspan=1 colspan=1>BC-GAIL</td><td rowspan=1 colspan=1>3132.11 ± 520.65</td><td rowspan=1 colspan=1>3130.82 ± 554.54</td><td rowspan=1 colspan=1>578.85 ± 934.34</td><td rowspan=1 colspan=1>1597.51 ± 1173.93</td></tr><tr><td rowspan=1 colspan=1>AIRL</td><td rowspan=1 colspan=1>3.07 ± 0.02</td><td rowspan=1 colspan=1>3.31 ± 0.02</td><td rowspan=1 colspan=1>-146.46± 23.57</td><td rowspan=1 colspan=1>755.46± 10.92</td></tr><tr><td rowspan=1 colspan=1>Ourinit</td><td rowspan=1 colspan=1>3412.58 ± 450.97</td><td rowspan=1 colspan=1>3601.16± 300.14</td><td rowspan=1 colspan=1>1064.44 ± 227.32</td><td rowspan=1 colspan=1>7102.29 ± 910.54</td></tr><tr><td rowspan=1 colspan=1>Our final</td><td rowspan=1 colspan=1>3539.56 ±130.36</td><td rowspan=1 colspan=1>3614.19 ± 150.74</td><td rowspan=1 colspan=1>1616.34 ±180.76</td><td rowspan=1 colspan=1>8817.32 ± 860.55</td></tr></table>
+
+# 5.3 ABLATION STUDY
+
+# 5.3.1 COEFFICIENT $\beta$ IN $\beta$ -VAE
+
+$\beta$ -VAE introduces an additional parameter to the original VAE. It controls the variance of the randomly sampled latent variable sampling, which subsequently affects the reconstruction quality and robustness. Theoretically, a smaller $\beta$ leads to better state prediction quality, with the cost of losing the deviation correction ability (Dai et al., 2018).
+
+To empirically show the role of beta and check the sensitivity of our algorithm with respect to beta, we evaluate VAE in settings of both the imitator has the same dynamics and has different dynamics. We select HalfCheetah-v2 and HeavyAnt as an example. For HalfCheetah-v2, we pretrain the inverse dynamics and VAE using given demonstrations so that the initial performance will tell the quality of the VAE’s prediction. For DisabledAnt, we pretrain the dynamics with random trials, which results in forward/inverse dynamics estimation of less accuracy. In this case, we examine both its initialized performance and final performance. The results are shown in Table 2. We find out that for $\beta$ in [0.01, 0.1], the performance is better. Specifically, when the imitator is different from the expert, a smaller $\bar { \boldsymbol \beta }$ will result in poor performance as it overfits the demonstration data.
+
+We also compare our method with an ordinary MLP trained by MSE loss. We find out that VAE outperforms MLP in all settings. Note that the MLP-based approach is very similar to the state-based behavior cloning work of (Torabi et al., 2018b).
+
+# 5.3.2 ACTION PREDICTIVE $\beta$ -VAE
+
+In Figure 1, we mentioned that a VAE to predict the next action is less favorable. To justify the claim, we compare a VAE-based BC with a vanilla BC that both predict actions, as shown in Table 3. Experiments show that VAE-BC is even outperformed by a vanilla BC, especially when $\beta$ is larger than 0.001. Compared with the last line in Table 2, we can conclude that VAE is more useful when predicting state, which consolidates that the advantage really comes from our state-based approach but not only the robustness of VAE.
+
+# 5.3.3 EFFECT OF WASSERSTEIN DISTANCE AND KL REGULARIZATION
+
+In our policy update process, we use Wasserstein distance with KL regularization to update the policy. To analyze their effects on the performance, we use HalfCheetah-v2 and Humanoid-v2 with
+
+Table 2: Analyze the role of VAE coefficient. The “None” item means replacing VAE with an ordinary network with linear layers.   
+
+<table><tr><td rowspan="2">β</td><td colspan="4">Environments</td></tr><tr><td>HalfCheetah-50</td><td>HalfCheetah-20</td><td>HeavyAnt-Initial</td><td>HeavyAnt-Final</td></tr><tr><td>0.2</td><td>2007.86</td><td>1289.21</td><td>258.91</td><td>282.13</td></tr><tr><td>0.15</td><td>2653.04</td><td>1151.93</td><td>1149.65</td><td>1502.68</td></tr><tr><td>0.1</td><td>7102.29</td><td>1797.44</td><td>1219.34</td><td>5208.45</td></tr><tr><td>0.05</td><td>5933.28</td><td>2215.71</td><td>987.72</td><td>4850.62</td></tr><tr><td>0.01</td><td>5893.17</td><td>1982.62</td><td>740.54</td><td>1921.26</td></tr><tr><td>0.005</td><td>4415.04</td><td>1369.57</td><td>320.54</td><td>399.31</td></tr><tr><td>None</td><td>4759.69</td><td>1123.79</td><td>359.15</td><td>-62.13</td></tr></table>
+
+Table 3: Compare behavior cloning to variational behavior cloning   
+
+<table><tr><td rowspan=2 colspan=1>β</td><td rowspan=1 colspan=2>Environments</td></tr><tr><td rowspan=1 colspan=1>HalfCheetah-50</td><td rowspan=1 colspan=1>Hopper-50</td></tr><tr><td rowspan=1 colspan=1>0.1</td><td rowspan=1 colspan=1>230.52±13.26</td><td rowspan=1 colspan=1>203.87 ±14.39</td></tr><tr><td rowspan=1 colspan=1>0.01</td><td rowspan=1 colspan=1>1320.04 ± 15.43</td><td rowspan=1 colspan=1>438.10± 20.43</td></tr><tr><td rowspan=1 colspan=1>0.001</td><td rowspan=1 colspan=1>3306.91 ± 12.51</td><td rowspan=1 colspan=1>3303.72±10.46</td></tr><tr><td rowspan=1 colspan=1>None</td><td rowspan=1 colspan=1>4813.20± 1949.26</td><td rowspan=1 colspan=1>3525.87 ± 6.74</td></tr></table>
+
+![](images/af5b94877281e6dbd09e56642dd12280cc3fb04531e9cd4ba0d68f4524d52fe1.jpg)  
+Figure 5: (a), (b) show the effects of Wasserstein distance and KL regularization on HalfCheetah-v2 and Humanoid-v2 given 20 demonstration trajectories. And (c) presents the result on Antmaze.
+
+20 expert trajectories. For each environment, they use the same pretrained inverse model and VAE, thus they have the same behavior after pretraining.
+
+As shown in Figure 5(a)(b), Wasserstein distance combined with KL regularization performs the best. Wasserstein objective is used in our inverse RL based mechanism that would significantly penalize the exploration when the agent deviates from the demonstration far away. However, using this objective alone lacks constraints over consecutive states, thus performing the worst. The KL objective adds constraints over consecutive states using a VAE prior; however, VAE is unable to extrapolate to states when the imitator deviates far from the demo (green line gradually fails as in Fig 5 (b)), but this is the scenario when the Wasserstein distance would not favor, thus the reward from the Wasserstein distance will push the imitator back to the demonstration states.
+
+# 6 CONCLUSION
+
+We proposed SAIL, a flexible and practical imitation learning algorithms that use state alignment from both local and global perspective. We demonstrate the superiority of our method using MuJoCo environments, especially when the action dynamics are different from the demonstrations.
+
+# REFERENCES
+
+Pieter Abbeel and Andrew $\mathrm { ~ Y ~ N ~ g ~ }$ . Apprenticeship learning via inverse reinforcement learning. In Proceedings of the twenty-first international conference on Machine learning, pp. 1. ACM, 2004.
+
+Martin Arjovsky, Soumith Chintala, and Leon Bottou. Wasserstein gan. ´ arXiv preprint arXiv:1701.07875, 2017.
+
+Yusuf Aytar, Tobias Pfaff, David Budden, Thomas Paine, Ziyu Wang, and Nando de Freitas. Playing hard exploration games by watching youtube. In Advances in Neural Information Processing Systems, pp. 2930–2941, 2018a.
+
+Yusuf Aytar, Tobias Pfaff, David Budden, Thomas Paine, Ziyu Wang, and Nando de Freitas. Playing hard exploration games by watching youtube. In Advances in Neural Information Processing Systems, pp. 2930–2941, 2018b.
+
+Michael Bain and Claude Sommut. A framework for behavioural cloning. Machine intelligence, 15 (15):103, 1999.
+
+Lionel Blonde and Alexandros Kalousis. Sample-efficient imitation learning via generative adver- ´ sarial nets. arXiv preprint arXiv:1809.02064, 2018.
+
+Tian Qi Chen, Xuechen Li, Roger B Grosse, and David K Duvenaud. Isolating sources of disentanglement in variational autoencoders. In Advances in Neural Information Processing Systems, pp. 2610–2620, 2018.
+
+Bin Dai, Yu Wang, John Aston, Gang Hua, and David Wipf. Connections with robust pca and the role of emergent sparsity in variational autoencoder models. The Journal of Machine Learning Research, 19(1):1573–1614, 2018.
+
+Ashley D Edwards, Himanshu Sahni, Yannick Schroecker, and Charles L Isbell. Imitating latent policies from observation. arXiv preprint arXiv:1805.07914, 2018.
+
+Justin Fu, Katie Luo, and Sergey Levine. Learning robust rewards with adversarial inverse reinforcement learning. ICLR 2018.
+
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in neural information processing systems, pp. 2672–2680, 2014.
+
+Ishaan Gulrajani, Faruk Ahmed, Martin Arjovsky, Vincent Dumoulin, and Aaron C Courville. Improved training of wasserstein gans. In Advances in neural information processing systems, pp. 5767–5777, 2017.
+
+Tuomas Haarnoja, Aurick Zhou, Pieter Abbeel, and Sergey Levine. Soft actor-critic: Offpolicy maximum entropy deep reinforcement learning with a stochastic actor. arXiv preprint arXiv:1801.01290, 2018.
+
+Todd Hester, Matej Vecerik, Olivier Pietquin, Marc Lanctot, Tom Schaul, Bilal Piot, Dan Horgan, John Quan, Andrew Sendonaris, Ian Osband, et al. Deep q-learning from demonstrations. In Thirty-Second AAAI Conference on Artificial Intelligence, 2018.
+
+Irina Higgins, Loic Matthey, Arka Pal, Christopher Burgess, Xavier Glorot, Matthew Botvinick, Shakir Mohamed, and Alexander Lerchner. beta-vae: Learning basic visual concepts with a constrained variational framework. ICLR, 2(5):6, 2017.
+
+Jonathan Ho and Stefano Ermon. Generative adversarial imitation learning. In Advances in neural information processing systems, pp. 4565–4573, 2016.
+
+Liyiming Ke, Matt Barnes, Wen Sun, Gilwoo Lee, Sanjiban Choudhury, and Siddhartha Srinivasa. Imitation learning as $f$ -divergence minimization. arXiv preprint arXiv:1905.12888, 2019.
+
+Diederik $\mathrm { \bf P }$ Kingma and Max Welling. Auto-encoding variational bayes. arXiv preprint arXiv:1312.6114, 2013.
+
+Hoang M Le, Yisong Yue, Peter Carr, and Patrick Lucey. Coordinated multi-agent imitation learning. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 1995– 2003. JMLR. org, 2017.
+
+Lisa Lee, Benjamin Eysenbach, Emilio Parisotto, Ruslan Salakhutdinov, and Sergey Levine. State marginal matching with mixtures of policies.
+
+Lisa Lee, Benjamin Eysenbach, Emilio Parisotto, Eric Xing, Sergey Levine, and Ruslan Salakhutdinov. Efficient exploration via state marginal matching. arXiv preprint arXiv:1906.05274, 2019.
+
+YuXuan Liu, Abhishek Gupta, Pieter Abbeel, and Sergey Levine. Imitation from observation: Learning to imitate behaviors from raw video via context translation. In 2018 IEEE International Conference on Robotics and Automation (ICRA), pp. 1118–1125. IEEE, 2018.
+
+Ofir Nachum, Shixiang Gu, Honglak Lee, and Sergey Levine. Near-optimal representation learning for hierarchical reinforcement learning. arXiv preprint arXiv:1810.01257, 2018a.
+
+Ofir Nachum, Shixiang Shane Gu, Honglak Lee, and Sergey Levine. Data-efficient hierarchical reinforcement learning. In Advances in Neural Information Processing Systems, pp. 3303–3313, 2018b.
+
+Andrew Y Ng, Stuart J Russell, et al. Algorithms for inverse reinforcement learning. In Icml, volume 1, pp. 2, 2000.
+
+Sebastian Nowozin, Botond Cseke, and Ryota Tomioka. f-gan: Training generative neural samplers using variational divergence minimization. In Advances in neural information processing systems, pp. 271–279, 2016.
+
+Deepak Pathak, Parsa Mahmoudieh, Michael Luo, Pulkit Agrawal, Dian Chen, Fred Shentu, Evan Shelhamer, Jitendra Malik, Alexei A Efros, and Trevor Darrell. Zero-shot visual imitation. international conference on learning representations, 2018.
+
+Xue Bin Peng, Angjoo Kanazawa, Jitendra Malik, Pieter Abbeel, and Sergey Levine. Sfv: Reinforcement learning of physical skills from videos. ACM Trans. Graph., 37(6), November 2018.
+
+Tobias Pohlen, Bilal Piot, Todd Hester, Mohammad Gheshlaghi Azar, Dan Horgan, David Budden, Gabriel Barth-Maron, Hado van Hasselt, John Quan, Mel Vecer ˇ ´ık, et al. Observe and look further: Achieving consistent performance on atari. arXiv preprint arXiv:1805.11593, 2018.
+
+Dean A Pomerleau. Alvinn: An autonomous land vehicle in a neural network. In Advances in neural information processing systems, pp. 305–313, 1989.
+
+Ahmed H Qureshi, Byron Boots, and Michael C Yip. Adversarial imitation via variational inverse reinforcement learning. arXiv preprint arXiv:1809.06404, 2018.
+
+Danilo Jimenez Rezende, Shakir Mohamed, and Daan Wierstra. Stochastic backpropagation and approximate inference in deep generative models. arXiv preprint arXiv:1401.4082, 2014.
+
+Stephane Ross and Drew Bagnell. Efficient reductions for imitation learning. In ´ Proceedings of the thirteenth international conference on artificial intelligence and statistics, pp. 661–668, 2010.
+
+Stephane Ross, Geoffrey Gordon, and Drew Bagnell. A reduction of imitation learning and struc- ´ tured prediction to no-regret online learning. In Proceedings of the fourteenth international conference on artificial intelligence and statistics, pp. 627–635, 2011a.
+
+Stephane Ross, Geoffrey Gordon, and Drew Bagnell. A reduction of imitation learning and struc- ´ tured prediction to no-regret online learning. In Proceedings of the fourteenth international conference on artificial intelligence and statistics, pp. 627–635, 2011b.
+
+Stuart J Russell. Learning agents for uncertain environments. In COLT, volume 98, pp. 101–103, 1998.
+
+Yannick Schroecker and Charles L Isbell. State aware imitation learning. In Advances in Neural Information Processing Systems, pp. 2911–2920, 2017.
+
+John Schulman, Sergey Levine, Pieter Abbeel, Michael Jordan, and Philipp Moritz. Trust region policy optimization. In International Conference on Machine Learning, pp. 1889–1897, 2015.
+
+John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347, 2017.
+
+Justin Solomon. Optimal transport on discrete domains. AMS Short Course on Discrete Differential Geometry, 2018.
+
+Wen Sun, Anirudh Vemula, Byron Boots, and J Andrew Bagnell. Provably efficient imitation learning from observation alone. arXiv preprint arXiv:1905.10948, 2019.
+
+Emanuel Todorov, Tom Erez, and Yuval Tassa. Mujoco: A physics engine for model-based control. In 2012 IEEE/RSJ International Conference on Intelligent Robots and Systems, pp. 5026–5033. IEEE, 2012.
+
+Faraz Torabi, Garrett Warnell, and Peter Stone. Generative adversarial imitation from observation. arXiv preprint arXiv:1807.06158, 2018a.
+
+Faraz Torabi, Garrett Warnell, and Peter Stone. Behavioral cloning from observation. arXiv preprint arXiv:1805.01954, 2018b.
+
+Cedric Villani. ´ Optimal transport: old and new, volume 338. Springer Science & Business Media, 2008.
+
+Huang Xiao, Michael Herman, Joerg Wagner, Sebastian Ziesche, Jalal Etesami, and Thai Hong Linh. Wasserstein adversarial imitation learning. arXiv preprint arXiv:1906.08113, 2019.
+
+Gu Ye and Ron Alterovitz. Guided motion planning. In Robotics research, pp. 291–307. Springer, 2017.
+
+Brian D Ziebart, Andrew Maas, J Andrew Bagnell, and Anind K Dey. Maximum entropy inverse reinforcement learning. 2008.
+
+# A LEARNING ACROSS DIFFERENT ENVIRONMENTS
+
+PointMaze & AntMaze As shown in Figure 4, a point mass or an ant is put in a $2 4 \times 2 4$ U-maze. The task is to make the agent reach the other side of U-maze with the demonstration from the point mass. The ant is trained to reach a random goal in the maze from a random location, and should reach the other side of the maze. The state space of ant is 30-dim, which contains the positions and velocities.
+
+HeavyAnt Two times of original Ant’s density. Two times of original gear of the armature.
+
+LightAnt One tenth of original Ant’s density.
+
+DisabledAnt Two front legs are 3 quarters of original Ant’s legs.
+
+HeavySwimmer 2.5 times of original Swimmer’s density.
+
+LightSwimmer One twentieth of original Swimmer’s density.
+
+DisabledSwimmer Make the last joint 1.2 times longer and the first joint 0.7 times of the original length
+
+The exact results of these environments are listed in Table 4, 5. All the statistics are calculated from 20 trails.
+
+Table 4: Performance on modifeid Swimmer   
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>DisabledSwimmer</td><td rowspan=1 colspan=1>LightSwimmer</td><td rowspan=1 colspan=1>HeavySwimmer</td></tr><tr><td rowspan=1 colspan=1>BC</td><td rowspan=1 colspan=1>249.09±1.53</td><td rowspan=1 colspan=1>277.99± 3.41</td><td rowspan=1 colspan=1>255.95± 2.5</td></tr><tr><td rowspan=1 colspan=1>GAIL</td><td rowspan=1 colspan=1>228.46±2.02</td><td rowspan=1 colspan=1>-4.11 ± 0.51</td><td rowspan=1 colspan=1>254.91 ± 1.35</td></tr><tr><td rowspan=1 colspan=1>AIRL</td><td rowspan=1 colspan=1>283.42 ± 3.69</td><td rowspan=1 colspan=1>67.58 ± 25.09</td><td rowspan=1 colspan=1>301.27 ± 5.21</td></tr><tr><td rowspan=1 colspan=1>SAIL(Ours)</td><td rowspan=1 colspan=1>287.71 ± 2.31</td><td rowspan=1 colspan=1>342.61 ± 6.14</td><td rowspan=1 colspan=1>286.4 ± 3.2</td></tr></table>
+
+Table 5: Performance on modified Ant   
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>DisabledAnt</td><td rowspan=1 colspan=1>HeavyAnt</td><td rowspan=1 colspan=1>LightAnt</td></tr><tr><td rowspan=1 colspan=1>BC</td><td rowspan=1 colspan=1>1042.45± 75.13</td><td rowspan=1 colspan=1>550.6± 77.62</td><td rowspan=1 colspan=1>4936.59± 53.42</td></tr><tr><td rowspan=1 colspan=1>GAIL</td><td rowspan=1 colspan=1>-1033.54± 254.36</td><td rowspan=1 colspan=1>-1089.34± 174.13</td><td rowspan=1 colspan=1>-971.74 ± 123.14</td></tr><tr><td rowspan=1 colspan=1>AIRL</td><td rowspan=1 colspan=1>-3252.69± 153.47</td><td rowspan=1 colspan=1>-62.02± 5.33</td><td rowspan=1 colspan=1>-626.44 ± 104.31</td></tr><tr><td rowspan=1 colspan=1>SAIL(Ours)</td><td rowspan=1 colspan=1>3305.71 ± 67.21</td><td rowspan=1 colspan=1>5608.47 ± 57.67</td><td rowspan=1 colspan=1>4335.46± 82.34</td></tr></table>
+
+# B IMITATION BENCHMARK EXPERIMENTS SETTINGS AND RESULTS
+
+We use six MuJoCo (Todorov et al., 2012) control tasks. The name and version of the environments are listed in Table 6, which also list the state and action dimension of the tasks with expert performance and reward threshold to indicate the minimum score to solve the task. All the experts are trained by using SAC (Haarnoja et al., 2018) except Swimmer-v2 where TRPO (Schulman et al., 2015) get higher performance.
+
+Table 6: Performance on benchmark control tasks   
+
+<table><tr><td rowspan=1 colspan=1>Environment</td><td rowspan=1 colspan=1>State Dim</td><td rowspan=1 colspan=1>Action Dim</td><td rowspan=1 colspan=1>Reward threshold</td><td rowspan=1 colspan=1>Expert Performance</td></tr><tr><td rowspan=1 colspan=1>Swimmer-v2</td><td rowspan=1 colspan=1>8</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>360</td><td rowspan=1 colspan=1>332</td></tr><tr><td rowspan=1 colspan=1>Hopper-v2</td><td rowspan=1 colspan=1>11</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>3800</td><td rowspan=1 colspan=1>3566</td></tr><tr><td rowspan=1 colspan=1>Walker2d-v2</td><td rowspan=1 colspan=1>17</td><td rowspan=1 colspan=1>6</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>4924</td></tr><tr><td rowspan=1 colspan=1>Ant-v2</td><td rowspan=1 colspan=1>111</td><td rowspan=1 colspan=1>8</td><td rowspan=1 colspan=1>6000</td><td rowspan=1 colspan=1>6157</td></tr><tr><td rowspan=1 colspan=1>HalfCheetah-v2</td><td rowspan=1 colspan=1>17</td><td rowspan=1 colspan=1>6</td><td rowspan=1 colspan=1>4800</td><td rowspan=1 colspan=1>12294</td></tr><tr><td rowspan=1 colspan=1>Humanoid-v2</td><td rowspan=1 colspan=1>376</td><td rowspan=1 colspan=1>17</td><td rowspan=1 colspan=1>1000</td><td rowspan=1 colspan=1>5187</td></tr></table>
+
+The exact performance of all methods are list in Table 7, 8, 9, 10, 11, 12. We compare GAIL(Ho & Ermon, 2016), behavior cloning, GAIL with behavior cloning initilization and AIRL to our method containing. Means and standard deviations are calculated from 20 trajectories after the agents converge and the number total interactions with environments is less than one million environment steps.
+
+Table 7: Performance on Swimmer-v2 with different trajectories   
+
+<table><tr><td rowspan=1 colspan=5>Swimmer-v2</td></tr><tr><td rowspan=1 colspan=1>#Demo</td><td rowspan=1 colspan=4>5               10               20              50</td></tr><tr><td rowspan=1 colspan=1>Expert</td><td rowspan=1 colspan=4>332.88 ± 1.24</td></tr><tr><td rowspan=1 colspan=1>BC</td><td rowspan=1 colspan=1>328.85 ± 2.26</td><td rowspan=1 colspan=1>331.17 ± 2.4</td><td rowspan=1 colspan=1>332.17 ± 2.4</td><td rowspan=1 colspan=1>330.65± 2.42</td></tr><tr><td rowspan=1 colspan=1>GAIL</td><td rowspan=1 colspan=1>304.64 ± 3.16</td><td rowspan=1 colspan=1>271.59 ± 11.77</td><td rowspan=1 colspan=1>56.16 ± 5.99</td><td rowspan=1 colspan=1>246.73 ± 5.76</td></tr><tr><td rowspan=1 colspan=1>BC-GAIL</td><td rowspan=1 colspan=1>313.80± 3.42</td><td rowspan=1 colspan=1>326.58 ± 7.87</td><td rowspan=1 colspan=1>294.93±12.21</td><td rowspan=1 colspan=1>315.68 ± 9.99</td></tr><tr><td rowspan=1 colspan=1>AIRL</td><td rowspan=1 colspan=1>332.11 ± 2.57</td><td rowspan=1 colspan=1>338.43±3.65</td><td rowspan=1 colspan=1>335.67 ± 2.72</td><td rowspan=1 colspan=1>340.08 ± 2.70</td></tr><tr><td rowspan=1 colspan=1>Our init</td><td rowspan=1 colspan=1>332.36± 3.62</td><td rowspan=1 colspan=1>335.78± 0.34</td><td rowspan=1 colspan=1>336.23± 2.53</td><td rowspan=1 colspan=1>334.03 ± 2.11</td></tr><tr><td rowspan=1 colspan=1>Our final</td><td rowspan=1 colspan=1>332.22 ± 3.23</td><td rowspan=1 colspan=1>339.67 ± 3.21</td><td rowspan=1 colspan=1>336.18 ± 1.87</td><td rowspan=1 colspan=1>336.31± 3.20</td></tr></table>
+
+Table 8: Performance on Hopper-v2 with different trajectories   
+
+<table><tr><td rowspan=1 colspan=5>Hopper-v2</td></tr><tr><td rowspan=1 colspan=1>#Demo</td><td rowspan=1 colspan=4>5                  10                 20                 50</td></tr><tr><td rowspan=1 colspan=1>Expert</td><td rowspan=1 colspan=4>3566±1.24</td></tr><tr><td rowspan=1 colspan=1>BC</td><td rowspan=1 colspan=1>1471.40 ± 637.25</td><td rowspan=1 colspan=1>1318.76± 804.36</td><td rowspan=1 colspan=1>1282.46± 772.24</td><td rowspan=1 colspan=1>3525.87 ± 160.74</td></tr><tr><td rowspan=1 colspan=1>GAIL</td><td rowspan=1 colspan=1>3300.32 ± 331.61</td><td rowspan=1 colspan=1>3372.66 ± 130.75</td><td rowspan=1 colspan=1>3201.97 ± 295.27</td><td rowspan=1 colspan=1>3363.97± 262.77</td></tr><tr><td rowspan=1 colspan=1>BC-GAIL</td><td rowspan=1 colspan=1>3122.23± 358.65</td><td rowspan=1 colspan=1>3132.11 ± 520.65</td><td rowspan=1 colspan=1>3111.42 ± 414.28</td><td rowspan=1 colspan=1>3130.82± 554.54</td></tr><tr><td rowspan=1 colspan=1>AIRL</td><td rowspan=1 colspan=1>4.12 ± 0.01</td><td rowspan=1 colspan=1>3.07 ± 0.02</td><td rowspan=1 colspan=1>4.11 ± 0.01</td><td rowspan=1 colspan=1>3.31 ± 0.02</td></tr><tr><td rowspan=1 colspan=1>Our init</td><td rowspan=1 colspan=1>2322.49 ± 300.93</td><td rowspan=1 colspan=1>3412.58 ± 450.97</td><td rowspan=1 colspan=1>3314.03± 310.32</td><td rowspan=1 colspan=1>3601.16± 300.14</td></tr><tr><td rowspan=1 colspan=1>Our final</td><td rowspan=1 colspan=1>3092.26± 670.72</td><td rowspan=1 colspan=1>3539.56±130.36</td><td rowspan=1 colspan=1>3516.81± 280.98</td><td rowspan=1 colspan=1>3610.19± 150.74</td></tr></table>
+
+Table 9: Performance on Walker2d-v2 with different trajectories   
+
+<table><tr><td rowspan=1 colspan=5>Walker2d-v2</td></tr><tr><td rowspan=1 colspan=1>#Demo</td><td rowspan=1 colspan=4>5                   10                   20                  50</td></tr><tr><td rowspan=1 colspan=1>Expert</td><td rowspan=1 colspan=4>5070.97士209.19</td></tr><tr><td rowspan=1 colspan=1>BC</td><td rowspan=1 colspan=1>1617.34 ± 693.63</td><td rowspan=1 colspan=1>4425.50± 930.62</td><td rowspan=1 colspan=1>4689.30± 372.33</td><td rowspan=1 colspan=1>4796.24 ± 490.05</td></tr><tr><td rowspan=1 colspan=1>GAIL</td><td rowspan=1 colspan=1>1307.21 ± 388.55</td><td rowspan=1 colspan=1>692.16±145.34</td><td rowspan=1 colspan=1>1991.58 ± 446.66</td><td rowspan=1 colspan=1>751.21 ± 150.18</td></tr><tr><td rowspan=1 colspan=1>BC-GAIL</td><td rowspan=1 colspan=1>3454.91 ± 792.40</td><td rowspan=1 colspan=1>2094.68 ±1425.05</td><td rowspan=1 colspan=1>3482.31 ± 828.21</td><td rowspan=1 colspan=1>2896.50± 828.18</td></tr><tr><td rowspan=1 colspan=1>AIRL</td><td rowspan=1 colspan=1>-7.13 ± 0.11</td><td rowspan=1 colspan=1>-7.39 ±0.09</td><td rowspan=1 colspan=1>-3.74 ± 0.13</td><td rowspan=1 colspan=1>-4.64 ± 0.09</td></tr><tr><td rowspan=1 colspan=1>Our init</td><td rowspan=1 colspan=1>1859.10± 720.44</td><td rowspan=1 colspan=1>2038.90±260.78</td><td rowspan=1 colspan=1>4509.82 ± 1470.65</td><td rowspan=1 colspan=1>4757.58 ± 880.45</td></tr><tr><td rowspan=1 colspan=1>Our final</td><td rowspan=1 colspan=1>2681.20± 530.67</td><td rowspan=1 colspan=1>3764.14 ± 470.01</td><td rowspan=1 colspan=1>4778.82 ± 760.34</td><td rowspan=1 colspan=1>4780.73± 360.66</td></tr></table>
+
+Table 10: Performance on Ant-v2 with different trajectories   
+
+<table><tr><td rowspan=1 colspan=5>Ant-v2</td></tr><tr><td rowspan=1 colspan=1>#Demo</td><td rowspan=1 colspan=4>5                   10                   20                    50</td></tr><tr><td rowspan=1 colspan=1>Expert</td><td rowspan=1 colspan=4>6190.90 ± 254.18</td></tr><tr><td rowspan=1 colspan=1>BC</td><td rowspan=1 colspan=1>3958.20 ± 661.28</td><td rowspan=1 colspan=1>3948.88± 753.41</td><td rowspan=1 colspan=1>5424.01 ± 473.05</td><td rowspan=1 colspan=1>5852.79± 572.97</td></tr><tr><td rowspan=1 colspan=1>GAIL</td><td rowspan=1 colspan=1>340.02 ± 59.02</td><td rowspan=1 colspan=1>335.25 ± 89.19</td><td rowspan=1 colspan=1>314.35 ± 52.13</td><td rowspan=1 colspan=1>284.18 ± 32.40</td></tr><tr><td rowspan=1 colspan=1>BC-GAIL</td><td rowspan=1 colspan=1>-1081.30± 673.65</td><td rowspan=1 colspan=1>-1177.27 ± 618.67</td><td rowspan=1 colspan=1>-13618.45 ± 4237.79</td><td rowspan=1 colspan=1>-1166.16±1246.79</td></tr><tr><td rowspan=1 colspan=1>AIRL</td><td rowspan=1 colspan=1>-839.32 ± -301.54</td><td rowspan=1 colspan=1>-386.43±156.98</td><td rowspan=1 colspan=1>-586.07 ± 145.43</td><td rowspan=1 colspan=1>-393.90± 145.13</td></tr><tr><td rowspan=1 colspan=1>Our init</td><td rowspan=1 colspan=1>1150.82 ± 200.87</td><td rowspan=1 colspan=1>3015.43± 300.70</td><td rowspan=1 colspan=1>5200.58± 870.74</td><td rowspan=1 colspan=1>5849.88 ± 890.56</td></tr><tr><td rowspan=1 colspan=1>Our final</td><td rowspan=1 colspan=1>1693.59± 350.74</td><td rowspan=1 colspan=1>3983.34± 250.99</td><td rowspan=1 colspan=1>5980.37± 420.16</td><td rowspan=1 colspan=1>5988.65± 470.03</td></tr></table>
+
+Table 11: Performance on HalfCheetah-v2 with different trajectories   
+
+<table><tr><td rowspan=1 colspan=5>HalfCheetah-v2</td></tr><tr><td rowspan=1 colspan=1>#Demo</td><td rowspan=1 colspan=4>5                   10                  20                   50</td></tr><tr><td rowspan=1 colspan=1>Expert</td><td rowspan=1 colspan=4>12294.22 ± 208.41</td></tr><tr><td rowspan=1 colspan=1>BC</td><td rowspan=1 colspan=1>225.42 ± 147.16</td><td rowspan=1 colspan=1>971.42 ± 249.62</td><td rowspan=1 colspan=1>2782.76± 959.67</td><td rowspan=1 colspan=1>4813.20 ±1949.26</td></tr><tr><td rowspan=1 colspan=1>GAIL</td><td rowspan=1 colspan=1>-84.92 ± 43.29</td><td rowspan=1 colspan=1>474.42 ± 389.30</td><td rowspan=1 colspan=1>-116.70± 34.14</td><td rowspan=1 colspan=1>-175.83 ± 26.76</td></tr><tr><td rowspan=1 colspan=1>BC-GAIL</td><td rowspan=1 colspan=1>1362.59 ± 1255.57</td><td rowspan=1 colspan=1>578.85 ± 934.34</td><td rowspan=1 colspan=1>3744.32 ± 1471.90</td><td rowspan=1 colspan=1>1597.51 ± 1173.93</td></tr><tr><td rowspan=1 colspan=1>AIRL</td><td rowspan=1 colspan=1>782.36± 48.98</td><td rowspan=1 colspan=1>-146.46± 23.57</td><td rowspan=1 colspan=1>1437.25 ± 25.45</td><td rowspan=1 colspan=1>755.46 ±10.92</td></tr><tr><td rowspan=1 colspan=1>Our init</td><td rowspan=1 colspan=1>267.71± 90.38</td><td rowspan=1 colspan=1>1064.44± 227.32</td><td rowspan=1 colspan=1>3200.80± 520.04</td><td rowspan=1 colspan=1>7102.74 ± 910.54</td></tr><tr><td rowspan=1 colspan=1>Our final</td><td rowspan=1 colspan=1>513.66 ± 15.31</td><td rowspan=1 colspan=1>1616.34 ± 180.76</td><td rowspan=1 colspan=1>6059.27 ± 344.41</td><td rowspan=1 colspan=1>8817.32 ± 860.55</td></tr></table>
+
+Table 12: Performance on Humanoid-v2 with different trajectories   
+
+<table><tr><td rowspan=1 colspan=5>Humanoid-v2</td></tr><tr><td rowspan=1 colspan=1>#Demo</td><td rowspan=1 colspan=2>5                  10</td><td rowspan=1 colspan=2>20                   50</td></tr><tr><td rowspan=1 colspan=1>Expert</td><td rowspan=1 colspan=2>5286.21</td><td rowspan=1 colspan=2>± 145.98</td></tr><tr><td rowspan=1 colspan=1>BC</td><td rowspan=1 colspan=1>1521.55± 272.14</td><td rowspan=1 colspan=1>3491.07± 518.64</td><td rowspan=1 colspan=1>4686.05 ±355.74</td><td rowspan=1 colspan=1>4746.88 ±605.61</td></tr><tr><td rowspan=1 colspan=1>GAIL</td><td rowspan=1 colspan=1>485.92± 27.59</td><td rowspan=1 colspan=1>486.44 ±27.18</td><td rowspan=1 colspan=1>477.15± 22.07</td><td rowspan=1 colspan=1>481.14± 24.37</td></tr><tr><td rowspan=1 colspan=1>BC-GAIL</td><td rowspan=1 colspan=1>363.68 ±44.44</td><td rowspan=1 colspan=1>410.03±33.07</td><td rowspan=1 colspan=1>487.99± 30.77</td><td rowspan=1 colspan=1>464.91±33.21</td></tr><tr><td rowspan=1 colspan=1>AIRL</td><td rowspan=1 colspan=1>79.72± 4.27</td><td rowspan=1 colspan=1>87.15 ± 5.01</td><td rowspan=1 colspan=1>-1293.86±10.70</td><td rowspan=1 colspan=1>84.84±6.46</td></tr><tr><td rowspan=1 colspan=1>Ourinit</td><td rowspan=1 colspan=1>452.31± 190.12</td><td rowspan=1 colspan=1>1517.63 ± 110.45</td><td rowspan=1 colspan=1>4610.25± 2750.86</td><td rowspan=1 colspan=1>4776.83 ± 1320.46</td></tr><tr><td rowspan=1 colspan=1>Our final</td><td rowspan=1 colspan=1>1225.58± 210.88</td><td rowspan=1 colspan=1>2190.43± 280.18</td><td rowspan=1 colspan=1>4716.91 ±680.29</td><td rowspan=1 colspan=1>4780.07± 700.01</td></tr></table>
+
+# C HYPER-PARAMETER AND NETWORK ARCHITECTURE
+
+When we pretrain the policy network with our methods, we choose $\beta = 0 . 0 5$ in $\beta$ -VAE. We use Adam with learning rate 3e-4 as the basic optimization algorithms for all the experiments. The policy network and value network used in the algorithms all use a three-layer relu network with hidden size 256. We choose $\sigma = 0 . 1$ in the policy prior for all the environments.
+
+# D COMPARISON WITH AIRL (FU ET AL.) FROM A THEORETICAL PERSPECTIVE
+
+Here we illustrate the theoretical advantage of our SAIL algorithm over AIRL in certain scenarios by an example.
+
+The theory of AIRL shows that it is able to recover the groundtruth reward of an MDP up to a constant if the reward of this MDP is define on states only, when the adversarial learning reaches the equilibrium. Next we show a basic case that violates the theoretical assumption of AIRL but can be solved by our algorithm.
+
+![](images/a74acd57a2c3bfb96d00ac866d6a1eafca4ca45eddae85b2b42d48ec161493ea.jpg)  
+Figure 6: Two-ring MDP with deterministic transition
+
+Figure 6 shows the states and transition of an MDP. The demonstration policy jumps back and forth between $s _ { 1 }$ and $s _ { 2 }$ periodically. Because our algorithm has the action prior (local alignment), it is clear that we can solve this problem. The dynamics of many periodic games, such as Walker and HalfCheetah in MuJoco, are extension of this two-ring graph.
+
+It is easy to show that it is impossible for the adversarial game in AIRL to solve this problem at equilibrium. According to Sec 6 of Fu et al., the reward family of AIRL is parameterized as
+
+$$
+f _ { \theta } ( s , s ^ { \prime } ) = g ( s ) + \gamma h ( s ^ { \prime } ) - h ( s )
+$$
+
+For simplicity of notation, let $\phi ( s ) = g ( s ) - h ( s )$ and $\psi ( s ) = \gamma h ( s )$ , then
+
+$$
+f _ { \theta } ( s , s ^ { \prime } ) = \phi ( s ) + \psi ( s ^ { \prime } )
+$$
+
+In other words, the reward of AIRL is decomposible to the sum of two functions defined on states only.
+
+Again, for simplicity, we omit the arguments of functions but use subscripts to represent states. For example, $f _ { 1 2 } \stackrel { - } { = } f ( \stackrel { - } { s _ { 1 } } , s _ { 2 } )$ and $\phi _ { 1 } = { \bar { \phi } } ( s _ { 1 } )$ . Then,
+
+$$
+\begin{array} { r } { f _ { 1 2 } = \phi _ { 1 } + \psi _ { 2 } , f _ { 1 1 } = \phi _ { 1 } + \psi _ { 1 } } \\ { f _ { 2 1 } = \phi _ { 2 } + \psi _ { 1 } , f _ { 2 2 } = \phi _ { 2 } + \psi _ { 2 } } \end{array}
+$$
+
+Assume that AIRL has reached the equilibrium and learned the optimal policy, then it must be true that $f _ { 1 2 } > f _ { 1 1 }$ and $f _ { 2 1 } > f _ { 2 2 }$ (otherwise, there exists other optimal policies). But $f _ { 1 2 } > f _ { 1 1 }$ implies that $\psi _ { 2 } > \psi _ { 1 }$ , while $f _ { 2 1 } > f _ { 2 2 }$ implies that $\psi _ { 1 } > \psi _ { 2 }$ , which is a contradiction.