Add files using upload-large-folder tool

parse/train/HkenPn4KPH/HkenPn4KPH.md

@@ -0,0 +1,322 @@
+# WHEN DOES SELF-SUPERVISION IMPROVE FEW-SHOT LEARNING?
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+We present a technique to improve the generalization of deep representations learned on small labeled datasets by introducing self-supervised tasks as auxiliary loss functions. Although recent research has shown benefits of self-supervised learning (SSL) on large unlabeled datasets, its utility on small datasets is unknown. We find that SSL reduces the relative error rate of few-shot meta-learners by $4 \% - 2 7 \%$ , even when the datasets are small and only utilizing images within the datasets. The improvements are greater when the training set is smaller or the task is more challenging. Though the benefits of SSL may increase with larger training sets, we observe that SSL can have a negative impact on performance when there is a domain shift between distribution of images used for meta-learning and SSL. Based on this analysis we present a technique that automatically select images for SSL from a large, generic pool of unlabeled images for a given dataset using a domain classifier that provides further improvements. We present results using several meta-learners and self-supervised tasks across datasets with varying degrees of domain shifts and label sizes to characterize the effectiveness of SSL for few-shot learning.
+
+# 1 INTRODUCTION
+
+Current machine learning algorithms require enormous amounts of training data to learn new tasks. This is a problem for many practical problems across domains such as biology and medicine where labeled data is hard to come by. In contrast, we humans can quickly learn new concepts from limited training data. We are able to do this by relying on our past “visual experience”. Recent work attempts to emulate this by training a feature representation to classify a training dataset of “base” classes with the hope that the resulting representation generalizes not just to unseen examples of the same classes but also to novel classes, which may have very few training examples (called fewshot learning). However, training for base class classification can force the network to only encode features that are useful for distinguishing between base classes. In the process, it might discard semantic information that is irrelevant for base classes but critical for novel classes. This might be especially true when the base dataset is small or when the class distinctions are challenging.
+
+One way to recover this useful semantic information is to leverage representation learning techniques that do not use class labels, namely, unsupervised or self-supervised learning. The key idea is to learn about statistical regularities (e.g., spatial relationship between patches, orientation of an images) that might be a cue to semantics. Despite recent advances, these techniques have only been applied to a few domains (e.g., entry-level classes on internet imagery), and under the assumption that large amounts of unlabeled images are available. Their applicability to the general few-shot scenario described above is unclear. In particular, can these techniques help prevent overfitting to base classes and improve performance on novel classes in the few-shot setting? If so, does the benefit generalize across domains and to more challenging tasks? Moreover, can we use self-supervised training to boost performance in domains where even unlabeled images are hard to get?
+
+This paper seeks to answer these questions. We show that with no additional training data, adding a self-supervised task as an auxiliary task (Figure 1) improves the performance of existing few-shot techniques on benchmarks across a multitude of domains (Figure 2). Intriguingly, we find that the benefits of self-supervision increase with the difficulty of the task, for example when training from a smaller base dataset, or with degraded inputs such as low resolution or greyscale images (Figure 3).
+
+One might surmise that as with traditional SSL, additional unlabeled images might improve performance further. But what unlabeled images should we use for novel problem domains where unlabeled data is not freely available? To answer this, we conduct a series of experiments with additional unlabeled data from different domains. We find that adding more unlabeled images improves performance only when the images used for self-supervision are within the same domain as the base classes (Figure 4a); otherwise they can even negatively impact the performance of the few-shot learner (Figure 4b, 4c, 4d). Based on this analysis we present a simple approach that uses a domain classifier to pick similar-domain unlabeled images for self-supervision from a large, generic pool of images. The resulting method improves over the performance of a model trained with self-supervised learning from images within the domain (Figure 4c). Taken together, this results in a powerful, general and practical approach for improving few-shot learning from small datasets in novel domains. Finally, these benefits are also observed on standard classification tasks (Appendix A.3).
+
+# 2 RELATED WORK
+
+Few-shot learning Few-shot learning aims to learn representations that generalize well to the novel classes where only few images are available. To this end several meta-learning approaches have been proposed that evaluate representations by sampling many few-shot tasks within the domain of a base dataset. These include optimization-based meta-learners, such as model-agnostic meta-learner (MAML) (Finn et al., 2017), gradient unrolling (Ravi & Larochelle, 2017), closed form solvers (Bertinetto et al., 2019), convex learners (Lee et al., 2019), etc. Others such as matching networks (Vinyals et al., 2016) and prototypical networks (Snell et al., 2017) rely on distance based classifiers, while Garcia & Bruna (2018) models higher-order relationships in data using a graph network. Another class of methods (Gidaris & Komodakis, 2018; Qi et al., 2018; Qiao et al., 2018) model the mapping between training data and classifier weights using a feed-forward network.
+
+While the literature is rapidly growing, a recent study by Chen et al. (2019) has shown that the differences between meta-learners are diminished when deeper network architectures are used and they develop a strong baseline for few-shot learning based on ResNet18 architecture and prototypical networks Snell et al. (2017). We build our experiments on top of this work and show that auxiliary self-supervised tasks provide additional benefits with state-of-the-art deep networks across several few-shot benchmarks. We also find that prototypical networks are often the best performing, though the benefits of SSL generalize across meta-learners such as MAML.
+
+Self-supervised learning Human labels are expensive to collect and hard to scale up. To this end, there has been increasing research interest to investigate learning representations from unlabeled data. In particular, the image itself already contains structural information which can be utilized. Self-supervised learning approaches attempt to capture this.
+
+There is a rich line of work on self-supervised learning. One class of methods removes part of the visual data, and tasks the network with predicting what has been removed from the rest in a discriminative manner (Larsson et al., 2016; Zhang et al., 2016; 2017). Doersch et al. (2015) proposed to predict the relative position of patches cropped from images. Wang & Gupta (2015) used the similarity of patches obtained from tracking as a self-supervised task and combined position and similarity predictions of patches (Wang et al., 2017). Other tasks include predicting rotation (Gidaris et al., 2018), noise (Bojanowski & Joulin, 2017), clusters (Caron et al., 2018; 2019; Wu et al., 2018), number of objects (Noroozi et al., 2017), missing patches (Pathak et al., 2016; Trinh et al., 2019), motion segmentation labels (Pathak et al., 2017), artifacts (Jenni & Favaro, 2018), next patch feature (Oord et al., 2018; Henaff et al. ´ , 2019), or by maximizing mutual information (Hjelm et al., 2019; Bachman et al., 2019), and training an adversarial generative model (Donahue & Simonyan, 2019). Doersch & Zisserman (2017) jointly trained four self-supervised tasks and found it to be beneficial. Recently, Goyal et al. (2019) and Kolesnikov et al. (2019) compared various self-supervised learning tasks at scale and concluded that solving jigsaw puzzles and predicting image rotations are among the most effective, motivating the choice of self-supervised tasks in our experiments.
+
+The focus of most prior works on self-supervised learning is to supplant traditional fully supervised representation learning with unsupervised learning on large unlabeled datasets for downstream tasks. Crucially in almost all prior works, self-supervised representations consistently lag behind fullysupervised representations trained on the same dataset with the same architecture (Goyal et al., 2019; Kolesnikov et al., 2019). In contrast, our work focuses on an important counterexample: selfsupervision can in fact augment standard supervised training for few-shot transfer learning in the low training data regime without relying on any external dataset. Our work also investigates the effect of domain shifts across datasets used for SSL and a given task.
+
+![](images/ec03160eda39865e6eb4c168be0607ecc6c97b41ebd9c31164eeebdce363673d.jpg)  
+Figure 1: Our framework combines supervised and self-supervised losses to learn representations on small datasets. Self-supervised tasks, such as jigsaw puzzle or rotation prediction, can be derived from the images alone and act as a data-dependent regularizer for the shared feature backbone.
+
+Multi-task learning Our work is related to multi-task learning, a class of techniques that train on multiple task objectives together to improve each one. Previous works in the computer vision literature have shown moderate benefits by combining tasks such as edge, normal, and saliency estimation for images, or part segmentation and detection for humans (Kokkinos, 2017; Maninis et al., 2019; Ren & Lee, 2018). However, there is significant evidence that training on multiple tasks together often hurts performance on individual tasks (Kokkinos, 2017; Maninis et al., 2019). Only certain task combinations appear to be mutually beneficial, and sometimes specific architectures are needed. Our key contribution here is showing that self-supervised tasks and few-shot learning are indeed mutually beneficial in this sense. The fact that self-supervised tasks require no annotations makes our finding especially practically significant.
+
+Concurrent works At the time of submission several concurrent works appear to draw similar conclusions to ours. We briefly describe these, deferring a detailed comparison to the future when code and experimental details become available. Asano et al. (2019) finds that self-supervised pretraining is useful even with a single image. However, very large images and extreme data augmentations are used. Carlucci et al. (2019) uses self-supervision to improve domain generalization. Gidaris et al. (2019), the most related work to ours, also shows that self-supervision improves few-shot learning. Although this initial result is the same, we further show these benefits on smaller datasets with harder recognition problems (fine-grained classification) and with deeper models. Moreover, we also present a novel analysis of the impact of the domain of unlabeled data, and a new, simple approach to automatically select similar-domain unlabeled data for self-supervision.
+
+# 3 METHOD
+
+We adopt the commonly used setup for few-shot learning where one is provided with labeled training data for a set of base classes $\mathcal { D } _ { b }$ and a much smaller training set (typically 1-5 examples per class) for novel classes $\mathcal { D } _ { n }$ . The goal of the few-shot learner is to learn representations on the base classes that lead to good generalization on novel classes. Although in theory the base classes are assumed to have a large number of labeled examples, in practice this number can be quite small for novel domains, e.g. less than 5000 examples for the birds dataset (Welinder et al., 2010), making it challenging to learn a generalizable representation.
+
+Our framework, as seen in Figure 1, combines meta-learning approaches for few-shot learning that rely on supervised labels with self-supervised learning on unlabeled images. Denote a training dataset as $\mathbf { \dot { \{ ( x _ { i } , } }  y _ { i } ) \mathbf  \} _ { i = 1 } ^ { n }$ consisting of pairs of images $x _ { i } \in \mathcal X$ and labels $y _ { i } \in \mathcal { V }$ . A feed-forward convolutional network $f ( x )$ maps the input to an embedding space, which is then mapped to the label space using a classifier $g$ . The overall mapping from the input to the label can be written as $g \circ f ( { \bar { x } } ) : \mathcal { X } \to { \bar { \mathcal { V } } }$ . Learning consists of estimating functions $f$ and $g$ that minimize a loss $\ell$ on the predicted labels on the training data along with suitable regularization $\mathcal { R }$ over the functions $f$ and $g$ . This can be written as:
+
+$$
+\mathcal { L } _ { s } : = \sum _ { i } \ell \big ( g \circ f ( x _ { i } ) , y _ { i } \big ) + \mathcal { R } ( f , g ) .
+$$
+
+A commonly used loss is the cross-entropy loss and a regularizer is the $\ell _ { 2 }$ norm of the parameters of the functions. For transfer $g$ is discarded and relearned on training data for novel classes.
+
+In addition, we consider self-supervised losses $\mathcal { L } _ { s s }$ based on labeled data $x  ( \hat { x } , \hat { y } )$ that can be derived from inputs $x$ alone. Figure 1 shows two examples: the jigsaw task rearranges the input image and uses the index of the permutation as the target label, while the rotation task uses the angle of the rotated image as the target label. In our framework, a separate function $h$ is used to predict these labels from the shared feature backbone $f$ with a self-supervised loss:
+
+$$
+\mathcal { L } _ { s s } : = \sum _ { i } \ell \big ( h \circ f ( \hat { x } _ { i } ) , \hat { y } _ { i } \big ) .
+$$
+
+Our final loss function combines the two losses: $\mathcal { L } : = \mathcal { L } _ { s } + \mathcal { L } _ { s s }$ , and thus the self-supervised losses act as a data-dependent regularizer for representation learning. Note that the domain of images used for supervised and self-supervised losses denoted by $\mathcal { D } _ { s }$ and $\mathcal { D } _ { s s }$ need not be identical. In particular we often would like to use significantly larger sets of images for self-supervised learning from related domains. Below we describe various losses we consider for image classification tasks.
+
+# 3.1 SUPERVISED LOSSES $( \mathcal { L } _ { s } )$
+
+Most of our results are presented using a meta-learner based on prototypical networks (Snell et al., 2017) that perform episodic training and testing over sampled datasets in stages called meta-training and meta-testing. During meta-training, we randomly sample $N$ classes from the base set $\mathcal { D } _ { b }$ , then we select a support set $\boldsymbol { S _ { b } }$ with $K$ images per class and another query set $\mathcal { Q } _ { b }$ with $M$ images per class. We call this an $N$ -way $K$ -shot classification task. The embeddings are trained to predict the labels of the query set $\mathcal { Q } _ { b }$ conditioned on the support set $\boldsymbol { S _ { b } }$ using a nearest mean (prototype) model. The objective is to minimize the prediction loss on the query set. Once training is complete, given the novel dataset $\mathcal { D } _ { n }$ , class prototypes are recomputed for classification and query examples are classified based on the distances to the class prototypes.
+
+Prototypical networks are related to distance-based learners such as matching networks (Vinyals et al., 2016) or metric-learning based on label similarity (Koch et al., 2015). In the Appendix we also present few-shot classification results using a gradient-based meta-learner called MAML (Finn et al., 2017), and one trained with a standard cross-entropy loss on the base classes. We also present standard classification results where the test set contains images from the same base categories.
+
+# 3.2 SELF-SUPERVISED LOSSES $( \mathcal { L } _ { s s } )$
+
+We consider two losses motivated by a recent large-scale comparison of the effectiveness of selfsupervised learning tasks (Goyal et al., 2019) described below:
+
+Jigsaw puzzle task loss. In this case the input image $x$ is tiled into $3 \times 3$ regions and permuted randomly to obtain an input $\hat { x }$ . The target label $\hat { y }$ is the index of the permutation. The index (one of 9!) is reduced to one of 35 following the procedure outlined in Noroozi & Favaro (2016), which grouped the possible permutations based on hamming distance to control the difficulty of the task.
+
+Rotation task loss. We follow the method of Gidaris et al. (2018) where the input image $x$ is rotated by an angle $\theta \in \{ 0 ^ { \circ } , 9 0 ^ { \circ } , 1 8 0 ^ { \circ } , 2 7 0 ^ { \circ } \}$ to obtain $\hat { x }$ and the target label $\hat { y }$ is the index of the angle.
+
+In both cases we use the cross-entropy loss between the target and prediction.
+
+# 3.3 STOCHASTIC SAMPLING AND TRAINING
+
+When the source of images used for SSL and meta-learning are identical the same batch of images are used for computing $\mathcal { L } _ { s }$ and $\mathcal { L } _ { s s }$ . For experiments investigating domain shifts (Sec. 4.2), where SSL and meta-learner are trained on different distribution of images, a different batch (size of 64) is used for computing $\mathcal { L } _ { s s }$ . After the two forward passes, one for the supervised task and one for the
+
+self-supervised task, the two losses are combined. While other techniques exist (Chen et al., 2018;   
+Kendall et al., 2018; Sener & Koltun, 2018), simply combining the two losses performed well.
+
+# 4 EXPERIMENTS
+
+We first describe the datasets and experimental details. We then present results for few-shot learning on different datasets and SSL tasks in Section 4.1. Last, we investigate the effectiveness of SSL with unlabeled data sampled from different domains in Section 4.2.
+
+Datasets and benchmarks We experiment with datasets across diverse domains: Caltech-UCSD birds (Welinder et al., 2010), Stanford cars (Krause et al., 2013), FGVC aircrafts (Maji et al., 2013), Stanford dogs (Khosla et al., 2011), and Oxford flowers (Nilsback & Zisserman, 2006). Each dataset contains between 100 to 200 classes with a few thousands of images. We also experiment with the widely-used mini-ImageNet (Vinyals et al., 2016) and tiered-ImageNet (Ren et al., 2018) benchmarks for few-shot learning. In mini-ImageNet, each class has 600 images, where in tiered-ImageNet each class has 732 to 1300 images.
+
+We split classes within a dataset into three disjoint sets: base, val, and novel. For each class all the images in the dataset are used in the corresponding set. A model is trained on the base set of categories, validated on the val set, and tested on the novel set of categories given a few examples per class. For birds, we use the same split as Chen et al. (2019), where $\{ b a s e , \nu a l , n o \nu e l \}$ sets have $\{ 1 0 0 , 5 0 , 5 0 \}$ classes respectively. The same ratio is used for the other four fine-grained datasets. We use the original splits for mini-ImageNet and tiered-ImageNet.
+
+We also present results on a setting where the base set is “degraded” either by reducing the resolution, removing color, or the number of training examples to $20 \%$ of the original set. This allows us to study the effectiveness of SSL on even smaller datasets and as a function of the difficulty of the task. Further details of the datasets are in the Appendix A.1.
+
+Meta-learners and feature backbone We follow the best practices and use the codebase for fewshot learning described in Chen et al. (2019). In particular, we use a prototypical network (Snell et al., 2017) with a ResNet18 (He et al., 2016) as the feature backbone. Their experiments found this to often be the best performing; however, we also experiment our method with other meta-learners such as MAML (Finn et al., 2017) and softmax classifiers.
+
+Learning and optimization We use 5-way (classes) and 5-shot (examples per-class) with 16 query images for training. For experiments using $20 \%$ of labeled data, we use 5 query images for training since the minimum number of images per class is 10. The models are trained with ADAM (Kingma & Ba, 2015) with a learning rate of 0.001 for 60,000 episodes. We report the mean accuracy and $9 5 \%$ confidence interval over 600 test experiments. In each test episode, $N$ classes are selected from the novel set, and for each class 5 support images and 16 query images (or 5 query images when using $20 \%$ labeled data) are used. We report results for $N = \{ 5 , 2 0 \}$ classes.
+
+Image sampling and data augmentation Data augmentation has a significant impact on few-shot learning performance. We follow the data augmentation procedure outlined in Chen et al. (2019) which resulted in a strong baseline performance of meta-learning. For label and rotation predictions, images are first resized to 224 pixels for the shorter edge while maintaining the aspect ratio, from which a central crop of $2 2 4 \times 2 2 4$ is obtained. For jigsaw puzzles, we first randomly crop $2 5 5 \times 2 5 5$ region from the original image with random scaling between [0.5, 1.0], then split into $3 \times 3$ regions, from which a random crop of size $6 4 \times 6 4$ is picked. While it might appear that with self-supervision the model effectively sees more images, we wish to point out that all the experiments use significant data augmentation, including cropping, flipping, and color jittering, which also significantly increases the amount of training data. The gains from the self-supervised auxiliary tasks are over and above any gains from data augmentation alone. More experimental details are in Appendix A.5.
+
+Other experimental results In Appendix A.3, we show the benefits of using self-supervision for standard classification tasks when training the model from scratch. We further visualize these models in Appendix A.4 to show that models trained with self-supervision tend to avoid accidental correlation of background features to class labels.
+
+![](images/778001d15f9855a23b78dd41c9b9ba24ee233a43eac81b7a01f823641dd215b6.jpg)  
+Figure 2: Benefits of SSL for few-shot learning tasks. We show the accuracy over the ProtoNet baseline of using different SSL tasks. The jigsaw task results in an improvement of the 5-way 5-shot classification accuracy for a ProtoNet across datasets. Combining SSL tasks can be beneficial for some datasets. Here SSL was performed on images within the base classes only. See Table 2 in the Appendix for a tabular version and results for 20-way 5-shot classification.
+
+![](images/425e40f8cc91ac3cf293e2f93c3739d343ddea654f82e85eb891024f04bb860d.jpg)  
+Figure 3: Benefits of SSL for harder few-shot learning tasks. We show the accuracy of using jigsaw puzzle task over ProtoNet baseline on harder versions of the datasets. We see that SSL is effective even on smaller datasets and the relative benefits are higher.
+
+# 4.1 RESULTS ON FEW-SHOT LEARNING
+
+Self-supervised learning improves few-shot learning Figure 2 shows the accuracies of various models for 5-way 5-shot classification on few-shot benchmarks. Our ProtoNet baseline matches the results of the mini-ImageNet and birds datasets presented in Chen et al. (2019) (in their Table A5). Our results show that jigsaw puzzle task improves the ProtoNet baseline on all seven datasets. Specifically, it reduces the relative error rate by $4 . 0 \%$ , $8 . 7 \%$ , $1 9 . 7 \%$ , $8 . 4 \%$ , $4 . 7 \%$ , $1 5 . 9 \%$ , and $2 7 . 8 \%$ on mini-ImageNet, tiered-ImageNet, birds, cars, aircrafts, dogs, and flowers datasets respectively. Predicting rotations also improves the ProtoNet baseline on most of the datasets, except for aircrafts and flowers. We speculate this is because most flower images are symmetrical, and airplanes are usually horizontal, making the rotation task too hard or too trivial to benefit main task. In addition, combining these two SSL tasks can be beneficial sometimes. Our results also echo those of Gidaris et al. (2019) who find that the rotation task improves on mini- and tiered-ImageNet. A tabular version of the figure and the results for 20-way classification are included in Table 2 in Appendix A.2.
+
+Gains are larger for harder tasks Figure 3 shows the performance on the degraded version of the same datasets (first five groups). For cars and aircrafts we use low-resolution images where the images are down-sampled by a factor of four and up-sampled back to $2 2 4 \times 2 2 4$ with bilinear interpolation. For natural categories we discard color. Low-resolution images are considerably harder to classify for man-made categories while color information is most useful for natural categories (Su & Maji, 2017). On birds and dogs datasets, the improvements using self-supervision ( $3 . 2 \%$ and $2 . 9 \%$ on 5-way 5-shot) are higher compared to color images ( $2 . 5 \%$ and $2 . 7 \%$ ), similarly on the cars and aircrafts datasets with low-resolution images $2 . 2 \%$ and $2 . 1 \%$ vs. $0 . 7 \%$ and $0 . 4 \%$ ). We also conduct an experiment where only $20 \%$ of the images in the base categories are used for both SSL and meta-learning (last five groups in Figure 3). This results in a much smaller training set than standard few-shot benchmarks: $20 \%$ of the birds dataset amounts to only roughly $3 \%$ of the popular mini-ImageNet dataset. We find larger benefits from SSL in this setting. For example, the gain from the jigsaw puzzle loss for 5-way 5-shot car classification increases from $0 . 7 \%$ (original dataset) to $7 . 0 \%$ ( $20 \%$ training data).
+
+![](images/9682b15dfa78ea22b998a573df02748e1f3610e593a4a4fdc343e0b4fbda2b44.jpg)  
+(d) Effectiveness of SSL as a function of domain distance between $\mathcal { D } _ { s }$ and $\mathcal { D } _ { s s }$ (shown on top)   
+Figure 4: Effect of size and domain of SSL on 5-way 5-shot accuracy. (a) More unlabeled data from the same domain for SSL improves the performance of the meta-learner. $\mathbf { ( b ) }$ Replacing a fraction $\mathbf { \bar { X } }$ -axis) of the images with those from other domains makes SSL less effective. (c) A comparison of approaches to sample images from a pool for SSL. With random sampling, the extra unlabeled data often hurts the performance, while those sampled using the “domain weighs” improves performance on most datasets. When the pool contains images from related domains, e.g., birds and dogs, the performance using selected images matches that of using $100 \%$ within-dataset images. (d) Accuracy of the meta-learner with SSL on different domains as function of distance between the supervised domain $\mathcal { D } _ { s }$ and the self-supervised domain $\mathcal { D } _ { s s }$ . See text for details.
+
+Improvements generalize to other meta-learners We combine SSL with other meta-learners and find the combination to be effective. In particular we use MAML (Finn et al., 2017) and a standard feature extractor trained with cross-entropy loss (softmax). We observe that the average 5-way 5- shot accuracies across five fine-grained datasets for softmax, MAML, and ProtoNet improve from $8 5 . 5 \%$ , $8 2 . 6 \%$ and $8 8 . 5 \%$ to $8 6 . 6 \%$ , $8 3 . 8 \%$ and $9 0 . 4 \%$ respectively when combined with the jigsaw puzzle task. Detailed results are shown in Table 4 in Appendix A.2.
+
+Self-supervision alone is not enough SSL alone significantly lags behind supervised learning in our experiments. For example, a ResNet18 trained with SSL alone achieve $3 2 . 9 \%$ (w/ jigsaw) and $3 3 . 7 \%$ (w/ rotation) 5-way 5-shot accuracy averaged across five fine-grained datasets. While this is better than a random initialization $( 2 9 . 5 \% )$ , it is dramatically worse than one trained with a simple cross-entropy loss $( 8 5 . 5 \% )$ on the labels (Details in Table 2). Surprisingly, we found that initialization with SSL followed by meta-learning did not yield improvements over meta-learning starting from random initialization, supporting the view that SSL acts as a feature regularizer.
+
+# 4.2 SELECTING DOMAINS FOR SELF-SUPERVISION
+
+A promising direction of research in SSL is by scaling it to massive unlabeled datasets which are readily available for some domains. However, does more unlabeled data always help for a task in hand? This question hasn’t been sufficiently addressed in the literature as most prior works study the effectiveness of SSL on a curated set of images, such as ImageNet, and their transferability to a handful of tasks. In this section we conduct a series of experiments to characterize effect of size and distribution $\mathcal { D } _ { s s }$ of images used for SSL in the context of few-shot learning on a domain $\mathcal { D } _ { s }$ .
+
+First we investigate if SSL on unlabeled data from the same domain improves the meta-learner. We use $20 \%$ of the images in the base categories for meta-learning identical to setting in Figure 3. The labels of the remaining $80 \%$ data are withheld and only the images are used for SSL. We systematically vary the number of images used by the SSL from $20 \%$ to $100 \%$ . Results are presented in Figure 4a. The accuracy improves with the size of the unlabeled set with diminishing returns. Note that $0 \%$ corresponds to no SSL and $20 \%$ corresponds to using only the labeled images for SSL.
+
+Figure $\cdot$ shows an experiment where a fraction of the unlabeled images are replaced with images from other datasets. For example $20 \%$ along the $\mathbf { X }$ -axis for birds indicate that $20 \%$ of the images in base set are replaced by images drawn uniformly at random from other datasets. Since the number of images used for SSL are identical, the $\mathbf { X }$ -axis from left to right represents increasing amounts of domain shifts between $\mathcal { D } _ { s }$ and $\mathcal { D } _ { s s }$ . We observe that the effectiveness of SSL decreases as the fraction of out-of-domain images increases. Importantly, training with SSL on the available $20 \%$ within domain images (shown as crosses) is often (3 out of 5 datasets) better than increasing the set of images by five times to include out of domain images.
+
+Figure 4d analyzes how the magnitude of the domain shift affects performance. Here all the images in base classes are used (instead of using $20 \%$ data in previous experiment), and all the images for SSL are sampled from different datasets. In addition to the five datasets (birds, cars, aircrafts, dogs, flowers), we include 1) 5000 images of Aves from iNaturalist 2018 dataset (iNat) (Van Horn et al., 2018), 2) 5000 images of other super-classes from iNat, and 3) 5760 images sampled from miniImageNet. These domains are roughly of the same sizes (between $5 \mathrm { k }$ to 10k images each) but exhibit varying degrees of domain shifts. To compute a “distance” between a pair of domains, we first estimate an embedding for each domain $\mathcal { D }$ using the mean image feature: $\begin{array} { r } { \Phi ( { \mathcal { D } } ) = \sum _ { x _ { i } \in { \mathcal { D } } } \phi ( x _ { i } ) / N } \end{array}$ , where $N$ is the number of images within $\mathcal { D }$ , and use the Euclidean distance between their embeddings. Here $\phi ( x )$ is an image embedding from a ResNet101 network pretrained on ImageNet. Figure 4d shows the accuracy of the meta-learner when combined with SSL on different domains as a function of the domain distance between $\mathcal { D } _ { s }$ and $\mathcal { D } _ { s s }$ . Once again we see that the effectiveness of SSL decreases with the distance from the supervised domain across all datasets.
+
+Based on the above analysis we propose a simple method to select images for SSL from a large, generic pool of unlabeled images in a dataset dependent manner. We use a “domain weighted” model to select the top images based on a domain classifier, in our case a binary logistic regression model trained with images from the source domain $\mathcal { D } _ { s }$ as the positive class and from pool $\mathcal { D } _ { p }$ as the negative class based on ResNet101 image features. The top images are selected according to the ratio $\bar { p ( x \in \mathcal { D } _ { s } ) / p ( x \in \mathcal { D } _ { p } ) }$ . Note that these importance weights account for the domain shift. We evaluate this approach using a pool of images from all five datasets as well as 30000 images each from Aves of iNat, other super-classes of iNat and mini-ImageNet. For each dataset we use $20 \%$ of the labeled images for meta-learning, then use the pool in a leave-one-out manner: all images from a dataset are excluded from the pool to simulate a scenario where one does not have additional within-domain images. The compositions of the selected images are shown in Appendix A.6.
+
+Figure 4c shows results across datasets with meta-learner trained on $20 \%$ labeled examples. SSL with $20 \%$ and $100 \%$ dataset denotes baselines when SSL uses $20 \%$ and $100 \%$ of the images within domain. The latter is a reference “upper bound”. SSL pool “(random)” and “(weight)” denote two approaches for selecting the remaining $80 \%$ of images from the pool. The former selects images uniformly at random, which is detrimental for cars, dogs, and flowers. For dogs the performance is even worse than no SSL. The pool selected according to the importance weights provides significant improvements on birds and dogs as the pool has relevant images, and outperforms the random selection on most datasets. These results are likely to improve by collecting an even larger pool.
+
+# 5 CONCLUSION
+
+We have shown that self-supervision improves transferability of representations on few-shot learning tasks across a range of different domains. Surprisingly, we found that self-supervision is more beneficial for more challenging problems, especially when the number of images used for selfsupervision is small, orders of magnitude smaller than previously reported results. This has a practical benefit that the images within small datasets can be used for self-supervision without relying on a large-scale external dataset. We have also shown that additional unlabeled images can improve performance only if they are from the same or similar domains. Finally, for domains where unlabeled data is limited, we present a novel, simple approach to automatically identify such similar-domain images from a larger pool.
+
+# REFERENCES
+
+Yuki M Asano, Christian Rupprecht, and Andrea Vedaldi. Surprising effectiveness of few-image unsupervised feature learning. arXiv preprint arXiv:1904.13132, 2019. 3
+
+Philip Bachman, R Devon Hjelm, and William Buchwalter. Learning representations by maximizing mutual information across views. arXiv preprint arXiv:1906.00910, 2019. 2
+
+Luca Bertinetto, Joao F Henriques, Philip HS Torr, and Andrea Vedaldi. Meta-learning with differentiable closed-form solvers. International Conference on Learning Representations (ICLR), 2019. 2
+
+Piotr Bojanowski and Armand Joulin. Unsupervised learning by predicting noise. In International Conference on Machine Learning (ICML), 2017. 2
+
+Fabio M Carlucci, Antonio D’Innocente, Silvia Bucci, Barbara Caputo, and Tatiana Tommasi. Domain generalization by solving jigsaw puzzles. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2019. 3
+
+Mathilde Caron, Piotr Bojanowski, Armand Joulin, and Matthijs Douze. Deep clustering for unsupervised learning of visual features. In European Conference on Computer Vision (ECCV), 2018. 2
+
+Mathilde Caron, Piotr Bojanowski, Julien Mairal, and Armand Joulin. Leveraging large-scale uncurated data for unsupervised pre-training of visual features. arXiv preprint arXiv:1905.01278, 2019. 2
+
+Wei-Yu Chen, Yen-Cheng Liu, Zsolt Kira, Yu-Chiang Wang, and Jia-Bin Huang. A Closer Look at Few-shot Classification. In International Conference on Learning Representations (ICLR), 2019. 2, 5, 6, 15
+
+Zhao Chen, Vijay Badrinarayanan, Chen-Yu Lee, and Andrew Rabinovich. Gradnorm: Gradient normalization for adaptive loss balancing in deep multitask networks. In International Conference on Machine Learning (ICML), 2018. 5
+
+Carl Doersch and Andrew Zisserman. Multi-task self-supervised visual learning. In International Conference on Computer Vision (ICCV), 2017. 2
+
+Carl Doersch, Abhinav Gupta, and Alexei A Efros. Unsupervised visual representation learning by context prediction. In International Conference on Computer Vision (ICCV), 2015. 2
+
+Jeff Donahue and Karen Simonyan. Large scale adversarial representation learning. arXiv preprint arXiv:1907.02544, 2019. 2
+
+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. 2, 4, 5, 7
+
+Victor Garcia and Joan Bruna. Few-shot learning with graph neural networks. In International Conference on Learning Representations (ICLR), 2018. 2
+
+Spyros Gidaris and Nikos Komodakis. Dynamic few-shot visual learning without forgetting. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2018. 2
+
+Spyros Gidaris, Praveer Singh, and Nikos Komodakis. Unsupervised representation learning by predicting image rotations. In International Conference on Learning Representations (ICLR), 2018. 2, 4
+
+Spyros Gidaris, Andrei Bursuc, Nikos Komodakis, Patrick Perez, and Matthieu Cord. Boosting ´ few-shot visual learning with self-supervision. arXiv preprint arXiv:1906.05186, 2019. 3, 6
+
+Priya Goyal, Dhruv Mahajan, Abhinav Gupta, and Ishan Misra. Scaling and benchmarking selfsupervised visual representation learning. arXiv preprint arXiv:1905.01235, 2019. 2, 4
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Computer Vision and Pattern Recognition (CVPR), 2016. 5
+
+Olivier J Henaff, Ali Razavi, Carl Doersch, SM Eslami, and Aaron van den Oord. Data-efficient ´ image recognition with contrastive predictive coding. arXiv preprint arXiv:1905.09272, 2019. 2
+
+R Devon Hjelm, Alex Fedorov, Samuel Lavoie-Marchildon, Karan Grewal, Phil Bachman, Adam Trischler, and Yoshua Bengio. Learning deep representations by mutual information estimation and maximization. In International Conference on Learning Representations (ICLR), 2019. 2
+
+Simon Jenni and Paolo Favaro. Self-supervised feature learning by learning to spot artifacts. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2018. 2
+
+Alex Kendall, Yarin Gal, and Roberto Cipolla. Multi-task learning using uncertainty to weigh losses for scene geometry and semantics. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2018. 5
+
+Aditya Khosla, Nityananda Jayadevaprakash, Bangpeng Yao, and Li Fei-Fei. Novel dataset for finegrained image categorization. In First Workshop on Fine-Grained Visual Categorization, IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2011. 5
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In International Conference on Learning Representations (ICLR), 2015. 5
+
+Gregory Koch, Richard Zemel, and Ruslan Salakhutdinov. Siamese neural networks for one-shot image recognition. In ICML deep learning workshop, volume 2, 2015. 4
+
+Iasonas Kokkinos. Ubernet: Training a universal convolutional neural network for low-, mid-, and high-level vision using diverse datasets and limited memory. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2017. 3
+
+Alexander Kolesnikov, Xiaohua Zhai, and Lucas Beyer. Revisiting self-supervised visual representation learning. arXiv preprint arXiv:1901.09005, 2019. 2
+
+Jonathan Krause, Michael Stark, Jia Deng, and Li Fei-Fei. 3D Object Representations for FineGrained Categorization. In 4th International IEEE Workshop on 3D Representation and Recognition (3dRR-13), Sydney, Australia, 2013. 5
+
+Gustav Larsson, Michael Maire, and Gregory Shakhnarovich. Learning representations for automatic colorization. In European Conference on Computer Vision (ECCV), 2016. 2
+
+Kwonjoon Lee, Subhransu Maji, Avinash Ravichandran, and Stefano Soatto. Meta-learning with differentiable convex optimization. In Computer Vision and Pattern Recognition (CVPR), 2019. 2
+
+Subhransu Maji, Esa Rahtu, Juho Kannala, Matthew Blaschko, and Andrea Vedaldi. Fine-grained visual classification of aircraft. arXiv preprint arXiv:1306.5151, 2013. 5
+
+Kevis-Kokitsi Maninis, Ilija Radosavovic, and Iasonas Kokkinos. Attentive single-tasking of multiple tasks. arXiv preprint arXiv:1904.08918, 2019. 3
+
+M-E. Nilsback and A. Zisserman. A visual vocabulary for flower classification. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), volume 2, 2006. 5
+
+Mehdi Noroozi and Paolo Favaro. Unsupervised learning of visual representations by solving jigsaw puzzles. In European Conference on Computer Vision (ECCV), 2016. 4, 15
+
+Mehdi Noroozi, Hamed Pirsiavash, and Paolo Favaro. Representation learning by learning to count. In Proceedings of the IEEE International Conference on Computer Vision (ICCV), 2017. 2
+
+Aaron van den Oord, Yazhe Li, and Oriol Vinyals. Representation learning with contrastive predictive coding. arXiv preprint arXiv:1807.03748, 2018. 2
+
+Adam Paszke, Sam Gross, Soumith Chintala, Gregory Chanan, Edward Yang, Zachary DeVito, Zeming Lin, Alban Desmaison, Luca Antiga, and Adam Lerer. Automatic differentiation in pytorch. In NeurIPS Autodiff Workshop, 2017. 15
+
+Deepak Pathak, Philipp Krahenb ¨ uhl, Jeff Donahue, Trevor Darrell, and Alexei A. Efros. Context ¨ encoders: Feature learning by inpainting. In Computer Vision and Pattern Recognition (CVPR), 2016. 2
+
+Deepak Pathak, Ross B. Girshick, Piotr Dollar, Trevor Darrell, and Bharath Hariharan. Learning ´ features by watching objects move. In Computer Vision and Pattern Recognition (CVPR), 2017. 2
+
+Hang Qi, Matthew Brown, and David G Lowe. Low-shot learning with imprinted weights. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2018. 2
+
+Siyuan Qiao, Chenxi Liu, Wei Shen, and Alan L Yuille. Few-shot image recognition by predicting parameters from activations. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2018. 2
+
+Sachin Ravi and Hugo Larochelle. Optimization as a model for few-shot learning. In International Conference on Learning Representations (ICLR), 2017. 2
+
+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. International Conference on Learning Representations (ICLR), 2018. 5
+
+Zhongzheng Ren and Yong Jae Lee. Cross-domain self-supervised multi-task feature learning using synthetic imagery. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2018. 3
+
+Ozan Sener and Vladlen Koltun. Multi-task learning as multi-objective optimization. In Advances in Neural Information Processing Systems (NeurIPS), 2018. 5
+
+Jake Snell, Kevin Swersky, and Richard Zemel. Prototypical networks for few-shot learning. In Advances in Neural Information Processing Systems (NeurIPS), 2017. 2, 4, 5
+
+Jong-Chyi Su and Subhransu Maji. Adapting models to signal degradation using distillation. In British Machine Vision Conference (BMVC), 2017. 6
+
+Trieu H Trinh, Minh-Thang Luong, and Quoc V Le. Selfie: Self-supervised pretraining for image embedding. arXiv preprint arXiv:1906.02940, 2019. 2
+
+Grant Van Horn, Oisin Mac Aodha, Yang Song, Yin Cui, Chen Sun, Alex Shepard, Hartwig Adam, Pietro Perona, and Serge Belongie. The inaturalist species classification and detection dataset. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2018. 8
+
+Oriol Vinyals, Charles Blundell, Timothy Lillicrap, Daan Wierstra, et al. Matching networks for one shot learning. In Advances in neural information processing systems (NeurIPS), 2016. 2, 4, 5
+
+Xiaolong Wang and Abhinav Gupta. Unsupervised learning of visual representations using videos. In International Conference on Computer Vision (ICCV), 2015. 2
+
+Xiaolong Wang, Kaiming He, and Abhinav Gupta. Transitive invariance for self-supervised visual representation learning. In International Conference on Computer Vision (ICCV), 2017. 2
+
+P. Welinder, S. Branson, T. Mita, C. Wah, F. Schroff, S. Belongie, and P. Perona. Caltech-UCSD Birds 200. Technical Report CNS-TR-2010-001, California Institute of Technology, 2010. 3, 5
+
+Davis Wertheimer and Bharath Hariharan. Few-shot learning with localization in realistic settings. In Computer Vision and Pattern Recognition (CVPR), 2019. 14
+
+Zhirong Wu, Yuanjun Xiong, Stella X. Yu, and Dahua Lin. Unsupervised feature learning via nonparametric instance discrimination. In Computer Vision and Pattern Recognition (CVPR), 2018. 2
+
+Richard Zhang, Phillip Isola, and Alexei A Efros. Colorful image colorization. In European Conference on Computer Vision (ECCV), 2016. 2
+
+Richard Zhang, Phillip Isola, and Alexei A Efros. Split-brain autoencoders: Unsupervised learning by cross-channel prediction. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2017. 2
+
+# A APPENDIX
+
+# A.1 DATASET DETAILS
+
+The statistics of various datasets used in our experiments are shown in Table 1. We show results on several fine-grained classification datasets in addition to standard few-shot benchmarks such as mini- and tiered-ImageNet. Notably, the fine-grained datasets are significantly smaller.
+
+<table><tr><td rowspan=1 colspan=18>Birds                Cars              Aircrafts              Dogs               Flowers</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=2></td><td rowspan=1 colspan=2></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=2></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>*</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=2></td><td rowspan=1 colspan=8></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td rowspan=1 colspan=2>福</td><td rowspan=6 colspan=1></td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td rowspan=1 colspan=2>mini-ImageNet</td><td rowspan=1 colspan=2>tiered-ImageNet</td><td rowspan=1 colspan=1>Birds</td><td rowspan=1 colspan=1>Cars</td><td></td><td rowspan=1 colspan=2>Aircrafts</td><td rowspan=1 colspan=1>Dogs</td><td rowspan=1 colspan=2>Flowers</td></tr><tr><td></td><td></td><td rowspan=1 colspan=2>Base</td><td rowspan=1 colspan=2>#class#images</td><td rowspan=1 colspan=2>6438,400</td><td rowspan=1 colspan=2>351448,695</td><td rowspan=1 colspan=1>1005885</td><td rowspan=1 colspan=1>988162</td><td></td><td rowspan=1 colspan=2>505000</td><td rowspan=1 colspan=1>6010337</td><td rowspan=1 colspan=2>514129</td></tr><tr><td></td><td></td><td rowspan=1 colspan=2>Val</td><td rowspan=1 colspan=2>#class#images</td><td rowspan=1 colspan=2>169,600</td><td rowspan=1 colspan=2>97124,261</td><td rowspan=1 colspan=1>502950</td><td rowspan=1 colspan=1>493993</td><td></td><td rowspan=1 colspan=2>252500</td><td rowspan=1 colspan=1>305128</td><td rowspan=1 colspan=2>262113</td></tr><tr><td></td><td></td><td rowspan=2 colspan=2>Novel</td><td rowspan=2 colspan=2>#class#images</td><td rowspan=2 colspan=2>2012.000</td><td rowspan=2 colspan=2>160206,209</td><td rowspan=2 colspan=1>502953</td><td rowspan=1 colspan=1>49</td><td></td><td rowspan=1 colspan=2>25</td><td rowspan=1 colspan=1>30</td><td rowspan=1 colspan=2>25</td></tr><tr><td></td><td></td><td rowspan=1 colspan=1>4030</td><td></td><td rowspan=1 colspan=2>2500</td><td rowspan=1 colspan=1>5115</td><td rowspan=1 colspan=2>1947</td></tr></table>
+
+Table 1: Example images and dataset statistics. For few-shot learning experiments the classes are split into base, val, and novel set. Image representations learned on base set are evaluated on the novel set while val set is used for cross-validation. These datasets vary in the number of classes but are orders of magnitude smaller than ImageNet dataset.
+
+# A.2 RESULTS ON FEW-SHOT LEARNING
+
+Table 2 shows the performance of ProtoNet with different self-supervision on seven datasets. We also test the accuracy of the model on novel classes when trained only with self-supervision on the base set of images. Compared to the randomly initialized model (“None” rows), training the network to predict rotations gives around $2 \%$ to $21 \%$ improvements on all datasets, while solving jigsaw puzzles only improves on aircrafts and flowers. However, these numbers are significantly worse than learning with supervised labels on the base set, in line with the current literature.
+
+Table 3 shows the performance of ProtoNet with jigsaw puzzle loss on harder benchmarks. The results on degraded version of the datasets are shown in the top part, and the bottom part shows the results of using only $20 \%$ of the images in the base categories. The gains using SSL are higher in this setting.
+
+Table 4 compares meta-learners based on a ResNet18 network trained with and without jigsaw puzzle loss. Self-supervision improves the performance across different meta-learners and different datasets. ProtoNet trained with self-supervision is the best model across all datasets.
+
+Table 2: Performance on few-shot transfer task. The mean accuracy $( \% )$ and the $9 5 \%$ confidence interval of 600 randomly chosen test experiments are reported for various combinations of loss functions. The top part shows the accuracy on 5-way 5-shot classification tasks, while the bottom part shows the same on 20-way 5-shot. Adding self-supervised losses to the ProtoNet loss improves the performance on all seven datasets on 5-way classification results. On 20-way classification, the improvements are even larger. The last row indicates results with a randomly initialized network. The top part of this table corresponds to Figure 2.   
+
+<table><tr><td rowspan=2 colspan=4>Loss</td><td rowspan=1 colspan=1>mini-ImageNet</td><td rowspan=1 colspan=1>tiered-ImageNet</td><td rowspan=1 colspan=1>Birds</td><td rowspan=1 colspan=1>Cars</td><td rowspan=1 colspan=1>Aircrafts</td><td rowspan=1 colspan=1>Dogs</td><td rowspan=1 colspan=1>Flowers</td></tr><tr><td rowspan=1 colspan=7> 5-way 5-shot</td></tr><tr><td rowspan=1 colspan=4>ProtoNet</td><td rowspan=1 colspan=1>75.2±0.6</td><td rowspan=1 colspan=1>75.9±0.7</td><td rowspan=1 colspan=1>87.3±0.5</td><td rowspan=1 colspan=1>91.7±0.4</td><td rowspan=1 colspan=1>91.4±0.4</td><td rowspan=1 colspan=1>83.0±0.6</td><td rowspan=1 colspan=1>89.2±0.6</td></tr><tr><td rowspan=1 colspan=4>ProtoNet + JigsawRel. error reduction</td><td rowspan=1 colspan=1>76.2±0.64.0%</td><td rowspan=1 colspan=1>78.0±0.78.7%</td><td rowspan=1 colspan=1>89.8±0.419.7%</td><td rowspan=1 colspan=1>92.4±0.48.4%</td><td rowspan=1 colspan=1>91.8±0.44.7%</td><td rowspan=1 colspan=1>85.7±0.515.9%</td><td rowspan=1 colspan=1>92.2±0.427.8%</td></tr><tr><td rowspan=1 colspan=2>J</td><td rowspan=1 colspan=1>1。</td><td rowspan=1 colspan=1>Jigsaw</td><td rowspan=1 colspan=1>25.6±0.5</td><td rowspan=1 colspan=1>24.9±0.4</td><td rowspan=1 colspan=1>25.7±0.5</td><td rowspan=1 colspan=1>25.3±0.5</td><td rowspan=1 colspan=1>38.8±0.6</td><td rowspan=1 colspan=1>24.3±0.5</td><td rowspan=1 colspan=1>50.5±0.7</td></tr><tr><td rowspan=1 colspan=4>ProtoNet+Rotation</td><td rowspan=1 colspan=1>76.0±0.6</td><td rowspan=1 colspan=1>78.9±0.7</td><td rowspan=1 colspan=1>89.4±0.4</td><td rowspan=1 colspan=1>92.3±0.4</td><td rowspan=1 colspan=1>91.4±0.4</td><td rowspan=2 colspan=1>84.3±0.527.3±0.5</td><td rowspan=2 colspan=1>89.0±0.549.4±0.7</td></tr><tr><td rowspan=2 colspan=4>RotationProtoNet + Jig. + Rot.</td><td rowspan=1 colspan=1>51.4±0.7</td><td rowspan=1 colspan=1>50.7±0.8</td><td rowspan=1 colspan=1>33.1±0.6</td><td rowspan=1 colspan=1>29.4±0.5</td><td rowspan=1 colspan=1>29.5±0.5</td></tr><tr><td rowspan=1 colspan=1>76.6±0.7</td><td rowspan=1 colspan=1>77.2±0.7</td><td rowspan=1 colspan=1>90.2±0.4</td><td rowspan=1 colspan=1>92.7±0.4</td><td rowspan=1 colspan=1>91.9±0.4</td><td rowspan=1 colspan=1>85.9±0.5</td><td rowspan=1 colspan=1>91.4±0.5</td></tr><tr><td rowspan=1 colspan=4>None</td><td rowspan=1 colspan=1>31.0±0.5</td><td rowspan=1 colspan=1>28.9±0.5</td><td rowspan=1 colspan=1>26.7±0.5</td><td rowspan=1 colspan=1>25.2±0.5</td><td rowspan=1 colspan=1>28.1±0.5</td><td rowspan=1 colspan=1>25.3±0.5</td><td rowspan=1 colspan=1>42.3±0.8</td></tr><tr><td rowspan=1 colspan=4></td><td rowspan=1 colspan=7>20-way 5-shot</td></tr><tr><td rowspan=1 colspan=4>ProtoNet</td><td rowspan=1 colspan=1>46.6±0.3</td><td rowspan=1 colspan=1>49.7±0.4</td><td rowspan=1 colspan=1>69.3±0.3</td><td rowspan=1 colspan=1>78.7±0.3</td><td rowspan=1 colspan=1>78.6±0.3</td><td rowspan=1 colspan=1>61.6±0.3</td><td rowspan=1 colspan=1>75.4±0.3</td></tr><tr><td rowspan=1 colspan=4>ProtoNet + Jigsaw</td><td rowspan=1 colspan=1>47.8±0.3</td><td rowspan=1 colspan=1>52.4±0.4</td><td rowspan=1 colspan=1>73.7±0.3</td><td rowspan=1 colspan=1>79.1±0.3</td><td rowspan=1 colspan=1>79.1±0.2</td><td rowspan=1 colspan=1>65.4±0.3</td><td rowspan=1 colspan=1>79.2±0.3</td></tr><tr><td rowspan=2 colspan=4>JigsawProtoNet + Rotation</td><td rowspan=1 colspan=1>9.2±0.2</td><td rowspan=1 colspan=1>7.5±0.1</td><td rowspan=1 colspan=1>8.1±0.1</td><td rowspan=1 colspan=1>7.1±0.1</td><td rowspan=1 colspan=1>15.4±0.2</td><td rowspan=1 colspan=1>7.1±0.1</td><td rowspan=1 colspan=1>25.7±0.2</td></tr><tr><td rowspan=1 colspan=1>48.2±0.3</td><td rowspan=1 colspan=1>52.4±0.4</td><td rowspan=1 colspan=1>72.9±0.3</td><td rowspan=1 colspan=1>80.0±0.3</td><td rowspan=1 colspan=1>78.4±0.2</td><td rowspan=1 colspan=1>63.4±0.3</td><td rowspan=1 colspan=1>73.9±0.3</td></tr><tr><td rowspan=2 colspan=4>RotationProtoNet + Jig.+ Rot.</td><td rowspan=1 colspan=1>27.4±0.2</td><td rowspan=1 colspan=1>25.7±0.3</td><td rowspan=1 colspan=1>12.9±0.2</td><td rowspan=1 colspan=1>9.3±0.2</td><td rowspan=1 colspan=1>9.8±0.2</td><td rowspan=1 colspan=1>8.8±0.1</td><td rowspan=1 colspan=1>26.3±0.2</td></tr><tr><td rowspan=1 colspan=1>49.0±0.3</td><td rowspan=1 colspan=1>51.2±0.4</td><td rowspan=1 colspan=1>75.0±0.3</td><td rowspan=1 colspan=1>79.8±0.3</td><td rowspan=1 colspan=1>79.0±0.2</td><td rowspan=1 colspan=1>66.2±0.3</td><td rowspan=1 colspan=1>78.6±0.3</td></tr><tr><td rowspan=1 colspan=4>None</td><td rowspan=1 colspan=1>10.8±0.1</td><td rowspan=1 colspan=1>11.0±0.2</td><td rowspan=1 colspan=1>9.3±0.2</td><td rowspan=1 colspan=1>7.5±0.1</td><td rowspan=1 colspan=1>8.9±0.1</td><td rowspan=1 colspan=1>7.8±0.1</td><td rowspan=1 colspan=1>22.6±0.2</td></tr></table>
+
+Table 3: Performance on few-shot transfer task with degraded inputs or less training data. Accuracies are reported on novel set for 5-way 5-shot and 20-way 5-shot classification with degraded inputs, and with a subset $( 2 0 \% )$ of the images in the base set. The loss of color or resolution, and the smaller training set size make the tasks more challenging as seen by the drop in the performance of the ProtoNet baseline. However the improvements of using the jigsaw puzzle loss are higher in comparison to the results presented in Table 2.   
+
+<table><tr><td>Loss</td><td>Birds Greyscale</td><td>Cars Low-resolution</td><td>Aircrafts Low-resolution</td><td>Dogs Greyscale</td><td>Flowers Greyscale</td></tr><tr><td></td><td colspan="5">5-way 5-shot</td></tr><tr><td>ProtoNet</td><td>82.2±0.6</td><td>84.8±0.5</td><td>85.0±0.5</td><td>80.7±0.6</td><td>86.1±0.6</td></tr><tr><td>ProtoNet + Jigsaw</td><td>85.4±0.6</td><td>87.0±0.5</td><td>87.1±0.5</td><td>83.6±0.5</td><td>87.6±0.5</td></tr><tr><td>ProtoNet</td><td>64.7±0.3</td><td></td><td>20-way 5-shot 64.1±0.3</td><td>57.4±0.3</td><td>69.7±0.3</td></tr><tr><td>ProtoNet + Jigsaw</td><td>60.8±0.4 65.7±0.3</td><td>68.6±0.3</td><td>68.3±0.3</td><td>61.2±0.3</td><td>71.6±0.3</td></tr><tr><td>Loss</td><td>20% Birds</td><td>20% Cars</td><td>20% Aircrafts</td><td>20% Dogs</td><td>20% Flowers</td></tr><tr><td></td><td colspan="5">5-way 5-shot</td></tr><tr><td>ProtoNet</td><td>73.0±0.7</td><td>75.8±0.7</td><td>77.7±0.6</td><td>68.5±0.7</td><td>82.2±0.7</td></tr><tr><td>ProtoNet + Jigsaw</td><td>75.4±0.7</td><td>82.8±0.6</td><td>78.4±0.6</td><td>69.1±0.7</td><td>86.0±0.6</td></tr><tr><td></td><td colspan="5">20-way 5-shot</td></tr><tr><td>ProtoNet</td><td>46.4±0.3</td><td>51.8±0.4</td><td>52.3±0.3</td><td>40.8±0.3</td><td>62.8±0.3</td></tr><tr><td>ProtoNet + Jigsaw</td><td>49.8±0.3</td><td>61.5±0.4</td><td>53.6±0.3</td><td>42.2±0.3</td><td>68.5±0.3</td></tr></table>
+
+Table 4: Performance on few-shot transfer task using different meta-learners. Using jigsaw puzzle loss gives improvements across different meta-learners on most of the datasets. ProtoNet with jigsaw loss performs the best on all five datasets.   
+
+<table><tr><td rowspan="2">Loss</td><td>Birds</td><td>Cars</td><td>Aircrafts</td><td>Dogs</td><td>Flowers</td></tr><tr><td colspan="4">5-way 5-shot</td></tr><tr><td>Softmax</td><td>81.5±0.5</td><td>87.7±0.5</td><td>89.2±0.4</td><td>77.6±0.6</td><td>91.3±0.5</td></tr><tr><td>Softmax + Jigsaw</td><td>83.9±0.5</td><td>90.6±0.5</td><td>89.6±0.4</td><td>77.8±0.6</td><td>90.9±0.5</td></tr><tr><td>MAML</td><td>81.2±0.7</td><td>86.9±0.6</td><td>88.8±0.5</td><td>77.3±0.7</td><td>79.0±0.9</td></tr><tr><td>MAML + Jigsaw</td><td>81.1±0.7</td><td>89.0±0.5</td><td>89.1±0.5</td><td>77.3±0.7</td><td>82.6±0.7</td></tr><tr><td>ProtoNet</td><td>87.3±0.5</td><td>91.7±0.4</td><td>91.4±0.4</td><td>83.0±0.6</td><td>89.2±0.6</td></tr><tr><td>ProtoNet + Jigsaw</td><td>89.8±0.4</td><td>92.4±0.4</td><td>91.8±0.4</td><td>85.7±0.5</td><td>92.2±0.4</td></tr></table>
+
+# A.3 RESULTS ON STANDARD FINE-GRAINED CLASSIFICATION
+
+Here we present results on standard classification task. Different from few-shot transfer learning, all the classes are seen in the training set and test set contains novel images from the same classes. We use the standard training and test splits provided in the datasets. We investigate if SSL can improve training of deep networks (e.g. ResNet18 network) when trained from scratch (i.e. with random initialization) using images and labels in the training set only. The accuracy using various loss functions are shown in Table 5. Training with self-supervision improves performance across datasets. On birds, cars, and dogs, predicting rotation gives $4 . 1 \%$ , $3 . 1 \%$ , and $3 . 0 \%$ improvements, while on aircrafts and flowers, the jigsaw puzzle loss yields $0 . 9 \%$ and $3 . 6 \%$ improvements.
+
+Table 5: Performance on standard classification task. Per-image accuracy $( \% )$ on the test set are reported. Using self-supervision improves the accuracy of a ResNet18 network trained from scratch over the baseline of supervised training with cross-entropy (softmax) loss on all five datasets.   
+
+<table><tr><td>Loss</td><td>Birds</td><td>Cars</td><td>Aircrafts</td><td>Dogs</td><td>Flowers</td></tr><tr><td>Softmax</td><td>47.0</td><td>72.6</td><td>69.9</td><td>51.4</td><td>72.8</td></tr><tr><td>Softmax + Jigsaw</td><td>49.2</td><td>73.2</td><td>70.8</td><td>53.5</td><td>76.4</td></tr><tr><td>Softmax + Rotation</td><td>51.1</td><td>75.7</td><td>70.0</td><td>54.4</td><td>73.5</td></tr></table>
+
+# A.4 VISUALIZATION OF LEARNED MODELS
+
+To understand why the representation generalizes, we visualize what pixels contribute the most to the correct classification for various models. In particular, for each image and model we compute the gradient of the logits (predictions before softmax) for the correct class with respect to the input image. The magnitude of the gradient at each pixel is a proxy for its importance and is visualized as “saliency maps”. Figure 5 shows these maps for various images and models trained with and without self-supervision on the standard classification task. It appears that the self-supervised models tend to focus more on the foreground regions, as seen by the amount of bright pixels within the bounding box. One hypothesis is that self-supervised tasks force the model to rely less on background features, which might be accidentally correlated to the class labels. For fine-grained recognition, localization indeed improves performance when training from few examples (see Wertheimer & Hariharan (2019) for a contemporary evaluation of the role of localization for few-shot learning).
+
+# A.5 EXPERIMENTAL DETAILS
+
+Additional optimization details on few-shot learning During training, especially for jigsaw puzzle task, we found it to be beneficial to not track the running mean and variance for the batch normalization layer, and instead estimate them for each batch independently. We hypothesize that this is because the inputs contain both full-sized images and small patches, which might have different statistics. At test time we do the same. We found the accuracy goes up as the batch size increases but saturates at size of 64.
+
+![](images/623c70098be77a56354a43d1a05f40fb23d0b084fba649e6a6f0c7628ff1d76b.jpg)  
+Figure 5: Saliency maps for various images and models. For each image we visualize the magnitude of the gradient with respect to the correct class for models trained with various loss functions. The magnitudes are scaled to the same range for easier visualization. The models trained with selfsupervision often have lower energy on the background regions when there is clutter. We highlight a few examples with blue borders and the bounding-box of the object for each image is shown in red.
+
+When training with supervised and self-supervised loss, a trade-off term $\lambda$ between the losses can be used, thus the total loss is $\mathcal { L } = ( 1 - \lambda ) \bar { \mathcal { L } } _ { s } + \lambda \mathcal { L } _ { s s }$ . We find that simply use $\lambda = 0 . 5$ works the best, except for training on mini- and tiered-ImageNet with jigsaw loss, where we set $\lambda = 0 . 3$ . We suspect that this is because the variation of the image size and the categories are higher, making the self-supervision harder to train with limited data. When both jigsaw and rotation losses are used, we set $\lambda = 0 . 5$ and the two self-supervised losses are averaged for $\mathcal { L } _ { s s }$ .
+
+For training meta-learners, we use 16 query images per class for each training episode. When only $20 \%$ of labeled data are used, 5 query images per class are used. For MAML, we use 10 query images and the approximation method for backpropagation as proposed in Chen et al. (2019) to reduce the GPU memory usage. When training with self-supervised loss, it is added when computing the loss in the outer loop. We use PyTorch (Paszke et al., 2017) for our experiments.
+
+For the domain classifier, we first obtain features from the penultimate-layer (2048 dimensional) from a ResNet101 model pretrained on ImageNet. We then train a binary logistic regression model with weight decay using LBFGS for 1000 iterations. The images from labeled dataset are the positive class and images from pool are the negative. A loss for the positive class is scaled by the inverse of its frequency to account for the significantly larger number of negative examples.
+
+Optimization details for standard classification For standard classification (Appendix A.3) we train a ResNet18 network from scratch. All the models are trained with ADAM optimizer with a learning rate of 0.001 for 600 epochs with a batch size of 16. We track the running statistics for the batch normalization layer for the softmax baselines following the conventional setting, i.e. w/o self-supervised loss, but do not track these statistics when training with self-supervision.
+
+Architectures for self-supervised tasks For jigsaw puzzle task, we follow the architecture of Noroozi & Favaro (2016) where it was first proposed. The ResNet18 results in a 512-dimensional feature for each input, and we add a fully-connected (fc) layer with 512-units on top. The nine patches gives nine 512-dimensional feature vectors, which are concatenated. This is followed by a fc layer, projecting the feature vector from 4608 to 4096 dimensions, and a fc layer with 35- dimensional outputs corresponding to the 35 permutations for the jigsaw task.
+
+For the rotation task, the 512-dimensional output of ResNet18 is passed through three fc layers with $\{ 5 1 2 , 1 2 8 , 1 2 8 , 4 \}$ units. The predictions correspond to the four rotation angles. Between each $\pounds _ { C }$ layer, a ReLU activation and a dropout layer with dropout probability of 0.5 are added.
+
+# A.6 DETAILS OF THE DATASET SELECTED FROM POOL
+
+Table 6 describes the composition of the unlabeled images sampled from a generic pool for SSL experiments presented in Section 4.2 (Figure 4c). “Random sampling” uniformly samples images proportional to the size of each dataset, while the “domain weighted” one tends to pick more images from related domains. This is also indicated by the domain distance of the sampled images with respect to the source domain. The improvements are larger when the domain distance is small, e.g., for birds, dogs, and flowers.
+
+<table><tr><td rowspan=4 colspan=3>Dataset</td><td rowspan=1 colspan=10>Labeled dataset</td></tr><tr><td rowspan=1 colspan=2>20% Birds</td><td rowspan=1 colspan=2>20% Cars</td><td rowspan=1 colspan=2>20% Aircrafts</td><td rowspan=1 colspan=2>20% Dogs</td><td rowspan=1 colspan=2>20% Flowers</td></tr><tr><td rowspan=1 colspan=10>Selection method</td></tr><tr><td rowspan=1 colspan=1>randomy</td><td rowspan=1 colspan=1>weight</td><td rowspan=1 colspan=1>random</td><td rowspan=1 colspan=1>weight</td><td rowspan=1 colspan=1>random</td><td rowspan=1 colspan=1>weight</td><td rowspan=1 colspan=1>random</td><td rowspan=1 colspan=1>weight</td><td rowspan=1 colspan=1>trandom</td><td rowspan=1 colspan=1>weight</td></tr><tr><td rowspan=8 colspan=3>BirdsCarsAircraftsDogsFlowersiNat avesiNat othersmini-ImageNet</td><td rowspan=1 colspan=1>1177</td><td rowspan=1 colspan=1>1177</td><td rowspan=1 colspan=1>325</td><td rowspan=1 colspan=1>87</td><td rowspan=1 colspan=1>184</td><td rowspan=1 colspan=1>114</td><td rowspan=1 colspan=1>410</td><td rowspan=1 colspan=1>118</td><td rowspan=1 colspan=1>156</td><td rowspan=1 colspan=1>9</td></tr><tr><td rowspan=1 colspan=1>303</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>1632</td><td rowspan=1 colspan=1>1632</td><td rowspan=1 colspan=1>242</td><td rowspan=1 colspan=1>466</td><td rowspan=1 colspan=1>532</td><td rowspan=1 colspan=1>594</td><td rowspan=1 colspan=1>230</td><td rowspan=1 colspan=1>12</td></tr><tr><td rowspan=1 colspan=1>214</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>259</td><td rowspan=1 colspan=1>259</td><td rowspan=1 colspan=1>1000</td><td rowspan=1 colspan=1>1000</td><td rowspan=1 colspan=1>356</td><td rowspan=2 colspan=1>2852067</td><td rowspan=2 colspan=1>129283</td><td rowspan=2 colspan=1>091</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>413</td><td rowspan=1 colspan=1>19</td><td rowspan=1 colspan=1>554</td><td rowspan=1 colspan=1>657</td><td rowspan=1 colspan=1>334</td><td rowspan=1 colspan=1>251</td><td rowspan=1 colspan=1>2067</td></tr><tr><td rowspan=1 colspan=2>Flowers</td><td rowspan=1 colspan=1>167</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>230</td><td rowspan=1 colspan=1>162</td><td rowspan=1 colspan=1>140</td><td rowspan=1 colspan=1>40</td><td rowspan=1 colspan=1>290</td><td rowspan=2 colspan=1>145744</td><td rowspan=3 colspan=1>825767793</td><td rowspan=3 colspan=1>8251192533</td></tr><tr><td rowspan=1 colspan=1>1133</td><td rowspan=1 colspan=1>4176</td><td rowspan=1 colspan=1>1599</td><td rowspan=1 colspan=1>792</td><td rowspan=1 colspan=1>957</td><td rowspan=1 colspan=1>815</td><td rowspan=1 colspan=1>1997</td></tr><tr><td rowspan=1 colspan=1>1089</td><td rowspan=1 colspan=1>108</td><td rowspan=1 colspan=1>1546</td><td rowspan=1 colspan=1>1555</td><td rowspan=1 colspan=1>935</td><td rowspan=1 colspan=1>240</td><td rowspan=1 colspan=1>2048</td><td rowspan=1 colspan=1>964</td></tr><tr><td rowspan=1 colspan=1>1389</td><td rowspan=1 colspan=1>397</td><td rowspan=1 colspan=1>2017</td><td rowspan=1 colspan=1>3018</td><td rowspan=1 colspan=1>1208</td><td rowspan=1 colspan=1>2074</td><td rowspan=1 colspan=1>2637</td><td rowspan=1 colspan=1>5420</td><td rowspan=1 colspan=1>946</td><td rowspan=1 colspan=1>540</td></tr><tr><td rowspan=1 colspan=3>Domain distance →</td><td rowspan=1 colspan=1>6.69</td><td rowspan=1 colspan=1>0.94</td><td rowspan=1 colspan=1>11.42</td><td rowspan=1 colspan=1>9.69</td><td rowspan=1 colspan=1>13.41</td><td rowspan=1 colspan=1>11.13</td><td rowspan=1 colspan=1>8.72</td><td rowspan=1 colspan=1>3.68</td><td rowspan=1 colspan=1>13.38</td><td rowspan=1 colspan=1>4.57</td></tr><tr><td rowspan=1 colspan=3>Accuracy (%)→</td><td rowspan=1 colspan=1>75.7</td><td rowspan=1 colspan=1>78.5</td><td rowspan=1 colspan=1>79.2</td><td rowspan=1 colspan=1>80.8</td><td rowspan=1 colspan=1>79.7</td><td rowspan=1 colspan=1>79.2</td><td rowspan=1 colspan=1>66.6</td><td rowspan=1 colspan=1>74.6</td><td rowspan=1 colspan=1>83.4</td><td rowspan=1 colspan=1>85.6</td></tr></table>
+
+Table 6: Composition of the unlabeled datasets selected from a pool of images used in Figure 4c. We list the number of images in each source datasets. We also provide domain distance between the selected images and the labeled dataset. The 5-way 5-shot accuracy of the models trained with SSL are shown in the last row. The performance correlates with domain distance: when the distribution of unlabeled data is closer to labeled data, the performance is better.

parse/train/T1STW1NYYKW/T1STW1NYYKW_content_list.json

@@ -0,0 +1,1277 @@
+[
+    {
+        "type": "text",
+        "text": "Practical Bayesian Optimization of Objectives with Conditioning Variables ",
+        "text_level": 1,
+        "bbox": [
+            191,
+            122,
+            808,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous Author(s)   \nAffiliation   \nAddress   \nemail ",
+        "bbox": [
+            423,
+            226,
+            580,
+            281
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            318,
+            535,
+            334
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Bayesian optimization is a class of data efficient model based algorithms typically focused on global optimization. We consider the more general case where a user is faced with multiple tasks that each need to be optimized, find the global optima within each task, all the task conditional optima. For example given a range of cities with different patient distributions, we optimize the ambulance locations for each and every city; given subclass partitions of CIFAR-10, we optimize CNN hyperparameters for each partition. Similarity across tasks boosts optimization of each task in two ways: in modelling by data sharing across objectives, and also in acquisition by quantifying how a single point on one task can help learn the optima of similar tasks. For this we propose a framework for conditional optimization: ConBO. This can be built on top of a range of acquisition functions and we propose a new Hybrid Knowledge Gradient acquisition function. The resulting method is intuitive and theoretically grounded, either matches or significantly outperforms recently published works on a range of problems, and thanks to the unique nature of conditional optimization, is easily parallelized to collect a batch of points. ",
+        "bbox": [
+            148,
+            348,
+            766,
+            558
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "16 1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            582,
+            312,
+            599
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "17 Expensive stochastic black box functions arise in many fields such as fluid simulations [1], engineering   \n18 wing design [2], and machine learning parameter tuning [3]. Bayesian optimization is a powerful set   \n19 of tools to optimize such functions, finding the input with highest long term average performance   \n20 $x ^ { * } = \\arg \\operatorname* { m a x } _ { x } \\mathbb { E } [ f ( x ) ]$ , (the expectation represents averaging over the performance noise). In this   \n21 work we consider an under-explored generalization of the standard setting previously referred to as   \n22 “conditional optimization\" [4] where a user has a collection of functions, or tasks, and simply seeks   \n23 the peak of each function/task. Formally, we have an expensive black box $f$ that takes as arguments   \n24 both a task $s \\in S$ and an input $x \\in X$ , typically box-constrained continuous variables, and returns a   \n25 noisy scalar performance ",
+        "bbox": [
+            147,
+            613,
+            825,
+            738
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "equation",
+        "img_path": "images/73e851ea3d20cb49bf61a242be5cc83dbd1bcc69147c784d4b3ed735743c6ff8.jpg",
+        "text": "$$\nf ( s , x ) : S \\times X \\to \\mathbb { R } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            423,
+            737,
+            575,
+            753
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "26 At each iteration an algorithm determines both task and input $( s , x )$ then observes performance   \n27 $y = f ( s , x )$ and the goal is to learn the input with highest average performance for each task ",
+        "bbox": [
+            148,
+            757,
+            823,
+            785
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7b79bac2be9b4e417de5cc5c3591f699f2c3e6801b5a58c0ae57424e2557b9f8.jpg",
+        "text": "$$\nx ^ { * } ( s ) = \\arg \\operatorname* { m a x } _ { x } \\mathbb { E } [ f ( s , x ) ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            401,
+            791,
+            596,
+            816
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "28 $x ^ { * } ( s )$ is referred to as the optima conditioned on $s$ , see Figure 1 black line. In certain applications,   \n29 one may want to give higher priority to particular tasks hence a task weighting function $W ( s )$ may   \n30 also be specified. In this work we consider the following applications.   \n31 CNN hyperparameters: the CIFAR-10 dataset contains 10 classes, this is split into five mutually   \n32 exclusive binary classification datasets and for each we train a CNN, each CNN is a task in $S =$   \n33 $\\{ 1 , . . . , 5 \\}$ . For each CNN, we optimize dropout rates, batch size and Adam parameters, so $X \\subset \\mathbb { R } ^ { 7 }$   \n4 and $f ( s , x )$ is the validation accuracy. We assume all five CNNs have equal priority, $W ( s ) = 1 / 5$ .   \n35 Ambulances in a square: [5] given a range of   \n36 $3 0 \\mathrm { k m } \\times 3 0 \\mathrm { k m }$ cities, each city is a task with a   \n37 different population centre $\\dot { s } \\in [ 0 , 3 0 ] ^ { 2 }$ . For   \n38 a given city, we optimize the 2D location of   \n39 three ambulance bases, $x \\in [ 0 , 3 0 ] ^ { 3 \\times 2 } \\subset \\mathbb { R } ^ { 6 }$ .   \n40 Given a city $s$ and ambulance bases $x$ , a vir  \n41 tual environment randomly generates patients   \n42 for a simulated day and the average ambulance   \n43 journey time, $f ( s , x )$ , is returned. Inland cities,   \n44 like Paris or London, with population centres   \n45 in the middle are more common than coastal   \n46 cities, like Singapore or Dubai, with a popula  \n47 tion centre on a boundary. Thus, $W ( s )$ mirrors   \n48 this distribution of city centres, a Gaussian cen  \n49 tred at $s = ( 1 5 , 1 5 )$ with $7 \\mathrm { k m }$ standard deviation   \n50 and truncated to $[ 0 , 3 0 ] ^ { 2 }$ .   \n51 Assemble to order: [6, 7] a company owns   \n52 many stock warehouses and each one faces a   \n53 different level of demand $s \\in [ 0 . 5 , 1 . 5 ]$ . Equal   \n54 priority is given to all warehouses and so $W ( s )$   \n55 is uniform. At each warehouse, stock levels are   \n56 controlled by setting targets of a control pol  \n57 icy $x = [ 0 , \\dot { 2 } 0 ] ^ { 8 }$ . Given a demand level $s$ and   \n58 control parameters $x$ , a simulator generates cus  \n59 tomer orders according to demand, the ware",
+        "bbox": [
+            147,
+            824,
+            826,
+            867
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            872,
+            826,
+            901
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            156,
+            90,
+            825,
+            119
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            150,
+            127,
+            486,
+            347
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            148,
+            353,
+            485,
+            477
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/303db05f44ad7878365f95c85f17cf1431f40372fc7008a7e0445e40355d1cf4.jpg",
+        "image_caption": [
+            "Figure 1: Top: GP model. Each task (vertical slice) is an objective function to maximise. A new sample $( s , x ) ^ { \\searrow n + 1 }$ provides information about the optima of similar tasks. Bottom: the acquisition function value of each task using hybrid Knowledge Gradient. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            498,
+            142,
+            789,
+            359
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "house stock is sold and replenished according to policy $x$ , and profit over a simulated month is returned as $f ( s , x )$ . ",
+        "bbox": [
+            160,
+            477,
+            825,
+            506
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "62 The closely related multi-task Bayesian optimisation or Bayesian Quadrature optimisation methods   \n63 [8, 9, 10, 11] aim to find a single peak that maximises the weighted sum/integral over tasks, $x ^ { * } =$   \n64 arg $\\begin{array} { r } { \\operatorname* { m a x } _ { x } \\int \\mathbb { E } [ f ( s , x ) ] W ( s ) d s } \\end{array}$ . However, as they are fundamentally designed for a different purpose,   \n65 we observe that they struggle to find the peak of each and every task, see experiments in Supplementary   \n66 Material 6 (SM 6).   \n67 Also closely related are contextual optimization algorithms [12, 13, 14], conditional optimization   \n68 has also been referred to as “offline contextual\" [15]. In contextual applications, at iteration $n$ the   \n69 next task (called context) $s ^ { n }$ is passed from the black box to a contextual algorithm that intelligently   \n70 determines $x ^ { n }$ . Then the black box returns both performance $y ^ { n }$ and the next task/context $s ^ { n + 1 }$ . One   \n71 could “hotfix\" a contextual algorithm for conditional optimization problems by randomly choosing   \n72 $s ^ { n + 1 } \\sim \\mathbb { P } [ s ] \\propto W ( s )$ at each iteration. However, we empirically show that, unsurprisingly, randomly   \n73 choosing the task in each iteration is significantly worse than intelligently choosing the task.   \n74 Multi-fidelity and multi-information source methods [16, 17, 18, 19] assume there is a single known   \n75 constant target task $s ^ { * } \\in S$ corresponding to the highest fidelity level or most expensive information   \n76 source that must be optimized, $x ^ { * } = \\arg \\operatorname* { m a x } _ { x } \\mathbb { E } [ f ( s ^ { * } , x ) ]$ . If the cost of evaluation varies across the   \n77 function domain, $c ( s , x )$ , cheaper regions of the domain can be evaluated improving sample efficiency.   \n78 Again, such methods may be hotfixed for the setting we consider by artificially designating a target   \n79 task, e.g. the highest priority task $s ^ { * } = \\arg \\operatorname* { m a x } _ { s } W ( s )$ . However, we observe that if cost is constant   \n80 across the domain (as is commonly assumed in the BO literature), these methods greedily optimise   \n81 the artificial target task $s ^ { * }$ and blindly neglect all other tasks, see SM4. This desirable behaviour in   \n82 multi-fidelity optimization problems leads to failure in conditional optimization problems. ",
+        "bbox": [
+            148,
+            511,
+            825,
+            580
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            587,
+            825,
+            685
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            690,
+            825,
+            815
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To the best of our knowledge, there exist only a small number of works that propose algorithms specifically designed for the conditional setting. ",
+        "bbox": [
+            158,
+            821,
+            823,
+            849
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "85 The Surrogate Collaborative Tuning (SCoT) algorithm [20] optimizes a finite set of tasks. It iteratively   \n86 visits each task, $s$ , in a round-robin fashion and determines the input $x$ by expected improvement (EI).   \n87 The authors apply this to optimize the hyperparameters of an ML model for multiple datasets. The   \n88 Profile Expected Improvement (PEI) and Profile Expected Quantile Improvment (PEQI) algorithms   \n89 [21, 4] consider continuous tasks and significantly improve upon SCoT by dynamically determining   \n90 the task in each iteration. The acquisition value of a given point $( s , x )$ is the expected improvement   \n91 of a new output over the best predicted output within the same task.   \n92 The REVI algorithm [22] at each iteration discretizes both task $S$ and input $X$ spaces. Given a new   \n93 hypothetical point, $( s , x ) ^ { n + 1 }$ , for each task in the discretization, $s _ { i }$ , the discrete Knowledge Gradient   \n94 over the $X$ discretization quantifies how $( s , x ) ^ { n + 1 }$ will benefit task $s _ { i }$ . Summing the benefits over the   \n95 tasks yields the acquisition value of $( s , x ) ^ { n + 1 }$ . REVI was designed to account for how all tasks can be   \n96 optimized by each sample. However, this comes with exponential cost, increasing problem dimension   \n97 leads to exponentially increasing discretization size with corresponding exponential space and time   \n98 requirements. On the other hand, sparse discretizations can lead to poor and arbitrary measures   \n99 of acquisition value. Consequently, REVI has only successfully been applied to low-dimensional   \n100 synthetic problems.   \n101 Most recently, the Multi-task Thompson sampling (MTS) method [15] uses a novel kernel with a   \n102 length scale that varies across tasks. This is combined with a Thompson sampling method for col  \n103 lecting new data and showed performance improvements over REVI. However, Thompson sampling   \n104 also does not account for how one sample provides benefit for optimizing all tasks, a fundamental   \n105 structural property of conditional optimization.   \n106 We propose a method that exploits the basic structure of conditional optimization while also being   \n107 highly scalable, and therefore applicable to more challenging real-world problems. We make the   \n108 following contributions:   \n1. A framework for conditional Bayesian optimization with theoretical guarantees: ConBO.   \n2. A new, fast global optimization method: Hybrid Knowledge Gradient.   \n3. State-of-the-art performance on open source problems including CNNs and simulators. ",
+        "bbox": [
+            147,
+            856,
+            825,
+            898
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            90,
+            825,
+            147
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            143,
+            152,
+            825,
+            279
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            284,
+            825,
+            354
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            143,
+            359,
+            825,
+            401
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            210,
+            412,
+            815,
+            460
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "112 2 The Conditional Bayesian Optimization Algorithm ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            478,
+            629,
+            496
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "113 We first discuss the fitting of the Gaussian process model and the predicted conditional optima. We   \n114 then motivate the acquisition value for a single task and how this is integrated over tasks yielding the   \n115 acquisition function. Because integrating over tasks multiplies the computational burden, we propose   \n116 Hybrid Knowledge Gradient as a solution. See Algorithm 1 in the SM 2 for a high level summary.   \n117 At a stage after having observed $n$ data points, $\\{ ( s ^ { i } , x ^ { i } , y ^ { i } ) \\} _ { i = 1 } ^ { n }$ where $y ^ { i } = f ( s ^ { i } , x ^ { i } )$ , a Gaussian   \n118 process is fit over the joint space $S \\times X$ to scalar outputs $y$ . Let $\\tilde { X } ^ { n } = ( ( s , x ) ^ { 1 } , . . . , ( s , x ) ^ { n } )$ and   \n119 $\\mathbf { \\bar { \\boldsymbol { Y } } } ^ { n } = ( y ^ { 1 } , . . . , y ^ { n } )$ . A Gaussian process is defined by a prior mean and prior covariance function,   \n120 $\\mu ^ { 0 } ( s , x )$ , $k ^ { 0 } ( ( s , x ) , ( s ^ { \\prime } , x ^ { \\prime } ) )$ which are chosen for each application, for more information see [23].   \n121 Let the data covariance matrix be $K = k ^ { 0 } ( \\tilde { X } ^ { n } , \\tilde { X } ^ { n } ) \\in \\mathbb { R } ^ { n \\times n }$ , the posterior mean is given by ",
+        "bbox": [
+            142,
+            510,
+            825,
+            565
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            570,
+            826,
+            647
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/db0be709a00a10a82e987af057508b9578e4309bae83383ff76aa802a5de3a46.jpg",
+        "text": "$$\n\\mu ^ { n } ( s , x ) = \\mu ^ { 0 } ( s , x ) + k ^ { 0 } ( ( s , x ) , \\tilde { X } ^ { n } ) \\big ( K + \\sigma _ { 0 } ^ { 2 } I \\big ) ^ { - 1 } \\big ( Y ^ { n } - \\mu ^ { 0 } ( \\tilde { X } ^ { n } ) \\big )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            272,
+            651,
+            723,
+            675
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "122 and the posterior covariance is given by ",
+        "bbox": [
+            145,
+            679,
+            436,
+            694
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/dcf02681b92726428ac0f610c9d2c187f242b8e795359a44daba7ded31e8e17a.jpg",
+        "text": "$$\nk ^ { n } ( ( s , x ) , ( s ^ { \\prime } , x ^ { \\prime } ) ) = k ^ { 0 } ( ( s , x ) , ( s ^ { \\prime } , x ^ { \\prime } ) ) + k ^ { 0 } ( ( s , x ) , \\tilde { X } ^ { n } ) \\big ( K + \\sigma _ { 0 } ^ { 2 } I \\big ) ^ { - 1 } k ^ { 0 } ( \\tilde { X } ^ { n } , ( s ^ { \\prime } , x ^ { \\prime } ) ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            207,
+            699,
+            789,
+            722
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "123 At the end of data collection, in standard BO, often the peak posterior mean is returned as the   \n124 predicted best input. Generalizing to the conditional setting we simply condition on $s$ , ",
+        "bbox": [
+            142,
+            726,
+            825,
+            755
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b533a37627c7113f491e8e5cd4fc73549d1861b9c0249a1ec6389c3c774f99b7.jpg",
+        "text": "$$\nx ^ { * N } ( s ) = \\underset { x } { \\mathrm { a r g m a x } } \\mu ^ { N } ( s , x ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            400,
+            760,
+            598,
+            786
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "125 During data collection, a new data point $y ^ { n + 1 }$ at $( s , x ) ^ { n + 1 }$ will update the Gaussian process over the   \n126 whole domain $S \\times X$ . To construct an acquisition function for conditional optimization, we start   \n127 by looking for standard acquisition functions that account for how the model changes at unsampled   \n128 locations $\\mathbf { \\bar { \\Phi } } ( s ^ { \\prime } , x ^ { \\prime } ) \\neq ( s , x ) ^ { n + 1 }$ . Specifically, the popular Expected improvement (EI) [24] and upper   \n129 confidence bound (UCB) [25] methods are both functions of the mean and kernel at the sampled point   \n130 only, i.e. of $( \\mu ^ { n } ( ( s , x ) ^ { n + 1 } )$ , $k ^ { n } ( ( s , x ) ^ { n + 1 } , ( s , x ) ^ { n + 1 } ) \\big )$ , hence would require non-trivial modification   \n131 to be able to account for how a sample affects similar tasks. Methods that do utilise the mean and   \n132 kernel at unsampled points include Entropy search (ES [26, 27] and PES [28]) that measures the   \n133 mutual information between the new output $\\mathbb { P } [ y ^ { n + 1 } | x ^ { n + 1 } ]$ and the (uncertain) location of the peak   \n134 $\\mathbb { P } [ x ^ { * } | { \\tilde { X } } ^ { n } , Y ^ { n } ]$ , Max-value entropy search (MES) [29] that measures mutual information between   \n135 the new output $\\mathbb { P } [ y ^ { n + 1 } | x ^ { n + 1 } ]$ and the (uncertain) largest output $\\mathbb { P } [ \\operatorname* { m a x } y | \\tilde { X } ^ { n } , Y ^ { n } ]$ , and Knowledge   \n136 Gradient (KG) [30] that measures the expected peak of the new posterior mean $\\mathbb { E } [ \\operatorname* { m a x } \\mu ^ { n + 1 } ( \\breve { x } ) ]$   \n137 caused by a new yn+1 at xn+1 .   \n138 Each single task $s$ defines a single global optimization problem over $x \\in X$ . Given a proposed   \n139 sample $( { \\bar { s } } , x ) ^ { n + 1 } = ( s ^ { n + 1 } , x ^ { n + 1 } )$ , the acquisition benefit for task $s$ may be computed using ES, PES,   \n140 MES or KG. In this work we adopt KG for its Bayesian decision theoretic derivation that extends   \n141 seamlessly to the conditional setting. For KG, the benefit for a given task is the expected increase in   \n142 peak predicted performance within the task. We denote the task-conditioned KG as ",
+        "bbox": [
+            140,
+            799,
+            825,
+            912
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/3e4a18929624b6e8451a395ae19c2c9a9ecd7b4f945ce90815c5d43073617386.jpg",
+        "image_caption": [
+            "Figure 2: Methods for computing $\\mathrm { K G } ( x ^ { n + 1 } )$ at $x ^ { n + 1 } = 7$ . Left: $\\mu ^ { n } ( x )$ and samples of $\\mu ^ { n + 1 } ( x )$ determined by a scalar $Z \\sim N ( 0 , 1 )$ . Centre-left: ${ \\mathrm { K G } } _ { d }$ replaces $X$ with up to 3000 points $x _ { i } \\in X _ { d }$ and $\\mu ^ { n + 1 } ( x _ { i } )$ is linear in $Z$ . Centre-right: ${ \\mathrm { K G } } _ { M C }$ samples up to 1000 functions $\\mu ^ { n + 1 } ( x )$ functions and maximises each of them numerically. Right: ${ \\mathrm { K G } } _ { h }$ samples up to 5 functions $\\dot { \\mu } ^ { n + 1 } ( x )$ and maximizes them numerically, the arg max points $x _ { 1 } ^ { * } , . . , x _ { 5 } ^ { * }$ are used as $X _ { d }$ in $\\operatorname { K G } _ { d }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            88,
+            818,
+            195
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            287,
+            825,
+            363
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            368,
+            825,
+            438
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/176a0a32da820bf0d9b7aa43b0f314b7238642a39fe62bc1621ecab4416bb13c.jpg",
+        "text": "$$\n\\mathrm { K G } _ { c } ( s ; ( s , x ) ^ { n + 1 } ) = \\mathbb { E } _ { y ^ { n + 1 } } [ \\operatorname* { m a x } _ { x ^ { \\prime } } \\mu ^ { n + 1 } ( s , x ^ { \\prime } ) | ( s , x ) ^ { n + 1 } ] - \\operatorname* { m a x } _ { x ^ { \\prime \\prime } } \\mu ^ { n } ( s , x ^ { \\prime \\prime } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            251,
+            441,
+            745,
+            467
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "143 We discuss numerical evaluation of $\\operatorname { K G } _ { c } ( \\cdot )$ in Section 2.1. Similar expressions for conditioned   \n144 entropy methods, $\\mathrm { E S } _ { c } ( \\cdot ) , \\mathrm { P E S } _ { c } ( \\cdot ) , \\mathrm { M E S } _ { c } ( \\cdot ) .$ , are derived in SM 7. Integrating over all tasks $s$ yields   \n145 the total acquisition value ",
+        "bbox": [
+            142,
+            472,
+            825,
+            515
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7d585f2e450421066e1d2371e217073b6a6efc828d0a4c724afe8a3fc411f0d2.jpg",
+        "text": "$$\n\\int _ { S } { \\bf K } { \\bf G } _ { c } ( s ; ( s , x ) ^ { n + 1 } ) W ( s ) d s .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            397,
+            518,
+            601,
+            553
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "146 For discrete $S$ the integral is replaced by summation. For continuous $S$ , the integral over tasks $s$   \n147 cannot be computed analytically so we use Monte Carlo with importance sampling. When using   \n148 a kernel that factorises $\\bar { k ( s , x , s ^ { \\prime } , x ^ { \\prime } ) } = \\sigma _ { 0 } ^ { 2 } k _ { S } ( s , s ^ { \\prime } ) k _ { X } ( x , x ^ { \\prime } )$ , like squared exponential or Matérn,   \n149 similarity across tasks is encoded in $k _ { S } ( s , s ^ { \\prime } )$ . This naturally leads to the proposal distribution   \n150 $q ( s | s ^ { n + \\bar { 1 } } ) \\propto k _ { S } ( s , s ^ { n + 1 } )$ . In our continuous task experiments, we use the Matérn kernel and a   \n151 Gaussian proposal distribution with mean $s ^ { n + 1 }$ and the task kernel length scales, $l _ { s }$ , as standard   \n152 deviations, ",
+        "bbox": [
+            140,
+            556,
+            825,
+            654
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c938f471ff7cb53791814cba364af9877f9dbf811e35a84af72119f78c1299d7.jpg",
+        "text": "$$\nq ( s | s ^ { n + 1 } ) \\sim \\mathcal { N } ( s | s ^ { n + 1 } , \\mathrm { d i a g } ( l _ { s } ^ { 2 } ) ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            383,
+            651,
+            612,
+            669
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "153 We generate $n _ { s } = 2 0$ samples $\\boldsymbol { S _ { M C } } = \\{ s _ { 1 } , . . . , s _ { n _ { s } } \\}$ , finally the acquisition function is ",
+        "bbox": [
+            138,
+            671,
+            736,
+            688
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8918ca1b03c7e7a775528e5ae7191b65103e4bb3f79693f953068d45a425b41f.jpg",
+        "text": "$$\n\\mathrm { C o n B O } ( s ^ { n + 1 } , x ^ { n + 1 } ) = \\sum _ { s _ { i } \\in S _ { M C } } \\frac { W ( s _ { i } ) } { q ( s _ { i } | s ^ { n + 1 } ) } \\mathrm { K G } _ { c } ( s _ { i } ; ( s , x ) ^ { n + 1 } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            287,
+            690,
+            709,
+            731
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "154 Figure 1 shows a set of sampled tasks and the $\\mathrm { K G } _ { c } ( \\cdot )$ for each one. Each KG term directly measures   \n155 increase in predicted performance for one task, e.g. if $y$ values are dollar amounts, ConBO with   \n156 $\\mathrm { K G } _ { c } ( \\cdot )$ is the sum of dollar increases over all tasks. However, for entropy based methods, ConBO   \n157 becomes a sum of Shannon information units thereby indirectly optimizing the dollar amounts.   \n158 The randomly sampled tasks $S _ { M C }$ may be resampled with each call to $\\mathbf { C o n B O } ( s , x )$ and gradients   \n159 estimated enabling the optimal $( s , x ) ^ { n + 1 }$ to be found with a stochastic gradient ascent optimizer such   \n160 as Adam [31]. Selecting each point according to maximising ConBO is also myopically optimal in a   \n161 value of information framework: ",
+        "bbox": [
+            140,
+            736,
+            825,
+            848
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Theorem 1 Let $( s ^ { * } , x ^ { * } ) \\in \\arg \\operatorname* { m a x } C o n B O ( s , x )$ be a point chosen for sampling. $( s ^ { * } , x ^ { * } )$ is also the point that maximises the myopic Value of Information, the increase in predicted performance. ",
+        "bbox": [
+            161,
+            857,
+            823,
+            887
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "164 Further, in finite search space, with an infinite sampling budget all points will be sampled infinitely: ",
+        "bbox": [
+            147,
+            896,
+            823,
+            912
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/548afe28f7cb00a2dd4ecb0271bed08e098386146045aaa907667d1d3e6bb60e.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">Algorithm 1 Computing ConBO(s,x). For each call with a candidate (task, input) point, similar tasks are sampled.For each sampled task a cheap acquisition function, hybrid KG, is evaluated. The output is the importance weighted average of hybrid KG values. Details and full numerical expressions are given in SM 3.</td></tr><tr><td colspan=\"2\">Require: candidate point (s,x)n+1, parameters ns, nz Sample ng tasks similar to gn+1, SMc ~ q(s|sn+1) Initialize output value Q ← 0 parfor si in SMc do InitializeX*←0</td></tr><tr><td>parfor j i ,...,nz do zj←Φ-1((2j-1)/2nz) computed with (s,x)n+1 and zj 3 x ← arg maxx μ+1(si,x) with Optimizer() X←X*U(si,x） end parfor</td><td>Hybrid Knowledge Gradient</td></tr><tr><td colspan=\"2\">αi ←KGd(X*) Q ← Q+αi W(si)/q(si|sn+1) end parfor</td></tr></table>",
+        "bbox": [
+            171,
+            90,
+            830,
+            409
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "165 Theorem 2 Let $S$ and $X$ be finite sets and $N$ the budget to be sequentially allocated by ConBO.   \n166 Let $n ( s , x , N )$ be the number of samples allocated to a point $( s , x )$ within budget $N$ . Then for all   \n167 $( s , x ) \\in S \\times X$ we have that $\\begin{array} { r } { \\operatorname* { l i m } _ { N \\to \\infty } n ( s , x , N ) = \\infty } \\end{array}$ . ",
+        "bbox": [
+            142,
+            435,
+            825,
+            479
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The law of large numbers ensures that the algorithm learns the true expected performance for all points. Proofs are given in the SM 1. ",
+        "bbox": [
+            160,
+            489,
+            825,
+            518
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "170 2.1 Hybrid Knowledge Gradient ",
+        "text_level": 1,
+        "bbox": [
+            151,
+            536,
+            413,
+            553
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "171 By definition, KG is more expensive than EI and UCB. Further, the function $\\operatorname { K G } _ { c } ( s _ { i } , ( s , x ) ^ { n + 1 } )$   \n172 must be computed once for each sampled task $s _ { i }$ , the computational cost is therefore $n _ { s }$ times the   \n173 global acquisition function equivalent. To alleviate this cost, we propose a novel, efficient algorithm   \n174 for computing KG. In the following section we assume constant $s$ for brevity, reducing to the   \n175 global optimization setting. Given a hypothetical location $x ^ { n + 1 }$ , KG quantifies the value of a new   \n176 hypothetical observation $y ^ { \\bar { n } + 1 }$ by the expected increase in the peak of the posterior mean ",
+        "bbox": [
+            140,
+            563,
+            826,
+            647
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ec4035d60174e7742bd5a1af508079c81ff69c0a0661cc6c72bb08832155ac5f.jpg",
+        "text": "$$\n\\operatorname { K G } ( x ^ { n + 1 } ) = \\mathbb { E } _ { y ^ { n + 1 } } \\big [ \\operatorname* { m a x } _ { x ^ { \\prime } } \\mu ^ { n + 1 } ( x ^ { \\prime } ) \\big | x ^ { n + 1 } \\big ] - \\operatorname* { m a x } _ { x ^ { \\prime \\prime } } \\mu ^ { n } ( x ^ { \\prime \\prime } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            302,
+            654,
+            696,
+            678
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "177 However, $\\operatorname* { m a x } _ { x ^ { \\prime } } \\mu ^ { n + 1 } ( x ^ { \\prime } )$ has no explicit formula and approximations are required which we describe   \n178 next. At time $n$ , the next posterior mean is unknown, however, it may be written as $\\mu ^ { n + 1 } ( x ) =$   \n179 $\\mu ^ { n } ( x ) + \\tilde { \\sigma } ( x ; x ^ { n + 1 } ) Z$ where $\\tilde { \\sigma } ( x ; x ^ { n + 1 } )$ is a deterministic function and the scalar $Z \\sim \\mathcal { N } ( 0 , 1 )$   \n180 captures the randomness of $y ^ { n + 1 }$ , see SM 2. Previously, $\\operatorname { K G } ( x )$ has been computed in two ways. ",
+        "bbox": [
+            142,
+            688,
+            826,
+            744
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "KG by discretization [30, 32]: in Equation 6, the maximizations may be performed over a discrete set of $d$ points $X _ { d } \\subset X$ . Denoting $\\underline { { \\mu } } ^ { \\mathsf { ^ { \\prime } } } = \\mu ^ { n } ( X _ { d } ) \\in \\mathbb { R } ^ { d }$ and $\\underline { { \\tilde { \\sigma } } } ( x ^ { n + 1 } ) \\overset { \\bullet } { = } \\tilde { \\sigma } ( \\mathbf { \\tilde { X } } _ { d } ; x ^ { n + 1 } ) \\in \\mathbb { R } ^ { d }$ , then ",
+        "bbox": [
+            171,
+            750,
+            823,
+            780
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/05a90e5f28160eadde2703d36d7a8c1fd17aeff1402b519665050677bef0cff4.jpg",
+        "text": "$$\n\\mathrm { K G } _ { d } ( x ^ { n + 1 } ) = \\mathbb { E } _ { Z } \\left[ \\operatorname* { m a x } \\{ \\underline { { \\mu } } + \\underline { { \\tilde { \\sigma } } } ( x ^ { n + 1 } ) Z \\} \\right] - \\operatorname* { m a x } \\underline { { \\mu } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            320,
+            789,
+            676,
+            810
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "181 The $\\operatorname* { m a x } \\{ \\underline { { \\mu } } + \\tilde { \\underline { { \\sigma } } } ( x ^ { n + 1 } ) Z \\}$ is a piece-wise linear function of $Z$ and the expectation is analytically   \n182 tractable. The output is a lower bound of the true $\\operatorname { K G } ( x )$ . REVI [22] and the MiSo algorithm   \n183 [17] used ${ \\mathrm { K G } } _ { d }$ with 3000 uniformly random distributed points. This method suffers the curse of   \n184 dimensionality as $X _ { d }$ must grow exponentially with dimension. Further, the discretization may likely   \n185 contain many useless points in uneventful regions of $X$ , see Figure 2 centre-left plot. ",
+        "bbox": [
+            140,
+            818,
+            825,
+            891
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/e776ab6721a6f72e275f2d53cf6b3e70120c3114f7739b3f85f5bdb9a51b9436.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>KG</td><td>Type of Estimate</td><td>nz=3</td><td>nz=5</td><td>nz=7</td><td>nz= 50</td></tr><tr><td>Discrete</td><td>lower bound</td><td>0.24 (1.37)</td><td>0.41 (1.49)</td><td>0.55 (1.91)</td><td>2.03 (2.2)</td></tr><tr><td>MC</td><td>unbiased</td><td>3.54 (4.79)</td><td>3.73 (4.51)</td><td>3.50 (3.39)</td><td>3.36 (1.18)</td></tr><tr><td>MC++</td><td>unbiased</td><td>2.97 (3.78)</td><td>3.50 (2.68)</td><td>3.22 (1.69)</td><td>3.32 (0.2)</td></tr><tr><td>Hybrid</td><td>lower bound</td><td>3.15 (0.00)</td><td>3.28 (0.00)</td><td>3.31 (0.00)</td><td>3.34 (0.00)</td></tr></table>",
+        "bbox": [
+            209,
+            88,
+            784,
+            174
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 1: We collect 20 points on the Rosenbrock function, a point was randomly selected and KG computed by the different methods. Each calculation is repeated 50 times and we report mean and two standard deviations. The Monte Carlo methods suffer from high variance, the discrete method is volatile and returns a very loose lower bound. Hybrid KG is very stable with errors too small to show. ",
+        "bbox": [
+            173,
+            189,
+            826,
+            246
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "187 KG by Monte Carlo [33, 34]: given $x ^ { n + 1 }$ , the method samples up to $n _ { z } = 1 0 0 0$ Gaussian values   \n188 of $Z$ . For each $Z _ { j }$ , construct the posterior mean, $\\mu _ { j } ^ { n + 1 } ( x )$ , find the maximum with a continuous   \n189 numerical Optimizer() like L-BFGS or CG. Averaging the maxima from all $Z _ { j }$ yields ",
+        "bbox": [
+            142,
+            260,
+            825,
+            308
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4fbef515f13bc68bedd16ab4bbed35cfa4c8cb7966f5fe4a8a2f498c7badbe77.jpg",
+        "text": "$$\n\\mathrm { K G } _ { M C } ( x ^ { n + 1 } ) = \\frac { 1 } { n _ { s } } \\sum _ { j } \\mathbb { O } \\mathrm { p t i } \\underset { x ^ { \\prime } } { \\mathrm { i m i } } z \\mathrm { e r } \\left( \\mu _ { j } ^ { n + 1 } ( x ) \\right) - \\mathbb { O } \\mathrm { p t i } \\underset { x ^ { \\prime \\prime } } { \\mathrm { i m i } } z \\mathrm { e r } \\left( \\mu ^ { n } ( x ^ { \\prime \\prime } ) \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            254,
+            311,
+            741,
+            352
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "190 The result is an unbiased estimate of true $\\operatorname { K G } ( x )$ and scales better to higher dimensional $X$ , the   \n191 univariate $Z$ is discretized by Monte Carlo samples instead of $X$ . However, for a good estimate, $n _ { z }$   \n192 must be large, many Optimizer() calls are required. See Figure 2 centre right.   \n193 We instead propose a simple mixture of the two approaches above that both scales to higher dimen  \n194 sional $X$ and drastically reduces the number of Optimizer() calls. ",
+        "bbox": [
+            140,
+            363,
+            825,
+            406
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            411,
+            825,
+            441
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Hybrid KG: given $x ^ { n + 1 }$ , following ${ \\mathrm { K G } } _ { M C }$ we use $n _ { z } = 5$ values of $Z _ { j }$ , construct $\\mu _ { j } ^ { n + 1 } ( x )$ and use Optimizer() to find the peak location $\\boldsymbol { x } _ { i } ^ { * }$ . The set of peak locations $X _ { d } ^ { * } = \\{ x _ { 1 } ^ { * } , . . . , x _ { n _ { z } } ^ { * } \\}$ is used as a dynamic optimized discretization in $\\check { \\mathsf { K G } } _ { d }$ thus analytically computing an extremely tight lower bound of the true $\\operatorname { K G } ( x )$ . Let $\\underline { { \\mu } } ^ { * } = \\mu ^ { n } ( X _ { d } ^ { * } )$ and similarly for $\\tilde { \\sigma } ^ { * } ( x ^ { n + 1 } )$ , Hybrid KG is given by ",
+        "bbox": [
+            173,
+            446,
+            825,
+            507
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/372f0db6bae4bc41d4a8b74a30239d2deb409a0bb4b78b27a7eba5a392b512eb.jpg",
+        "text": "$$\n\\mathrm { K G } _ { h } ( x ^ { n + 1 } ) = \\mathbb { E } _ { Z } [ \\operatorname* { m a x } \\underline { { \\mu } } ^ { * } + \\underline { { \\tilde { \\sigma } } } ^ { * } ( x ^ { n + 1 } ) Z ] - \\operatorname* { m a x } \\underline { { \\mu } } ^ { * } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            320,
+            513,
+            678,
+            534
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "195 Compared to $\\operatorname { K G } _ { d }$ , the hybrid method removes redundant points in the discretization $X _ { d }$ , all $X _ { d } ^ { * }$   \n196 points contribute to max $\\mu ^ { n + 1 } ( X _ { d } ^ { * } )$ and there are far fewer points. Compared to ${ \\mathrm { K G } } _ { M C }$ that samples   \n197 many $Z _ { j }$ and optimizes many $\\boldsymbol { x } _ { j } ^ { * }$ , Hybrid KG uses far fewer $Z _ { j }$ and optimizes far fewer $\\boldsymbol { x } _ { j } ^ { * }$ . See   \n198 Algorithm 1 for a summary of evaluating ConBO with Hybrid KG. ConBO can be reduced to the   \n199 REVI algorithm by replacing the dynamic importance sampled tasks with a pre-frozen discretization   \n200 of tasks and the (dynamic optimized) hybrid KG with discrete KG over a pre-frozen discretization of   \n201 inputs. These changes drastically improve scalability enabling ConBO to be applied to a far broader   \n202 range of applications.   \n203 To ensure asymptotic convergence, in a discrete domain, we require that the acquisition function   \n204 is non-negative, $\\mathrm { K G } _ { h } ( x ) \\geq { \\mathit { \\bar { 0 } } }$ , and the acquisition function is zero where GP variance is zero,   \n205 ${ \\bf K G } _ { h } ( x ) = 0 \\iff k ^ { n } ( x , x ) = 0$ . Therefore, always choosing $x ^ { n + 1 } = \\arg \\operatorname* { m a x } \\mathbf { K } \\mathbf { G } _ { h } ( x )$ ensures   \n206 only points with GP variance will be revisited until all points have no variance i.e. the true function is   \n207 known for all points. We can ensure these properties by setting $n _ { z } \\geq 2$ and at least one $Z _ { j }$ is equal to   \n208 zero. ",
+        "bbox": [
+            140,
+            536,
+            825,
+            650
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            656,
+            825,
+            739
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Theorem 3 Let $n _ { z } \\geq 2$ and let $\\underline { { Z } } = \\{ Z _ { j } | j = 1 , . . . , n _ { z } \\} .$ . If $0 \\in \\underline { { Z } }$ then $K G _ { h } ( x ) \\ge 0$ for all $x \\in X$ and if $x$ is sampled infinitely often $K G _ { h } ( x ) = 0$ . ",
+        "bbox": [
+            166,
+            750,
+            821,
+            780
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Proof is in the SM 1. The $Z _ { j }$ values can be fixed, for $n _ { z } = 5$ we use equal Gaussian quantiles $\\underline { { Z } } = \\{ \\Phi ^ { - 1 } ( 0 . 1 ) , \\Phi ^ { - 1 } ( 0 . 3 ) , \\ldots , \\Phi ^ { - 1 } ( 0 . 9 ) \\}$ where $\\Phi ( \\cdot )$ is the Gaussian CDF. Using quantile spacing and odd $n _ { z }$ ensures $Z _ { j } = \\Phi ^ { - 1 } ( 0 . 5 ) = 0$ is included which satisfies the assumptions of asymptotic convergence. See Fig.2 (right). ",
+        "bbox": [
+            171,
+            789,
+            825,
+            851
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The computational complexity of a single call to ConBO requires the posterior variance $( O ( n ^ { 2 } ) )$ and $n _ { s } n _ { z }$ runs of Optimizer(). Let $n _ { c a l l s }$ be the number of times that Optimizer() calls the posterior mean costing $O ( n )$ . Thus, ConBO total complexity is $O ( n ^ { 2 } + n n _ { c a l l s } n _ { s } n _ { z } )$ . Note this is linear in $n _ { s } n _ { z }$ , the size of the (small) dynamic optimal discretization over $S \\times X$ . Thompson sampling with ",
+        "bbox": [
+            160,
+            854,
+            825,
+            912
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/6b231524753c9d2579d81150e39a26e287244085ac1ab47829b5b86b5ec7a49e.jpg",
+        "image_caption": [
+            "Figure 3: Opportunity Cost across a range of synthetic test problems. The dummy baseline, KNN, is worst in all cases, policy gradient is better however the Gaussian process based methods all perform better. UNI and EI are not conditional algorithms yet outperform PEQI. Amongst other conditional algorihtms, MTS, REVI and ConBO methods all perform significantly better. ConBO-3 is outperformed by ConBO-5 demonstrating the improvement with more accurate ${ \\mathrm { K G } } _ { h }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            87,
+            826,
+            189
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "219 discretization uses one operation that scales cubically as $O ( n ^ { 2 } ( n _ { s } n _ { z } ) + n ( n _ { s } n _ { z } ) ^ { 2 } + ( n _ { s } n _ { z } ) ^ { 3 } )$ in   \n220 the worst case and to reduce cost special techniques are required e.g. Fourier features, CG matrix   \n221 inversion. ",
+        "bbox": [
+            143,
+            279,
+            825,
+            321
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "222 3 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            143,
+            345,
+            312,
+            363
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We consider synthetic benchmarks and the three applications described in Section 1. In SM 4 we also present parallelization batch sampling results, and experiments with contextual, multi-task and multi-fidelity methods in SM 6. We also briefly test Hybrid KG for global optimization, SM 5, and observe that ${ \\mathrm { K G } } _ { M C }$ performs worse in the same computation time hence we exclude ${ \\mathrm { K G } } _ { M C }$ methods from the conditional experiments. For each benchmark, for evaluation, held out test tasks are sampled from $\\mathbb { P } [ s ] \\propto W ( s )$ , for each test task, $s _ { i } ^ { t e s t }$ , the predicted optimal input is computed, $x ^ { * } ( s _ { i } ^ { t e s t } )$ and we report the true black box output averaged over all test tasks, see SM 3 for details. ",
+        "bbox": [
+            161,
+            381,
+            825,
+            478
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "230 3.1 How Accurate is Hybrid Knowledge Gradient? ",
+        "text_level": 1,
+        "bbox": [
+            142,
+            500,
+            539,
+            513
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The theoretical Knowledge Gradient cannot be analytically computed and must be approximated (similarly, entropy based methods are not fully tractable). To illustrate the quality of the approximations, we collected 20 points from the Rosenbrock test function and fit a Gaussian process. Another point was then randomly selected and true KG was estimated by the different methods, keeping the $2 0 + 1$ points fixed and only varying the $n _ { z }$ parameter. Each estimate of KG was recalculated 50 times and Table 1 shows the mean and two standard deviations. Discrete KG results in an extremely loose, volatile bound. The (state of the art) MC method with $n _ { z } = 5 0$ has a run-to-run variance of $\\pm 3 5 \\%$ , variance reduction techniques used in $\\mathbf { M C } { + + }$ (latin hypercube inverse sampling and control variates) can reduce this to $\\pm 6 \\%$ . Hybrid KG with $n _ { z } = 3$ is extremely stable, run-to-run variance is too small to show, and is within the error margins of $\\mathbf { M C } { + + }$ with $n _ { z } = 5 0$ which is $\\sim 1 7 \\times$ more expensive to compute. Increasing $n _ { z }$ tightens the bound, hybrid KG with $n _ { z } = 5$ has $9 8 . 2 \\%$ of the value of $n _ { z } = 5 0$ . As a result, Hybrid KG is much easier to optimize, the Adam optimizer may be used with a much higher learning rate and lower momentum and thus converges much faster. ",
+        "bbox": [
+            173,
+            527,
+            825,
+            707
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "244 As an aside, the recently proposed one-shot KG [34] enhances the optimization of ${ \\mathrm { K G } } _ { M C }$ . By   \n245 freezing the $Z$ values between calls to ${ \\mathrm { K G } } _ { M C }$ thus ${ \\tilde { X } } ^ { * }$ may be reused, this enables joint gradient   \n246 ascent of $( x ^ { n + 1 } , \\tilde { X } ^ { * } )$ . In the global optimization use case (a constant single task) one-shot KG and   \n247 Hybrid KG can be combined. In the conditional setting, the ${ \\tilde { X } } _ { i } ^ { * }$ of past sampled tasks may be saved,   \n248 however each call to ConBO must sample new tasks that are not in the saved history, one-shot KG   \n249 style joint optimization is not possible. In our implementation we utilise caching of ${ \\tilde { X } } _ { i } ^ { * }$ from old   \n250 tasks to heuristically warm start finding ${ \\tilde { X } } _ { i } ^ { * }$ for new tasks, see SM 3. ",
+        "bbox": [
+            143,
+            713,
+            825,
+            820
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.2 Synthetic Functions ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            842,
+            349,
+            856
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "52 We perform low-dimensional toy experiments in an ideal setting as a sanity check where we expect   \n53 all conditional methods to perform similarly. We use the popular Branin-Hoo and Rosenbrock test   \n54 functions in 2D defining the (task, input) domain as displayed in Figure 1. ",
+        "bbox": [
+            156,
+            869,
+            823,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/9385521d4cb702ed5972a88ec10ce8b14c1e39e1302cbcaf93973af158dd7909.jpg",
+        "image_caption": [
+            "Figure 4: Left: validation accuracy. Centre-left: validation accuracy after 50 samples. Centre-right: validation accuracy after 100 samples. Right: algorithm overhead in seconds. After 50 samples, none of the multi-task models outperform the baseline, $\\mathrm { E I } + \\mathrm { T r }$ (dashed line) suggesting all datasets can use similar hyperparameters. For the larger budget 100, all models outperform the baseline by $0 . 1 \\%$ suggesting that for more fine-tuning, each dataset requires different hyperaparameters. In all cases, performing data optimization significantly increases performance. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            169,
+            87,
+            825,
+            215
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Synthetic Functions Using the Rosenbrock and Branin-Hoo functions, we consider a uniform and a triangular task weighting $W ( s )$ . For baselines, we adopt two policy based methods. KNN: (dummy baseline) randomly collect data, $x _ { K N N } ^ { * } ( s )$ takes a task, $s$ , and returns the best input from 10 nearest neighbor tasks. PG: policy gradient, a parametric quadratic policy $x _ { P G } ^ { * } ( s ) = \\pi _ { \\theta } ( s )$ is learnt by maximising observed performance values, each iteration samples a task from $\\mathbb { P } [ s ] \\propto W ( s )$ then $x$ is sampled with an $\\epsilon$ -greedy strategy. For a controlled ablation study, all the BO methods fit the same GP and for evaluation use the same definition of ${ { x } ^ { * N } } ( s )$ (Equation 3), methods only differ by their data acquisition strategy. UNI: random data collection, the most recent conditional methods PEQI, REVI, MTS with all parameters given in SM 3. ConBO- $n _ { z }$ : given $( s , x )$ , 20 tasks are importance sampled, ${ \\mathrm { K G } } _ { h }$ with $n _ { z } = 3 , 5$ points is used. EI: expected improvement that treats $( s , x )$ as inputs to be optimized. ",
+        "bbox": [
+            168,
+            330,
+            825,
+            483
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Results are shown in Figure 3. Policy based methods KNN and PG consistently perform worse than the Gaussian process methods. Surprisingly, the conditional BO algorithm PEQI performs similarly to UNI and much worse than EI. All other conditional methods outperform all non-conditional methods. ",
+        "bbox": [
+            168,
+            489,
+            823,
+            532
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "3.3 CNN Training Hyperparameters ",
+        "text_level": 1,
+        "bbox": [
+            166,
+            547,
+            441,
+            564
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "270 We apply MTS, REVI, and ConBO variants, and we adopt the recently proposed kernel used for BO   \n271 with Common Random Numbers [35], ",
+        "bbox": [
+            147,
+            573,
+            826,
+            602
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/36688361b23bd08f3b36ddf40b73b13c79f778436307ca94a5d1dcad9be82902.jpg",
+        "text": "$$\nk ( ( s , x ) , ( s ^ { \\prime } , x ^ { \\prime } ) ) = \\sigma _ { 0 } ^ { 2 } M ( x , x ^ { \\prime } ; \\underline { { { l } } } ) + \\delta _ { s ^ { \\prime } s } ( \\sigma _ { 1 } ^ { 2 } M ( x , x ^ { \\prime } ; \\underline { { { l } } } ) + \\sigma _ { 3 } ^ { 2 } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            289,
+            607,
+            707,
+            626
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "272 where $M ( x , x ^ { \\prime } ; \\underline { { l } } )$ is a Matérn $\\frac { 5 } { 2 }$ kernel with length scales $l$ . The first term models a common trend   \n273 function across all tasks and the second term models how each task independently differs from the   \n274 trend. The differences are composed of another Matérn and the constant kernel to model a global   \n275 offset e.g. one dataset may have universally higher validation accuracy. This kernel has far fewer   \n276 parameters than a full multi-task product kernel, it is easy to fit and scales to an arbitrary number of   \n277 tasks (or datasets) without adding extra parameters.   \n278 In this problem setting, learning hyperparameters over similar datasets, one may expect that the   \n279 optimal hyperparameters would be the same for all datasets. Therefore, as a baseline we apply EI   \n280 to learn the hyperparameters of the first dataset (task 1). We then evaluate the objective function   \n281 (validation accuracy) on the rest of the datasets using the best observed hyperparameters from dataset   \n282 1, we refer to this as $\\mathbf { E I + }$ Transfer. ",
+        "bbox": [
+            140,
+            633,
+            825,
+            719
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            724,
+            825,
+            794
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Argument Optimization versus Data Optimization In continuous task settings, it is not possible to evaluate every task. In discrete task settings with large sampling budgets $N \\gg | S |$ , a user may desire a single high (although stochastic) output value, max $y$ , for every task. For example, in network hyperparameter optimization, the network with the best validation error, $\\operatorname { m a x } y$ , will be deployed (and the hyperparameters $x$ may or may not be reused). We refer to this is data optimization (DO). For simulated environments, the input (or “action\") that generalizes providing the best long-term average performance, $\\operatorname* { m a x } _ { x } \\mathbb { E } [ f ( s , x ) ]$ , is deployed and we refer to this is argument optimization (AO). Past work [22] has shown that argument optimization finds inputs that generalize better but ",
+        "bbox": [
+            171,
+            800,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/bb7082c7937c6daaeb0b0adc8d411d4d577c7cd7566be3c09e6d35929ac64a61.jpg",
+        "image_caption": [
+            "Figure 5: Left: average journey times across a range of cities. Right $:$ average profit across a range of warehouses. ConBO-5 and EI perform best on these benchmarks. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            87,
+            821,
+            253
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "291 may not provide optimal max $y$ for all tasks during the optimization run. The authors propose a “DO   \n292 trick”, use an AO method for $N - | S |$ iterations, then finally allocate one sample per task with input,   \n293 $x ^ { n + 1 }$ , determined by EI within the task. We apply this trick to all algorithms in this experiment. ",
+        "bbox": [
+            147,
+            301,
+            826,
+            343
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Results are shown in Figure 4. For the medium budget of 50 samples, ConBO performs best of the standard algorithms yet it is still worse than the $\\mathrm { E I + T r }$ baseline. Applying the final round of DO improves all results to match the baseline. For the large budget of 100 samples, all methods outperform the baseline suggesting dataset specific fine-tuning of hyperparameters is required to achieve best results. Again, DO provides a significant boost to performance for all methods. ",
+        "bbox": [
+            174,
+            349,
+            825,
+            419
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Gaussian process kernel parameter learning required approximately 2–5 seconds using Tensorflow. In Figure 4 (right) we show the runtime of each algorithm excluding model fitting and network training, purely acquisition function optimization time. MTS and ConBO-3 are quickest while Conbo-5 increases linearly over ConBO-3 and REVI takes much longer. ",
+        "bbox": [
+            169,
+            425,
+            825,
+            481
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "3.4 Ambulances and Warehouses ",
+        "text_level": 1,
+        "bbox": [
+            161,
+            497,
+            416,
+            512
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We apply all methods from Section 3.2 to two benchmarks from the www.SimOpt.org library for simulation optimization problems. The ambulance problem (AMB) is 8-dimensional and consists of a range of cities and one must optimize ambulance locations for each city. The Assemble-to-order problem (ATO) is 9-dimensional consisting of a range of warehouses and one must optimize target 8 stock level for each warehouse. Results are shown in Figure 5. Of the policy based methods, PG performs poorly and does not show on the plots whilst KNN performs poorly on AMB and performs well on ATO suggesting that AMB is a more difficult problem. Of the GP based methods, EI performs well for smaller budgets. Although it is not a conditional algorithm we include it to highlight that 2 sometimes the simplest idea can also work. Of the conditional methods, MTS, REVI, and ConBO-3 all perform similarly, either slightly (AMB) or largely (ATO) outperforming UNI. These methods struggle in higher dimensions while ConBO-5 uses a more accurate acquisition function and is the only method that consistently performs well across all problems. We hypothesize that these problems 6 are more difficult than the synthetics and CNN and truly stress test conditional algorithms. ",
+        "bbox": [
+            156,
+            522,
+            825,
+            702
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "317 4 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            143,
+            720,
+            299,
+            738
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Potential Limitations and Broader Impact there are multiple ways in which ConBO may fail, in this work we have not investigated how ConBO or Hybrid KG suffers with poorly learnt Gaussian process hyperparameters. In many applications, a poorly chosen kernel or unoptimized hyperparameters can lead to poor performance and our proposed methods may be more sensitive or more robust to these failures than alternative approaches. We propose a general purpose optimization algorithm and analysis, we do not currently see any immediate societal impact. ",
+        "bbox": [
+            171,
+            752,
+            825,
+            835
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "324 We investigate Conditional Bayesian optimization and propose ConBO. ConBO is designed from   \n325 the ground up to fully exploit the structure of conditional problems, namely that optimizing one task   \n326 helps optimize similar tasks. Hence every point should be collected to maximise the benefit of all   \n327 tasks. However, this can lead to excessive computational cost, particularly in higher dimensions.   \n328 Thus we also propose Hybrid KG that mixes past methods to be both fast and scalable.   \n329 References   \n330 [1] Victor Picheny and David Ginsbourger. A nonstationary space-time gaussian process model for   \n331 partially converged simulations. SIAM/ASA Journal on Uncertainty Quantification, 1(1):57–78,   \n332 2013.   \n333 [2] Shinkyu Jeong, Mitsuhiro Murayama, and Kazuomi Yamamoto. Efficient optimization design   \n334 method using kriging model. Journal of aircraft, 42(2):413–420, 2005.   \n335 [3] Jasper Snoek, Hugo Larochelle, and Ryan P Adams. Practical bayesian optimization of machine   \n336 learning algorithms. In Advances in neural information processing systems, pages 2951–2959,   \n337 2012.   \n338 [4] Diariétou Sambakhé, Lauriane Rouan, Jean-Noël Bacro, and Eric Gozé. Conditional opti  \n339 mization of a noisy function using a kriging metamodel. Journal of Global Optimization,   \n340 73(3):615–636, 2019.   \n341 [5] Naijia Anna Dong, David J Eckman, Xueqi Zhao, Shane G Henderson, and Matthias Poloczek.   \n342 Empirically comparing the finite-time performance of simulation-optimization algorithms. In   \n343 2017 Winter Simulation Conference (WSC), pages 2206–2217. IEEE, 2017.   \n344 [6] Jing Xie, Peter I Frazier, and Stephen E Chick. Bayesian optimization via simulation with   \n345 pairwise sampling and correlated prior beliefs. Operations Research, 64(2):542–559, 2016.   \n346 [7] Matthias Poloczek, Jialei Wang, and Peter I Frazier. Warm starting bayesian optimization. In   \n347 2016 Winter Simulation Conference (WSC), pages 770–781. IEEE, 2016.   \n348 [8] Kevin Swersky, Jasper Snoek, and Ryan Prescott Adams. Multi-task bayesian optimization. In   \n349 Advances in Neural Information Processing Systems. Curran Associates, Inc., 2013.   \n350 [9] Supratik Paul, Konstantinos Chatzilygeroudis, Kamil Ciosek, Jean-Baptiste Mouret, Michael   \n351 Osborne, and Shimon Whiteson. Alternating optimisation and quadrature for robust control. In   \n352 Proceedings of the AAAI Conference on Artificial Intelligence, volume 32, 2018.   \n353 [10] Saul Toscano-Palmerin and Peter I Frazier. Bayesian optimization with expensive integrands.   \n354 arXiv preprint arXiv:1803.08661, 2018.   \n355 [11] Michael Pearce and Juergen Branke. Bayesian simulation optimization with input uncertainty.   \n356 In 2017 Winter Simulation Conference (WSC), pages 2268–2278. IEEE, 2017.   \n357 [12] Wei Chu, Lihong Li, Lev Reyzin, and Robert Schapire. Contextual bandits with linear payoff   \n358 functions. In Geoffrey Gordon, David Dunson, and Miroslav Dudík, editors, Proceedings of   \n359 the Fourteenth International Conference on Artificial Intelligence and Statistics, volume 15 of   \n360 Proceedings of Machine Learning Research, pages 208–214, Fort Lauderdale, FL, USA, 11–13   \n361 Apr 2011. JMLR Workshop and Conference Proceedings.   \n362 [13] Wei Chu, Lihong Li, Lev Reyzin, and Robert Schapire. Contextual bandits with linear payoff   \n363 functions. In Proceedings of the Fourteenth International Conference on Artificial Intelligence   \n364 and Statistics, pages 208–214. JMLR Workshop and Conference Proceedings, 2011.   \n365 [14] Supratik Paul, Michael A Osborne, and Shimon Whiteson. Contextual policy optimisation.   \n366 arXiv preprint arXiv:1805.10662, 2018.   \n367 [15] Ian Char, Youngseog Chung, Willie Neiswanger, Kirthevasan Kandasamy, Andrew Oakleigh   \n368 Nelson, Mark Boyer, Egemen Kolemen, and Jeff Schneider. Offline contextual bayesian   \n369 optimization. In Advances in Neural Information Processing Systems, pages 4629–4640, 2019.   \n370 [16] Deng Huang, Theodore T Allen, William I Notz, and R Allen Miller. Sequential kriging   \n371 optimization using multiple-fidelity evaluations. Structural and Multidisciplinary Optimization,   \n372 32(5):369–382, 2006.   \n373 [17] Matthias Poloczek, Jialei Wang, and Peter Frazier. Multi-information source optimization. In   \n374 Advances in Neural Information Processing Systems, pages 4289–4299, 2017. ",
+        "bbox": [
+            142,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            138,
+            54,
+            828,
+            929
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[18] Kirthevasan Kandasamy, Gautam Dasarathy, Jeff Schneider, and Barnabás Póczos. Multi-fidelity bayesian optimisation with continuous approximations. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pages 1799–1808. JMLR. org, 2017.   \n[19] Aaron Klein, Stefan Falkner, Simon Bartels, Philipp Hennig, and Frank Hutter. Fast Bayesian Optimization of Machine Learning Hyperparameters on Large Datasets. In Aarti Singh and Jerry Zhu, editors, Proceedings of the 20th International Conference on Artificial Intelligence and Statistics, volume 54 of Proceedings of Machine Learning Research, pages 528–536, Fort Lauderdale, FL, USA, 20–22 Apr 2017. PMLR. [20] R. Bardenet, Mátyás Brendel, Balázs Kégl, and Michele Sebag. Collaborative hyperparameter tuning. In International Conference on Machine Learning, pages 199–207, 2013.   \n385 [21] David Ginsbourger, Jean Baccou, Clément Chevalier, Frédéric Perales, Nicolas Garland, and Yann Monerie. Bayesian adaptive reconstruction of profile optima and optimizers. SIAM/ASA Journal on Uncertainty Quantification, 2(1):490–510, 2014. [22] Michael Pearce and Juergen Branke. Continuous multi-task bayesian optimisation with correlation. European Journal of Operational Research, 270(3):1074–1085, 2018.   \n390 [23] C. E. Rasmussen and C. K. I. Williams. Gaussian Processes for Machine Learning. MIT Press, 2004. [24] D. R. Jones, M. Schonlau, and W. J. Welch. Efficient global optimization of expensive black-box functions. Journal of Global optimization, 13(4):455–492, 1998.   \n394 [25] Andreas Krause and Cheng S Ong. Contextual gaussian process bandit optimization. In Advances in neural information processing systems, pages 2447–2455, 2011.   \n396 [26] Philipp Hennig and Christian J Schuler. Entropy search for information-efficient global optimization. Journal of Machine Learning Research, 13(Jun):1809–1837, 2012. [27] J. Villemonteix, E. Vazquez, and E. Walter. An informational approach to the global optimization of expensive-to-evaluate functions. Journal of Global Optimization, 44(4):509–534, 2009. [28] J. M. HernÂŽandez-Lobato, M. W. Hoffman, and Z. Ghahramani. Predictive entropy search for efficient global optimization of black-box functions. In Advances in Neural Information Processing Systems, pages 918–926. Curran Associates, Inc., 2014.   \n403 [29] Zi Wang and Stefanie Jegelka. Max-value entropy search for efficient bayesian optimization. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pages 3627–3635. JMLR. org, 2017.   \n406 [30] P. Frazier, W. Powell, and S. Dayanik. The knowledge-gradient policy for correlated normal beliefs. INFORMS Journal on Computing, 21(4):599–613, 2009. [31] Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. [32] Warren Scott, Peter Frazier, and Warren Powell. The correlated knowledge gradient for simulation optimization of continuous parameters using gaussian process regression. SIAM Journal on Optimization, 21(3):996–1026, 2011.   \n413 [33] Jian Wu and Peter I Frazier. Discretization-free knowledge gradient methods for bayesian optimization. arXiv preprint arXiv:1707.06541, 2017.   \n415 [34] Maximilian Balandat, Brian Karrer, Daniel Jiang, Samuel Daulton, Ben Letham, Andrew G Wilson, and Eytan Bakshy. Botorch: A framework for efficient monte-carlo bayesian optimization. Advances in Neural Information Processing Systems, 33, 2020.   \n418 [35] Michael Pearce, Matthias Poloczek, and Juergen Branke. Bayesian optimization allowing for common random numbers. arXiv preprint arXiv:1910.09259, 2019. ",
+        "bbox": [
+            148,
+            80,
+            828,
+            915
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            116,
+            339,
+            130
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes] ConBO is theoretically grounded, see Theorems 1-3. ConBO outperforms recently published works on a range of problems, see Section 3, ConBO is easily parallelizable, see SM Section 4.   \n(b) Did you describe the limitations of your work? [Yes] see Section 4   \n(c) Did you discuss any potential negative societal impacts of your work? [Yes] see Section 4   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            238,
+            135,
+            825,
+            268
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            272,
+            493,
+            286
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [Yes] see SM Section 1 (b) Did you include complete proofs of all theoretical results? [Yes] see SM Section 1 ",
+        "bbox": [
+            238,
+            290,
+            825,
+            335
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            214,
+            339,
+            393,
+            354
+        ],
+        "page_idx": 11
+    },
+    {
+        "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] All code is submitted with the SM   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] all parameters for all baselines are given in SM section 3.   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes]   \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] SM section 3 ",
+        "bbox": [
+            238,
+            358,
+            825,
+            491
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            215,
+            494,
+            823,
+            510
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes] code from Simopt.org is cited.   \n(b) Did you mention the license of the assets? [N/A]   \n(c) Did you include any new assets either in the supplemental material or as a URL? [Yes] the benchmark test problems.   \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,
+            513,
+            825,
+            648
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            214,
+            652,
+            705,
+            667
+        ],
+        "page_idx": 11
+    },
+    {
+        "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,
+            671,
+            825,
+            761
+        ],
+        "page_idx": 11
+    }
+]

parse/train/U7vVeHydyR/U7vVeHydyR.md

@@ -0,0 +1,359 @@
+# Fast Extra Gradient Methods for Smooth Structured Nonconvex-Nonconcave Minimax Problems
+
+Sucheol Lee Department of Mathematical Sciences KAIST Daejeon, Republic of Korea csfh1379@kaist.ac.kr
+
+Donghwan Kim Department of Mathematical Sciences KAIST Daejeon, Republic of Korea donghwankim@kaist.ac.kr
+
+# Abstract
+
+Modern minimax problems, such as generative adversarial network and adversarial training, are often under a nonconvex-nonconcave setting, and developing an efficient method for such setting is of interest. Recently, two variants of the extragradient (EG) method are studied in that direction. First, a two-time-scale variant of the EG, named $\mathrm { E G + }$ , was proposed under a smooth structured nonconvexnonconcave setting, with a slow $\mathcal { O } ( \bar { 1 } / k )$ rate on the squared gradient norm, where $k$ denotes the number of iterations. Second, another variant of EG with an anchoring technique, named extra anchored gradient (EAG), was studied under a smooth convex-concave setting, yielding a fast $\mathcal { O } ( 1 / k ^ { 2 } )$ rate on the squared gradient norm. Built upon $\mathrm { E G + }$ and EAG, this paper proposes a two-time-scale EG with anchoring, named fast extragradient (FEG), that has a fast $\mathcal { O } ( 1 / k ^ { 2 } )$ rate on the squared gradient norm for smooth structured nonconvex-nonconcave problems; the corresponding saddle-gradient operator satisfies the negative comonotonicity condition. This paper further develops its backtracking line-search version, named FEG-A, for the case where the problem parameters are not available. The stochastic analysis of FEG is also provided.
+
+# 1 Introduction
+
+Recently, nonconvex-nonconcave minimax problems have received an increased attention in the optimization community and the machine learning community due to their applications to generative adversarial network [10] and adversarial training [27]. In this paper, we consider a smooth structured nonconvex-nonconcave minimax problem:
+
+$$
+\operatorname* { m i n } _ { \pmb { x } \in \mathbb { R } ^ { d _ { \boldsymbol { x } } } } \operatorname* { m a x } _ { \pmb { y } \in \mathbb { R } ^ { d _ { \boldsymbol { y } } } } f ( \pmb { x } , \pmb { y } ) ,
+$$
+
+where $f : \mathbb { R } ^ { d _ { x } } \times \mathbb { R } ^ { d _ { y } }  \mathbb { R }$ is smooth and is possibly nonconvex in $_ { \textbf { \em x } }$ for fixed $\textbf {  { y } }$ , and possibly nonconcave in $\textbf {  { y } }$ for fixed $_ { \textbf { \em x } }$ ; the saddle-gradient operator $\pmb { F } : = ( \nabla _ { x } f , - \nabla _ { y } f )$ satisfies the negative comonotonicity [1]. We construct an efficient (first-order) method, using a saddle gradient operator $\pmb { F }$ for finding a first-order stationary point of the problem (1).
+
+So far little is known under the nonconvex-nonconcave setting, compared to the convex-concave setting. Recent works [4, 7, 22, 24, 26, 42, 44] studied extragradient-type methods [19, 39] for minimax problems under various structured nonconvex-nonconcave settings. In other words, they consider various non-monotone conditions on $\pmb { F }$ , such as the Minty variational inequality (MVI) condition [4], the weak MVI condition [7], and the negative comonotonicity [1].1 Among them, this paper focuses on the negative comonotonicity condition for a Lipschitz continuous $\pmb { F }$ . To the best of our knowledge, the following two-time-scale variant of the extragradient method, named $\mathrm { E G + }$ :
+
+$$
+\begin{array} { c } { { z _ { k + 1 / 2 } = z _ { k } - \frac { \alpha _ { k } } { \beta } { \cal F } z _ { k } , } } \\ { { z _ { k + 1 } = z _ { k } - \alpha _ { k } { \cal F } z _ { k + 1 / 2 } , } } \end{array}
+$$
+
+is the only known (explicit)2 method, using $\pmb { F }$ , that converges under the considered setting3 [7], where $z _ { k } : = ( x _ { k } , y _ { k } )$ . The $\mathrm { E G + }$ , however, has a slow $\mathcal { O } ( 1 / k )$ rate on the squared gradient norm. Note that a similar two-time-scale approach has been found to stabilize the stochastic extragradient method with unbounded noise variance [14].
+
+Meanwhile, under the smooth convex-concave setting, recent works [6, 17, 21, 40, 43] suggest that Halpern-type [12] (or anchoring) methods, performing a convex combination of an initial point $z _ { \mathrm { 0 } }$ and the last updated point $z _ { k }$ at each iteration, has a fast $\mathcal { O } ( 1 / k ^ { 2 } )$ rate in terms of the squared gradient norm. In particular, [43] developed the following anchoring variant of the extragradient method, named extra anchored gradient (EAG):
+
+$$
+\begin{array} { r l } & { z _ { k + 1 / 2 } = z _ { k } + \beta _ { k } ( z _ { 0 } - z _ { k } ) - \alpha _ { k } F z _ { k } , } \\ & { \quad z _ { k + 1 } = z _ { k } + \beta _ { k } ( z _ { 0 } - z _ { k } ) - \alpha _ { k } F z _ { k + 1 / 2 } . } \end{array}
+$$
+
+This is the first (explicit) method with a fast $\mathcal { O } ( 1 / k ^ { 2 } )$ rate on the squared gradient norm, when $\pmb { F }$ satisfies both the Lipschitz continuity and the monotonicity. [43] also showed that such $\mathcal { O } ( 1 / k ^ { 2 } )$ rate is optimal for first-order methods using a Lipschitz continuous and monotone $\pmb { F }$ .
+
+Built upon both $\mathrm { E G + }$ and EAG, this paper studies the following class of two-time-scale anchored extragradient methods, named fast extragradient (FEG):
+
+$$
+\begin{array} { r l } & { z _ { k + 1 / 2 } = z _ { k } + \beta _ { k } ( z _ { 0 } - z _ { k } ) - ( 1 - \beta _ { k } ) ( \alpha _ { k } + 2 \rho _ { k } ) { \cal F } z _ { k } , } \\ & { ~ z _ { k + 1 } = z _ { k } + \beta _ { k } ( z _ { 0 } - z _ { k } ) - \alpha _ { k } { \cal F } z _ { k + 1 / 2 } - ( 1 - \beta _ { k } ) 2 \rho _ { k } { \cal F } z _ { k } . } \end{array}
+$$
+
+(Class FEG)
+
+Note that (Class FEG) reuses the $\pmb { F } z _ { k }$ term in the $z _ { k + 1 }$ update, unlike the standard extragradienttype methods, which we found essential for handling the negative comonotonicity condition. We leave further understanding the use of $\pmb { F } z _ { k }$ and the formulation of (Class FEG) as future work. The proposed FEG method (with appropriately chosen step coefficients $\alpha _ { k }$ , $\beta _ { k }$ and $\rho _ { k }$ discussed later) has an $\mathcal { O } ( 1 / k ^ { 2 } )$ rate on the squared gradient norm, under the Lipschitz continuity and the negative comonotonicity conditions on $\pmb { F }$ . To the best of our knowledge, this is the first accelerated method under the nonconvex-nonconcave setting. The FEG also has value under the smooth convex-concave setting. First, when $\pmb { F }$ is Lipschitz continuous and monotone, the rate bound of FEG is about 27/4 times smaller than that of EAG. Also note that the rate bound of FEG is only about four times larger than the $\mathcal { O } ( 1 / k ^ { 2 } )$ lower complexity bound of first-order methods under such setting [43], further closing the gap between the lower and upper complexity bounds. Second, when $\pmb { F }$ is cocoercive, FEG has a rate faster than that of a version of Halpern iteration [12] in [6].
+
+We also develop an adaptive variant of FEG, named FEG-A, which updates its parameters, $\alpha _ { k }$ and $\rho _ { k }$ in (Class FEG), adaptively using a backtracking line-search [2, 25, 31]. FEG requires the knowledge of the two problem parameters for the Lipschitz continuity and the comonotonicity of $\pmb { F }$ . However, those global parameters can be conservative, and in practice, they are even usually unknown. For such cases, the FEG-A adaptively and locally estimates the problem parameters, while preserving the fast rate $\mathcal { O } ( 1 / k ^ { 2 } )$ on the squared gradient norm for smooth structured nonconvex-nonconcave minimax problems.
+
+Lastly, we study a stochastic version of FEG, named S-FEG, which uses an unbiased stochastic estimate of $\pmb { F } z$ , i.e., $\tilde { F } z = F z + \xi$ , instead of $\pmb { F } z$ in FEG, where $\xi$ denotes a stochastic noise. For a Lipschitz continuous and monotone $\pmb { F }$ , we provide a convergence analysis in terms of the expected squared gradient norm. In specific, we show that the S-FEG is stable with a rate $\mathcal { O } ( 1 / k ^ { 2 } ) \overset { \cdot } { + } \mathcal { O } ( \epsilon )$ , when the noise variance decreases in the order of $\mathcal { O } ( \epsilon / k )$ , while being unstable otherwise due to error accumulation. This is similar to the convergence behavior of a stochastic version of Nesterov’s fast gradient method [35, 36], observed in [5], for smooth convex minimization.
+
+Our main contributions are summarized as follows.
+
+• We propose the FEG method that has an accelerated convergence rate $\mathcal { O } ( 1 / k ^ { 2 } )$ on the squared gradient norm for smooth structured nonconvex-nonconcave minimax problems.   
+We present that the FEG method has a rate faster than those of the EAG and the Halpern iteration for smooth convex-concave problems. We construct a backtracking line-search version of FEG, named FEG-A, for the case where the Lipschitz constant and comonotonicity parameters of $\pmb { F }$ are unavailable.   
+• We analyze a stochastic version of FEG, named S-FEG, for smooth convex-concave problems.
+
+# 2 Related work
+
+# 2.1 Methods for convex-concave minimax problems
+
+The extragradient method [19] is one of the widely used methods for solving smooth convex-concave minimax problems (see, e.g., [4, 7, 22, 24, 26, 42, 44] for its extensions and applications). In terms of the duality gap, $\begin{array} { r } { \operatorname* { m a x } _ { { \pmb y } ^ { \prime } \in \mathcal { V } } f ( { \pmb x } , { \pmb y } ^ { \prime } ) - \operatorname* { m i n } _ { { \pmb x } ^ { \prime } \in \mathcal { X } } f ( { \pmb x } ^ { \prime } , { \pmb y } ) } \end{array}$ , where $\mathcal { X }$ and $\mathcal { V }$ are compact4 domains, the ergodic iterate of the extragradient-type methods [32, 37] have an $\mathcal { O } ( 1 / k )$ rate. Such $\mathcal { O } ( 1 / k )$ rate on the duality gap is order-optimal for the first-order methods [34, 38], leaving no room for√ improvement. On the other hand, the last iterate of the extragradient method has a slower $\mathcal { O } ( 1 / \sqrt { k } )$ rate on the duality gap, under an additional assumption that $\pmb { F }$ has a Lipschitz derivative [9]. In terms of the squared gradient norm, $\| \ b { F z } \| ^ { 2 }$ , the best iterate of the extragradient-type methods [19, 39] have an $\mathcal { O } ( 1 / k )$ rate [40, 41, 43]. The last iterate of the extragradient method also has a rate $\mathcal { O } ( 1 / k )$ , when $\pmb { F }$ is further assumed to have a Lipschitz derivative [9]. Unlike the duality gap, the $\mathcal { O } ( 1 / k )$ rate on the squared gradient norm is not optimal [43]. From now on throughout this paper, we mainly study and compare the convergence rates on the squared gradient norm, which still has room for improvement in convex-concave problems, and has meaning for nonconvex-nonconcave minimax problems, unlike the duality gap.
+
+Recently, [6, 17, 21, 40, 43] found that Halpern-type [12] (or anchoring) methods yield a fast $\mathcal { O } ( 1 / k ^ { 2 } )$ rate in terms of the squared gradient norm for minimax problems. [17, 21] showed that the (implicit) Halpern iteration [12] with appropriately chosen step coefficients has an $\mathcal { O } ( 1 / k ^ { 2 } )$ rate on the squared norm of a monotone $\pmb { F }$ . Then, for a cocoercive $\pmb { F }$ , an (explicit) version of the Halpern iteration was studied in [6, 17] that has the same fast rate. In addition, [6] constructed a double-loop version of the Halpern iteration for a Lipschitz continuous and monotone $\pmb { F }$ , which has a rate $\tilde { \mathcal { O } } ( 1 / k ^ { 2 } )$ on the squared gradient norm, slower than the rate $\mathcal { O } ( 1 / k ^ { 2 } )$ . While this is promising compared to the $\bar { \mathcal { O } ( 1 / k ) }$ rate of the extragradient methods on the squared gradient norm [40, 41, 43], the computational complexity due to its double-loop nature and a relatively slow rate remained a problem. Very recently, [43] proposed the extra anchored gradient (EAG) method, which is the first (explicit) method with a fast $\bar { \mathcal { O } } ( \bar { 1 } / k ^ { 2 } )$ rate for smooth convex-concave minimax problems, i.e., for Lipschitz continuous and monotone operators. In addition, [43] proved that the EAG is order-optimal by showing that the lower complexity bound of first-order methods is $\Omega ( 1 / k ^ { 2 } )$ .
+
+$$
+\begin{array} { c c c c c } { { \mathrm { C o c o e r c i v e } } } & { { \subseteq } } & { { \bf M o n o t o n e } } & { { \subseteq } } & { { \mathrm { N e g a t i v e ~ c o m o n o t o n e } } } \\ { { } } & { { } } & { { | \bigcap } } & { { } } & { { | \bigcap } } \\ { { } } & { { } } & { { \mathrm { M V I } } } & { { \subseteq } } & { { \mathrm { W e a k ~ M V I } } } \end{array}
+$$
+
+Figure 1: Relations between the conditions on $\pmb { F }$ .
+
+# 2.2 Methods for nonconvex-nonconcave minimax problems
+
+Some recent literature considered relaxing the monotonicity condition of the saddle gradient operator to tackle modern nonconvex-nonconcave minimax problems. For example, the Minty variational inequality (MVI) condition, i.e., there exists $z _ { \ast } \in Z _ { \ast } ( F )$ satisfying $\langle F z , z - z _ { * } \rangle \ge 0$ for all $z \in \mathbb { R } ^ { d }$ where $Z _ { * } ( F ) : = \{ z _ { * } \in \mathbb { R } ^ { d } : F z _ { * } = \mathbf { 0 } \}$ , is studied in [4, 23, 22, 24]. This condition is also studied under the name, the coherence, in [26, 42, 44]. Moreover, [7] considered a weaker condition, named the weak MVI condition, i.e., for some $\rho < 0$ , there exists $z _ { \ast } \in Z _ { \ast } ( F )$ satisfying $\langle F z , z - z _ { * } \rangle \geq \rho \Vert F z \Vert ^ { 2 }$ for all $z \in \mathbb { R } ^ { d }$ . The weak MVI condition is implied by the negative comonotonicity [1] or, equivalently, the (positive) cohypomonotonicity [3]. The comonotonicity will be further discussed in the upcoming section.
+
+For $L$ -Lipschitz continuous $\pmb { F }$ , [4, 42] showed that the extragradient-type methods have an $\mathcal { O } ( 1 / k )$ rate on the squared gradient norm under the MVI condition, and [7] developed the $( \mathrm { E G + } )$ method under the weak MVI condition (and thus under the negative comonotonicty), which also has an $\mathcal { O } ( 1 / k )$ rate on the squared gradient norm. To the best of our knowledge, there is no known accelerated method for the nonconvex-nonconcave setting; our proposed FEG method is the first method to have a fast $\mathcal { O } ( 1 / k ^ { 2 } )$ rate under the nonconvex-nonconcave setting. The convergence rates of the existing methods and the FEG on the squared gradient norm are summarized in Table 1.
+
+Table 1: Comparison of the convergence rates of the existing extragradient-type methods and the FEG, with respect to the squared gradient norm, for smooth structured minimax problems, under various assumptions on the Lipschitz continuous saddle gradient operator $\pmb { F }$ .   
+
+<table><tr><td rowspan="2" colspan="2">Method</td><td colspan="2">Convex-concave</td><td colspan="3">Nonconvex-nonconcave</td></tr><tr><td></td><td>Cocoercive Monotone</td><td>Negative comonotone</td><td>MVI</td><td>Weak MVI</td></tr><tr><td rowspan="2">Normal</td><td>EG [4, 42]</td><td>0(1/k)</td><td>0(1/k）</td><td></td><td>0(1/k）</td><td></td></tr><tr><td>EG+[7]</td><td>0(1/k)</td><td>0(1/k)</td><td>0(1/k)</td><td>0(1/k）</td><td>0(1/k）</td></tr><tr><td rowspan="2">Accelerated</td><td>Halpern [12, 6]</td><td>0(1/k²)</td><td>(1/k²)</td><td></td><td></td><td></td></tr><tr><td>EAG [43] FEG (this paper)</td><td>0(1/k2) 0(1/k2)</td><td>0(1/k²) 0(1/k2)</td><td>0(1/k2)</td><td></td><td></td></tr></table>
+
+# 3 Preliminaries
+
+The followings are the two main assumptions for the saddle gradient operator $\pmb { F }$ of the smooth structured nonconvex-nonconcave problem (1). Under such assumptions, we develop efficient methods that find a first-order stationary point $z _ { \ast } \in Z _ { \ast } ( F )$ where $Z _ { * } ( \hat { F } ) : = \{ z _ { * } \in \mathbb { R } ^ { d } : \hat { F } z _ { * } = \mathbf { 0 } \}$ .
+
+Assumption 1 ( $L$ -Lipschitz continuity). For some $L \in ( 0 , \infty )$ , $\pmb { F }$ satisfies
+
+$$
+\| F z - F z ^ { \prime } \| \le L \| z - z ^ { \prime } \| , \quad \forall z , z ^ { \prime } \in \mathbb R ^ { d } .
+$$
+
+Assumption 2 ( $\rho$ -Comonotonicity). For some $\textstyle \rho \in { \bigl ( } - { \frac { 1 } { 2 L } } , \infty { \bigr ) }$ , $\pmb { F }$ satisfies
+
+$$
+\begin{array} { r } { \langle F z - F z ^ { \prime } , z - z ^ { \prime } \rangle \ge \rho \| F z - F z ^ { \prime } \| ^ { 2 } , \quad \forall z , z ^ { \prime } \in \mathbb { R } ^ { d } . } \end{array}
+$$
+
+The $\rho$ -comonotonicity consists of three cases depending on the choice of $\rho$ ; the negative comonotonicity when $\rho < 0$ , the monotonicity when $\rho = 0$ , and the cocoercivity when $\rho > 0$ . The negative comonotonicity is weaker than the other two, and is the main focus of this paper. The following is an examplary nonconvex-nonconcave condition that is stronger than the negative comonotonicity [1, 3].
+
+Example 1. Let $f$ be twice continuously differentiable and $\gamma$ -weakly-convex-weakly-concave. Further assume that $f$ satisfies
+
+$$
+\begin{array} { r } { \nabla _ { x x } ^ { 2 } f + \nabla _ { x y } ^ { 2 } f ( \eta I - \nabla _ { y y } ^ { 2 } f ) ^ { - 1 } \nabla _ { y x } ^ { 2 } f \succeq \alpha I , } \\ { - \nabla _ { y y } ^ { 2 } f + \nabla _ { y x } ^ { 2 } f ( \eta I + \nabla _ { x x } ^ { 2 } f ) ^ { - 1 } \nabla _ { x y } ^ { 2 } f \succeq \alpha I , } \end{array}
+$$
+
+for some $\alpha \geq 0$ and $\eta > \gamma ,$ , named $\alpha \geq 0$ -interaction dominant condition in [11]. Then, the saddle gradient of $f$ satisfies the $- \frac { 1 } { \eta }$ -negative comonotonicity. (See Appendix A.1.) For any $\gamma$ -weaklyconvex-weakly-concave function, the condition (2) holds with $\alpha = - \gamma < 0$ . Its extreme case is
+
+$\begin{array} { r } { f ( x , y ) = - \frac { \gamma } { 2 } x ^ { 2 } + \frac { \gamma } { 2 } y ^ { 2 } } \end{array}$ , where there is no interaction between x and y. On the other hand, when the   
+the second terms in the left-hand side of (2) are sufficently positive definite, a nonconvex-nonconave   
+function satisfies the condition (2) with a nonnegative condition is satisfied when the interaction term of Hess $\alpha$ .n cific, the is domin $\alpha \geq 0$ -interaction dominantany negative curvature $\nabla _ { \substack { x y } } ^ { 2 } f$   
+in Hessians $\nabla _ { x x } ^ { 2 } f$ and $- \nabla _ { \boldsymbol { y } \boldsymbol { y } } ^ { 2 } f l l l \boldsymbol { l } \boldsymbol { l } \boldsymbol { l } \boldsymbol { l }$ .
+
+We next present our proposed FEG, and illustrate that the FEG outperforms existing methods such as $\mathrm { E G + }$ , EAG, and the Halpern iteration, for each three comonoticity case, respectively.
+
+# 4 Fast extragradient (FEG) method for Lipschitz continuous and comonotone operators
+
+This section considers an instance of (Class FEG) with $\begin{array} { r } { \alpha _ { k } = \frac { 1 } { L } } \end{array}$ , $\begin{array} { r } { \beta _ { k } = \frac { 1 } { k + 1 } } \end{array}$ , and $\rho _ { k } = \rho$ for all $k \geq 0$ The resulting method, named FEG, is illustrated in Algorithm 1, which has an $\mathcal { O } ( 1 / k ^ { 2 } )$ fast rate with respect to the squared gradient norm, in Theorem 4.1. The proof of Theorem 4.1 is provided in Section 7.
+
+# Algorithm 1 Fast extragradient (FEG) method
+
+<table><tr><td>Input: z0 ∈ Rd,L ∈ (0,∞o),ρ ∈(- 2,00) for k = 0,1,... do</td></tr><tr><td>2+1/=+1(2-（1-1）（+2）F 1</td></tr><tr><td></td></tr><tr><td>1 2 2k+1= 2k+ k+1</td></tr></table>
+
+end for
+
+Theorem 4.1. For the $L$ -Lipschitz continuous and $\rho$ -comonotone operator $\pmb { F }$ with $\rho > - \frac { 1 } { 2 L }$ and for any $z _ { \ast } \in Z _ { \ast } ( F )$ , the sequence $\{ z _ { k } \} _ { k \ge 0 }$ generated by FEG satisfies, for all $k \geq 1$ ,
+
+$$
+\| F z _ { k } \| ^ { 2 } \leq \frac { 4 \| z _ { 0 } - z _ { * } \| ^ { 2 } } { \Big ( \frac { 1 } { L } + 2 \rho \Big ) ^ { 2 } k ^ { 2 } } .
+$$
+
+The following example shows that the bound (3) of the FEG is exact for $\rho = 0$ and $k = 4 l + 2$ . The bound (3) is not known to be exact in general, and we leave finding the exact bound as future work.
+
+Example 2. Let $f : \mathbb { R } \times \mathbb { R } \to \mathbb { R }$ be $f ( x , y ) = L x y .$ . Its saddle gradient operator and solution are $\pmb { F } ( x , y ) = ( L y , - L x )$ and $z _ { * } = ( 0 , 0 )$ , respectively. For the initial point $z _ { 0 } = ( x _ { 0 } , y _ { 0 } ) =$ $( 1 , 0 )$ , the sequence $\{ z _ { k } \} _ { k \ge 0 }$ generated by FEG satisfies $\begin{array} { r } { z _ { 4 l + 2 } = \left( 0 , \frac { 1 } { 2 l + 1 } \right) } \end{array}$ for all $l \geq 0$ . Hence, $\begin{array} { r } { \| F z _ { 4 l + 2 } \| ^ { 2 } = \frac { L ^ { 2 } } { ( 2 l + 1 ) ^ { 2 } } = \frac { 4 L ^ { 2 } \| z _ { 0 } - z _ { * } \| ^ { 2 } } { ( 4 l + 2 ) ^ { 2 } } } \end{array}$ for all $l \geq 0 .$ . (See Appendix B.1.)
+
+We next compare the rate bound (3) with existing analyses for the three cases $\begin{array} { r } { - \frac { 1 } { 2 L } < \rho < 0 , \rho = 0 } \end{array}$ and $\rho > 0$ .
+
+# 4.1 Comparison to $\mathbf { E G + }$ under the negative comonotonicity $( \rho < 0 )$ )
+
+Under the negative comonotonicity with $\begin{array} { r } { - \frac { 1 } { 8 L } < \rho < 0 } \end{array}$ , the $( \mathrm { E G + } )$ method with $\begin{array} { r } { \alpha _ { k } = \frac { 1 } { 2 L } } \end{array}$ and $\begin{array} { r } { \beta = \frac { 1 } { 2 } } \end{array}$ rate on the squared gradient norm. To the best of our knowledge, this is the best known rate, and the FEG has a faster $\mathcal { O } ( 1 \bar { \vert } k ^ { 2 } )$ rate with a wider region of convergence $\begin{array} { r } { - \frac { 1 } { 2 L } < \rho < 0 } \end{array}$ .
+
+# 4.2 Comparison to EAG under the monotonicity $( \rho = 0$ )
+
+For an $L$ -Lipschitz continuous and monotone operator $\pmb { F }$ , [43] proposed two EAG methods, named EAG-C and EAG-V, with same βk = 1k+2 but with different choices of $\alpha _ { k }$ . EAG-C sets $\alpha _ { k }$ to be a constant $\frac { 1 } { 8 L }$ for all $k \geq 0$ in (EAG), and has a large constant 260 in its convergence rate, $\begin{array} { r } { \| \pmb { F } \pmb { z } _ { k } \| ^ { 2 } \le \frac { 2 6 0 L ^ { 2 } \| \pmb { z } _ { 0 } - \pmb { z } _ { * } \| ^ { 2 } } { ( k + 1 ) ^ { 2 } } } \end{array}$ 260L2kz0−z∗k22 for all k ≥ 0. On the other hand, while EAG-V requires a complicated recursive update for {αk}, αk+1 = αk1−α2L2  $\begin{array} { r } { \alpha _ { k + 1 } = \frac { \alpha _ { k } } { 1 - \alpha _ { k } ^ { 2 } L ^ { 2 } } \big ( 1 - \frac { ( k + 2 ) ^ { 2 } } { ( k + 1 ) ( k + 3 ) } \alpha _ { k } ^ { 2 } L ^ { 2 } \big ) } \end{array}$ for all $k \geq 0$ , with $\begin{array} { r } { \alpha _ { 0 } = \frac { 0 . 6 1 8 } { L } } \end{array}$ , its rate has a smaller constant 27.
+
+![](images/380353bbf2580099fbe770143af658fb4debcb8120afd75852aaa71dc5266deb.jpg)  
+Figure 2: Numerical result with $\begin{array} { r } { f ( x , y ) = - \frac { 1 } { 6 } x ^ { 2 } + \frac { 2 \sqrt { 2 } } { 3 } x y + \frac { 1 } { 6 } y ^ { 2 } } \end{array}$ . The dashed line represents the theoretical bound (3) of FEG.
+
+The FEG takes a constant $\begin{array} { r } { \alpha _ { k } \ = \ \frac { 1 } { L } } \end{array}$ , unlike EAG-V, but has an even smaller constant 4 in its convergence rate $\begin{array} { r } { \| \pmb { F } \pmb { z } _ { k } \| ^ { 2 } \le \frac { 4 L ^ { 2 } \| \pmb { z } _ { 0 } - \pmb { z } _ { * } \| ^ { 2 } } { k ^ { 2 } } } \end{array}$ 4L2kz0−z∗k2k2 for ρ = 0. Therefore, the FEG with ρ = 0 has about $2 6 0 / 4$ -times and $2 7 / 4$ -times faster convergence rate compared to those of EAG-C and EAG-V, respectively. Furthermore, the rate bound of FEG with $\rho = 0$ is only about 4-times larger than the lower complexity bound of first-order methods under the considered setting [43], reducing the gap between the lower and upper complexity bounds from 27 to 4.
+
+# 4.3 Comparison to the Halpern iteration under the cocoercivity $( \rho > 0 )$ )
+
+For a $\rho$ -cocoercive operator $\pmb { F }$ , an (explicit) version of Halpern iteration [12], studied in [6], has a fast rate, $\begin{array} { r } { \| \boldsymbol { F } \boldsymbol { z } _ { k } \| ^ { 2 } \le \frac { \| \boldsymbol { z } _ { 0 } - \boldsymbol { z } _ { * } \| ^ { 2 } } { \rho ^ { 2 } k ^ { 2 } } } \end{array}$ kz0−z∗k2ρ2k2 . Note that while the ρ-cocoercivity implies the 1ρ -Lipschitz continuity, there is case where the $\rho$ -cocoercive (and thus Lipschitz continuous) operator has a Lipschitz constant $L$ smaller than $\frac { 1 } { \rho }$ . Since $\begin{array} { r } { L \le \frac { 1 } { \rho } } \end{array}$ , the FEG has a rate $\begin{array} { r } { \| \boldsymbol { F } \boldsymbol { z } _ { k } \| ^ { 2 } \le \frac { 4 \| \boldsymbol { z } _ { 0 } - \boldsymbol { z } _ { * } \| ^ { 2 } } { ( 1 / L + 2 \rho ) ^ { 2 } k ^ { 2 } } = \frac { 4 \| \boldsymbol { z } _ { 0 } - \boldsymbol { z } _ { * } \| ^ { 2 } } { 9 \rho ^ { 2 } k ^ { 2 } } } \end{array}$ that is faster than that of Halpern iteration. However, if we take into account that the FEG requires computing the saddle gradient twice per iteration, unlike Halpern iteration studied in [6], the FEG method has a slower rate in terms of the number of gradient computations. If we narrow down to the case $\begin{array} { r } { L < \frac { 1 } { 2 \rho } } \end{array}$ , the FEG has a faster rate, $\begin{array} { r } { \| \ b { F } \ b { z } _ { k } \| ^ { 2 } \leq \frac { 4 \| \ b { z } _ { 0 } - \ b { z } _ { * } \| ^ { 2 } } { ( 1 / L + 2 \rho ) ^ { 2 } k ^ { 2 } } < \frac { \| \ b { z } _ { 0 } - \ b { z } _ { * } \| ^ { 2 } } { 4 \rho ^ { 2 } k ^ { 2 } } } \end{array}$ . For such case, the FEG has a rate faster than that of the Halpern iteration, even in terms of the number of gradient computations.
+
+# 4.4 Toy example
+
+rformed a toy exp, which has an iment on a simple quadratic-Lipschitz continuous and nction, -comon $\begin{array} { r } { f ( x , y ) = \frac { \rho L ^ { 2 } } { 2 } x ^ { 2 } + L \sqrt { 1 - \rho ^ { 2 } L ^ { 2 } } x y - } \end{array}$ ${ \frac { \rho L ^ { 2 } } { 2 } } y ^ { 2 }$ $L$ $\rho$ $\begin{array} { r } { \rho = - \frac { 1 } { 3 L } } \end{array}$ and $L = 1$ , Figure 2 illustrates that the FEG converges with an accelerated rate whereas $\mathrm { E G + }$ , EAG-C, EAG-V, and the (explicit) version of Halpern iteration [6] diverge. This example presents that the existing guarantees on convergence and acceleration of the aforementioned methods under the convex-concave setting do not generalize to the nonconvex-nonconcave setting.
+
+# 5 FEG with backtracking line-search
+
+The FEG requires the knowledge of the two global parameters $L$ and $\rho$ for Lipschitz continuity and comonotonicity, respectively. Those global parameters are often difficult to compute in practice and can be locally conservative. To handle these two disadvantages, we employ the backtracking line-search technique [2, 25, 31] in FEG. We adaptively decrease the two step size parameters, $\tau$ and $\eta$ , to satisfy the both conditions, the local $\frac { 1 } { \tau _ { - } }$ -Lipschitz continuity and the $\frac { \eta - \tau } { 2 }$ -comonotonicity.5 A pseudocode of the resulting method, named FEG-A, is illustrated in Algorithm 2. For a detailed description of the FEG-A, see Algorithm 4 in Appendix C.1.
+
+# Algorithm 2 Fast extragradient method with adaptive step size (FEG-A)
+
+Input: $\boldsymbol { z } _ { 0 } \in \mathbb { R } ^ { d }$ , $\tau _ { - 1 } \in ( \operatorname* { m a x } \{ 0 , - 2 \rho \} , \infty )$ , $\eta _ { 0 } \in ( 0 , \infty )$ , $\delta \in ( 0 , 1 )$   
+Find the smallest nonnegative integer $i _ { 0 }$ such that $\hat { z } = { z _ { 0 } - \tau _ { - 1 } ( 1 - \delta ) ^ { i _ { 0 } } F z _ { 0 } }$ satisfies $\Vert \pmb { F } \hat { z } -$   
+$\begin{array} { r } { \pmb { F } z _ { 0 } \| \leq \frac { 1 } { \tau _ { - 1 } ( 1 - \delta ) ^ { i _ { 0 } } } \| \hat { \pmb { z } } - z _ { 0 } \| } \end{array}$ .   
+$\tau _ { 0 } = \tau _ { - 1 } ( 1 - \delta ) ^ { i _ { 0 } }$ , $z _ { \mathrm { 1 } } = z _ { \mathrm { 0 } } - \tau _ { 0 } F z _ { \mathrm { 0 } }$ .   
+for $k = 1 , 2 , \ldots$ do $i _ { k } = j _ { k } = 0$ . Increase each $i _ { k }$ and $j _ { k }$ one by one until
+
+$$
+\begin{array} { r l } & { \hat { z } _ { k + 1 / 2 } = z _ { k } + \cfrac { 1 } { k + 1 } ( z _ { 0 } - z _ { k } ) - \bigg ( 1 - \cfrac { 1 } { k + 1 } \bigg ) \eta _ { k - 1 } ( 1 - \delta ) ^ { j _ { k } } F z _ { k } \qquad \mathrm { a n d } } \\ & { \hat { z } _ { k + 1 } = z _ { k } + \cfrac { 1 } { k + 1 } ( z _ { 0 } - z _ { k } ) - \tau _ { k - 1 } ( 1 - \delta ) ^ { i _ { k } } F z _ { k + 1 / 2 } } \\ & { \qquad - \bigg ( 1 - \cfrac { 1 } { k + 1 } \bigg ) ( \eta _ { k - 1 } ( 1 - \delta ) ^ { j _ { k } } - \tau _ { k - 1 } ( 1 - \delta ) ^ { i _ { k } } ) F z _ { k } } \end{array}
+$$
+
+satisfy both conditions,
+
+$$
+\begin{array} { r l } & { \qquad \| F \hat { z } _ { k + 1 } - F \hat { z } _ { k + 1 / 2 } \| \le \frac { 1 } { \tau _ { k - 1 } ( 1 - \delta ) ^ { i _ { k } } } \| \hat { z } _ { k + 1 } - \hat { z } _ { k + 1 / 2 } \| \qquad \mathrm { a n d } } \\ & { \qquad \langle F \hat { z } _ { k + 1 } - F z _ { k } , \hat { z } _ { k + 1 } - z _ { k } \rangle \ge \frac { \eta _ { k - 1 } ( 1 - \delta ) ^ { j _ { k } } - \tau _ { k - 1 } ( 1 - \delta ) ^ { i _ { k } } } { 2 } \| F \hat { z } _ { k + 1 } - F z _ { k } \| ^ { 2 } . } \\ & { \qquad \frac { \tilde { \mathbf { \phi } } _ { k } } { \mathrm { \Delta } r } = \tau _ { k - 1 } ( 1 - \delta ) ^ { i _ { k } } , \eta _ { k } = \eta _ { k - 1 } ( 1 - \delta ) ^ { j _ { k } } , z _ { k + 1 } = \hat { z } _ { k + 1 } . } \end{array}
+$$
+
+The following lemma shows that each of the nonincreasing sequences $\{ \tau _ { k } \} _ { k \ge 0 }$ and $\{ \eta _ { k } \} _ { k \ge 0 }$ of the FEG-A has a positive lower bound, and thus FEG-A is well-defined6, under the condition $\rho > - \frac { \tau _ { k } } { 2 }$ . This condition for ρ can be weaker than the condition ρ > − 12L of FEG, since the local Lipschitz parameter $\scriptstyle { \frac { 1 } { \tau _ { k } } }$ can be smaller than $L$ . This is another benefit of using a backtracking line-search in FEG, over the standard FEG.
+
+Lemma 5.1. For the $L$ -Lipschitz and $\rho$ -comonotone operator $\pmb { F }$ and a given constant $\delta \in ( 0 , 1 )$ , the step size $\tau _ { k }$ of FEG-A is lower bounded by a positive value $\begin{array} { r } { \underline { { \tau } } : = \operatorname* { m i n } \left\{ \tau _ { - 1 } , { \frac { 1 - \delta } { L } } \right\} } \end{array}$ for all $k \geq 0$ , and $\begin{array} { r } { { \mathfrak { j } } f \rho > - { \frac { \tau _ { k } } { 2 } } } \end{array}$ , the step size $\eta _ { k }$ is lower bounded by a positive value $\operatorname* { m i n } \left\{ \eta _ { 0 } , ( 1 - \delta ) \bigl ( \tau _ { k } + 2 \rho \bigr ) \right\}$ for all $k \geq 1$ .
+
+The FEG-A method also has the following $\mathcal { O } ( 1 / k ^ { 2 } )$ rate with respect to the squared gradient norm in Theorem 5.1, when $\rho > - \frac { \tau _ { k } } { 2 }$ . The proof is provided in Section 7 and Appendix C.3.
+
+Theorem 5.1. For the $L$ -Lipschitz and $\rho$ -comonotone operator $\pmb { F }$ and for any $z _ { \ast } \in Z _ { \ast } ( F )$ , the sequence $\{ z _ { k } \} _ { k \ge 0 }$ generated by FEG-A satisfies
+
+$$
+\| F z _ { k } \| ^ { 2 } \leq \frac { 4 \| z _ { 0 } - z _ { * } \| ^ { 2 } } { ( ( k - 1 ) \eta _ { k } + \tau _ { k } + 2 \rho ) ^ { 2 } }
+$$
+
+for all $k \geq 1$ , if $\rho > - \frac { \tau _ { k } } { 2 }$
+
+This rate bound of FEG-A reduces to that of FEG in Theorem 4.1, when we choose $\begin{array} { r } { \tau _ { - 1 } = \frac { 1 } { L } } \end{array}$ and $\begin{array} { r } { \eta _ { 0 } = \frac { 1 } { L } + 2 \rho } \end{array}$ for FEG-A.
+
+# 6 FEG under stochastic setting
+
+When exactly computing $\pmb { F } z$ is expensive in practice, one usually instead consider its stochastic estimate for computational efficiency (see, e.g., [13, 16, 26, 33, 40, 42, 44]). This section also considers using a stochastic oracle in FEG for smooth convex-concave problems. In specific, this section assumes that we only have access to a noisy saddle gradient oracle, $\tilde { F } z _ { k / 2 } = F \bar { z } _ { k / 2 } + \xi _ { k / 2 }$ , where $\{ \xi _ { k / 2 } \} _ { k \geq 0 }$ are independent random variables satisfying $\mathbb { E } [ \xi _ { k / 2 } ] = 0$ and $\mathbb { E } [ \| \xi _ { k / 2 } \| ^ { 2 } ] = \sigma _ { k / 2 } ^ { 2 }$ for all $k \geq 0$ . Under this setting, we study a stochastic first-order method, named stochastic fast extragradient (S-FEG) method, illustrated in Algorithm 3.
+
+# Algorithm 3 Stochastic fast extragradient (S-FEG) method
+
+Input: $\boldsymbol { z } _ { 0 } \in \mathbb { R } ^ { d }$ , $L \in ( 0 , \infty )$ . for $k = 0 , 1 , \ldots$ do
+
+$$
+\begin{array} { l } { { z _ { k + 1 / 2 } = z _ { k } + \displaystyle \frac { 1 } { k + 1 } ( z _ { 0 } - z _ { k } ) - \left( 1 - \displaystyle \frac { 1 } { k + 1 } \right) \displaystyle \frac { 1 } { L } \tilde { F } z _ { k } } } \\ { { z _ { k + 1 } = z _ { k } + \displaystyle \frac { 1 } { k + 1 } ( z _ { 0 } - z _ { k } ) - \displaystyle \frac { 1 } { L } \tilde { F } z _ { k + 1 / 2 } } } \end{array}
+$$
+
+# end for
+
+The following theorem provides an upper bound of the expected squared gradient norm for the S-FEG. (See Appendix D.3 for the proof.)
+
+Theorem 6.1. Let $\tilde { F } z _ { k / 2 } = F z _ { k / 2 } + \xi _ { k / 2 }$ , where $\{ \xi _ { k / 2 } \} _ { k \geq 0 }$ are independent random variables satisfying $\mathbb { E } [ \xi _ { k / 2 } ] = 0$ and $\mathbb { E } [ \| \xi _ { k / 2 } \| ^ { 2 } ] = \sigma _ { k / 2 } ^ { 2 }$ for all $k \geq 0$ . Then, for the $L$ -Lipschitz continuous and monotone operator $F$ and for any $z _ { * } \in Z _ { * } ( F )$ , the sequence $\{ z _ { k } \} _ { k \ge 0 }$ generated by S-FEG satisfies
+
+$$
+\mathbb { E } [ \| F z _ { k } \| ^ { 2 } ] \le \frac { 4 L ^ { 2 } \| z _ { 0 } - z _ { * } \| ^ { 2 } } { k ^ { 2 } } + \frac { 6 } { k ^ { 2 } } \left[ \sigma _ { 0 } ^ { 2 } + \sum _ { l = 1 } ^ { k - 1 } ( l ^ { 2 } \sigma _ { l } ^ { 2 } + ( l + 1 ) ^ { 2 } \sigma _ { l + 1 / 2 } ^ { 2 } ) \right]
+$$
+
+for all $k \geq 1$ . Furthermore, if $\sigma _ { 0 } ^ { 2 } \le \frac { \epsilon } { 6 }$ , $\sigma _ { k } ^ { 2 } \le \frac { \epsilon } { 6 k }$ and $\textstyle \sigma _ { k + 1 / 2 } ^ { 2 } \leq \frac { \epsilon } { 6 ( k + 1 ) }$ for all $k \geq 1$ , then the bound (4) reduces to
+
+$$
+\mathbb { E } [ \| F z _ { k } \| ^ { 2 } ] \le \frac { 4 L ^ { 2 } \| z _ { 0 } - z _ { * } \| ^ { 2 } } { k ^ { 2 } } + \epsilon
+$$
+
+for all $k \geq 1$
+
+Here, we needed the noise variance $\sigma _ { k / 2 } ^ { 2 }$ to decrease in the order of $\mathcal { O } ( 1 / k )$ so that the stochastic error of the S-FEG does not accumulate. Otherwise, if $\sigma _ { k / 2 } ^ { 2 }$ is a constant for all $k$ , the error accumulates with rate ${ \mathcal { O } } ( k )$ . In short, the S-FEG will suffer from error accumulation, unless the stochastic error decreases with rate $\mathcal { O } ( 1 / k )$ . Such error accumulation behavior also appears in a stochastic version of Nesterov’s fast gradient method [35, 36] for smooth convex minimization [5, 8]. Similar to [5], we believe that adjusting the step coefficients of the S-FEG can make the S-FEG become relatively stable even with a constant noise, which we leave as future work.
+
+# 7 Convergence analysis with nonincreasing potential lemma
+
+We analyze FEG and FEG-A by finding a nonincreasing potential function in a form $V _ { k } ~ =$ $a _ { k } \| F z _ { k } \| ^ { 2 } - b _ { k } \left. F z _ { k } , z _ { 0 } - z _ { k } \right.$ in the lemma below. We provide a similar potential lemma for S-FEG in Appendix D.2. The convergence analyses of EAG and Halpern iteration are also based on such potential function [6, 43].
+
+Lemma 7.1. Let $\{ z _ { k } \} _ { k \ge 0 }$ be the sequence generated by (Class FEG) with $\{ \alpha _ { k } \} _ { k \geq 0 } , \{ \beta _ { k } \} _ { k \geq 0 } ,$ $\{ L _ { k } \} _ { k \ge 0 } \subset ( 0 , \infty )$ and $\{ \rho _ { k } \} _ { k \ge 0 } \subset \mathbb { R } ,$ , satisfying $\alpha _ { 0 } \in ( 0 , \infty )$ , $\textstyle \alpha _ { k } \in { \bigl ( } 0 , { \frac { 1 } { L _ { k } } } { \bigr ] }$ , $\beta _ { 0 } = 1$ , $\{ \beta _ { k } \} _ { k \ge 1 } \subseteq$ $( 0 , 1 )$ for all $k \geq 1$ , and
+
+$$
+\frac { ( 1 - \beta _ { k + 1 } ) } { 2 \beta _ { k + 1 } } ( \alpha _ { k + 1 } + 2 \rho _ { k + 1 } ) - \rho _ { k + 1 } \leq \frac { 1 } { 2 \beta _ { k } } ( \alpha _ { k } + 2 \rho _ { k } ) - \rho _ { k }
+$$
+
+for all $k \geq 0$ . Assume that the following conditions are satisfied.
+
+$$
+\begin{array} { c } { { \| { \pmb F } { \boldsymbol z } _ { 1 } - { \pmb F } { \boldsymbol z } _ { 0 } \| \leq L _ { 0 } \| { \boldsymbol z } _ { 1 } - { \boldsymbol z } _ { 0 } \| } } \\ { { \| { \pmb F } { \boldsymbol z } _ { k + 1 } - { \pmb F } { \boldsymbol z } _ { k + 1 / 2 } \| \leq L _ { k } \| { \boldsymbol z } _ { k + 1 } - { \boldsymbol z } _ { k + 1 / 2 } \| } } \\ { { \langle { \pmb F } { \boldsymbol z } _ { k + 1 } - { \pmb F } { \boldsymbol z } _ { k } , { \boldsymbol z } _ { k + 1 } - { \pmb z } _ { k } \rangle \geq \rho _ { k } \| { \pmb F } { \boldsymbol z } _ { k + 1 } - { \pmb F } { \boldsymbol z } _ { k } \| ^ { 2 } } } \end{array}
+$$
+
+Then the potential function
+
+$$
+V _ { k } = a _ { k } \| F z _ { k } \| ^ { 2 } - b _ { k } \left. F z _ { k } , z _ { 0 } - z _ { k } \right.
+$$
+
+with $\begin{array} { r } { a _ { 0 } = \frac { \alpha _ { 0 } ( L _ { 0 } ^ { 2 } \alpha _ { 0 } ^ { 2 } - 1 ) } { 2 } } \end{array}$ , $b _ { 0 } = 0 , b _ { 1 } = 1 ,$
+
+$$
+a _ { k } = { \frac { b _ { k } ( 1 - \beta _ { k } ) } { 2 \beta _ { k } } } ( \alpha _ { k } + 2 \rho _ { k } ) - b _ { k } \rho _ { k } a n d b _ { k + 1 } = { \frac { b _ { k } } { 1 - \beta _ { k } } }
+$$
+
+for all $k \geq 1$ satisfies $V _ { k } \le V _ { k - 1 }$ for all $k \geq 1$
+
+Based on the above potential lemma, we next provide a convergence analysis of FEG. The analyses for the convergence rate of FEG-A and S-FEG, i.e., the proofs of Theorem 5.1 and Theorem 6.1, are similar to that of FEG and are provided in Appendix C.3 and Appendix D.3.
+
+# 7.1 Convergence analysis for FEG
+
+Proof of Theorem 4.1. Recall that FEG is equivalent to (Class FEG) with $\begin{array} { r } { \alpha _ { k } = \frac { 1 } { L } , \beta _ { k } = \frac { 1 } { k + 1 } } \end{array}$ , and $\rho _ { k } = \rho$ . It is straightforward to verify that the given $\{ \alpha _ { k } \} _ { k \ge 0 }$ and $\{ \beta _ { k } \} _ { k \ge 0 }$ satisfy the conditions in Lemma 7.1 with $L _ { k } = L$ for all $k \geq 0$ . Since
+
+$$
+\begin{array} { c } { { a _ { k } = \displaystyle \frac { b _ { k } ( 1 - \beta _ { k } ) } { 2 \beta _ { k } } ( \alpha _ { k } + 2 \rho _ { k } ) - b _ { k } \rho _ { k } = \displaystyle \frac { k ^ { 2 } } { 2 } \Big ( \frac 1 L + 2 \rho \Big ) - k \rho \qquad \mathrm { a n d } } } \\ { { b _ { k } = \displaystyle \frac { 1 } { 1 - \beta _ { k - 1 } } b _ { k - 1 } = \Big ( \prod _ { i = 1 } ^ { k - 1 } \frac 1 { 1 - \beta _ { i } } \Big ) b _ { 1 } = k , } } \end{array}
+$$
+
+Lemma 7.1 implies that
+
+$$
+0 = V _ { 0 } \geq V _ { k } = \left( \frac { k ^ { 2 } } { 2 } \Big ( \frac { 1 } { L } + 2 \rho \Big ) - k \rho \right) \| F z _ { k } \| ^ { 2 } - k \left. F z _ { k } , z _ { 0 } - z _ { k } \right. .
+$$
+
+Therefore,
+
+$$
+\begin{array} { r l } & { \displaystyle \frac { k ^ { 2 } } { 2 } \Big ( \frac { 1 } { L } + 2 \rho \Big ) \| F z _ { k } \| ^ { 2 } \leq k \langle F z _ { k } , z _ { 0 } - z _ { k } \rangle + k \rho \| F z _ { k } \| ^ { 2 } } \\ & { \quad \quad \quad \quad = k \langle F z _ { k } , z _ { 0 } - z _ { * } \rangle + k \langle F z _ { k } , z _ { * } - z _ { k } \rangle + k \rho \| F z _ { k } \| ^ { 2 } } \\ & { \quad \quad \quad \leq k \langle F z _ { k } , z _ { 0 } - z _ { * } \rangle \quad \quad \quad \quad ( \because \rho \mathrm { - c o m o n o t o n i c i t y ~ o f ~ } F ) } \\ & { \quad \quad \quad \quad \leq k \| F z _ { k } \| \| z _ { 0 } - z _ { * } \| . } \end{array}
+$$
+
+The desired result follows directly by dividing both sides by $\begin{array} { r } { \frac { k ^ { 2 } } { 2 } \left( \frac { 1 } { L } + 2 \rho \right) \| F z _ { k } \| } \end{array}$ .
+
+# 8 Discussion: first-order methods for Lipschitz continuous operators
+
+Throughout this paper, we studied and constructed efficient methods in a class of first-order methods:
+
+$$
+z _ { k } \in z _ { 0 } + \operatorname { s p a n } \{ F z _ { 0 } , \cdot \cdot \cdot , F z _ { k } \}
+$$
+
+denoted by $\mathcal { A }$ , for smooth structured nonconvex-nonconcave problems. We observed that all existing first-order methods, including the FEG, required an additional condition, such as the negative comonoticity, on a Lipschitz continuous $\pmb { F }$ to guarantee convergence. One would then be curious whether or not there exists an (efficient) method in class $\mathcal { A }$ that guarantees convergence without any additional condition on a Lipschitz continuous $\pmb { F }$ . Unfortunately, the following lemma states that there exists a worst-case7 smooth example that none of the methods in $\mathcal { A }$ can find its stationary point. The corresponding smooth function is illustrated in Figure 3.
+
+![](images/417af2708fada253c811f0d36e8f36eb36b53d148b42635dd18fbe25dc8f1b31.jpg)  
+Figure 3: A smooth worst-case example $f ( x , y )$ (5) with $L = R = 1$ for first-order methods. any sequence $\{ z _ { k } \} _ { k \ge 0 }$ generated by a first-order method in class $\mathcal { A }$ starting from $( 0 , 0 )$ is contained in the line $x = y$ .
+
+Lemma 8.1. Let us consider the following function $f : \mathbb { R } ^ { 2 } \to \mathbb { R }$ for some $L , R > 0$ :
+
+$$
+\begin{array} { r } { f ( x , y ) = \left\{ \begin{array} { l l } { \frac { R } { 2 } } & { f o r x < y - \sqrt { \frac { R } { L } } } \\ { - \frac { L } { 2 } ( x - y ) ^ { 2 } - \sqrt { L R } ( x - y ) } & { f o r y - \sqrt { \frac { R } { L } } \leq x < y } \\ { \frac { L } { 2 } ( x - y ) ^ { 2 } - \sqrt { L R } ( x - y ) } & { f o r y \leq x < y + \sqrt { \frac { R } { L } } } \\ { - \frac { R } { 2 } } & { f o r y + \sqrt { \frac { R } { L } } < x . } \end{array} \right. } \end{array}
+$$
+
+Its saddle-gradient operator $\pmb { F }$ is $L$ -Lipschitz continuous but not comonotone.8 Then, the sequence $\{ z _ { k } \} _ { k \ge 0 }$ generated by any first-order method in class $\mathcal { A }$ with $z _ { 0 } = ( 0 , 0 )$ satisfies $\| { \pmb { F } } { \pmb { z } } _ { k } \| ^ { 2 } = 2 L R$ for all $k \geq 0$ .
+
+Proof. $\pmb { F }$ satisfies $F ( x , y ) = ( - \sqrt { L R } , - \sqrt { L R } )$ whenever $x = y$ . Hence, for all sequences $\{ z _ { k } \} _ { k \ge 0 }$ satisfying $z _ { 0 } = ( 0 , 0 )$ and $z _ { k } \in z _ { 0 } + \operatorname { s p a n } \{ F z _ { 0 } , \cdot \cdot \cdot , F z _ { k } \}$ for all $k \geq 0$ , we have that $\{ z _ { k } \} _ { k \ge 0 } \subseteq$ $\{ z = ( x , y ) \in \mathbb { R } ^ { 2 } | x = y \}$ ; thus, $\| { \pmb { F } } z _ { k } \| ^ { 2 } = 2 L R$ for all $k \geq 0$ .
+
+The lemma implies that one should consider a class of methods, other than the class $\mathcal { A }$ , to guarantee finding a stationary point of any smooth problem, which we leave as future work. We also leave finding additional conditions for a Lipschitz continuous $\pmb { F }$ , weaker than the weak MVI condition and the negative comonotonicity (with $\begin{array} { r } { { \Dot { \rho } } > - \frac { 1 } { 2 L } ) } \end{array}$ , which guarantee convergence or its accelerated rate, respectively, as future work.
+
+# 9 Conclusion
+
+This paper proposed a two-time-scale and anchored extragradient method, named FEG, for smooth structured nonconvex-nonconcave problems. The proposed FEG has an accelerated $\mathcal { O } ( 1 / k ^ { 2 } )$ rate, with respect to the squared gradient norm, for the Lipschitz continuous and negative comonotone operators for the first time. The FEG also has value for smooth convex-concave problems, compared to existing works. We further studied its backtracking line-search version, named FEG-A, for the smooth structured nonconvex-nonconcave problems and studied its stochastic version, named S-FEG, for smooth convex-concave problems. We leave extending this work to stochastic, composite, or more general nonconvex-nonconcave setting and applying to more realistic problems as future work.
+
+# Acknowledgments and Disclosure of Funding
+
+This work was supported in part by the National Research Foundation of Korea (NRF) grant funded by the Korea government (MSIT) (No. 2019R1A5A1028324), the POSCO Science Fellowship of POSCO TJ Park Foundation, and the Samsung Science and Technology Foundation (No. SSTFBA2101-02).
+
+# References
+
+[1] H. H. Bauschke, W. M. Moursi, and X. Wang. Generalized monotone operators and their averaged resolvents. Mathematical Programming, 189(1):55–74, 2021.   
+[2] A. Beck and M. Teboulle. A fast iterative shrinkage-thresholding algorithm for linear inverse problems. SIAM J. Imaging Sci., 2(1):183–202, 2009.   
+[3] P. L. Combettes and T. Pennanen. Proximal methods for cohypomonotone operators. SIAM J. Control Optim., 43(2):731–42, 2004.   
+[4] C. D. Dang and G. Lan. On the convergence properties of non-Euclidean extragradient methods for variational inequalities with generalized monotone operators. Computational Optimization and Applications, 60(2):277–310, 2015.   
+[5] O. Devolder. Stochastic first order methods in smooth convex optimization, 2011.   
+[6] J. Diakonikolas. Halpern iteration for near-optimal and parameter-free monotone inclusion and strong solutions to variational inequalities. In Conference on Learning Theory, pages 1428–1451. PMLR, 2020.   
+[7] J. Diakonikolas, C. Daskalakis, and M. Jordan. Efficient methods for structured nonconvexnonconcave min-max optimization. In International Conference on Artificial Intelligence and Statistics, pages 2746–2754. PMLR, 2021.   
+[8] S. Ghadimi and G. Lan. Accelerated gradient methods for nonconvex nonlinear and stochastic programming. Mathematical Programming, 156(1):59–99, March 2016.   
+[9] N. Golowich, S. Pattathil, C. Daskalakis, and A. Ozdaglar. Last iterate is slower than averaged iterate in smooth convex-concave saddle point problems. In Conference on Learning Theory (COLT), 2020.   
+[10] I. J. Goodfellow, J. Pouget-Abadie, M. Mirza, B. Xu, D. Warde-Farley, S. Ozair, A. Courville, and Y. Bengio. Generative adversarial networks. In Neural Info. Proc. Sys., 2014.   
+[11] B. Grimmer, H. Lu, P. Worah, and V. Mirrokni. The landscape of the proximal point method for nonconvex-nonconcave minimax optimization, 2020.   
+[12] B. Halpern. Fixed points of nonexpanding maps. Bull. Amer. Math. Soc, 73:957–961, 1967.   
+[13] Y.-G. Hsieh, F. Iutzeler, J. Malick, and P. Mertikopoulos. On the convergence of single-call stochastic extra-gradient methods. In Neural Info. Proc. Sys., 2019.   
+[14] Y.-G. Hsieh, F. Iutzeler, J. Malick, and P. Mertikopoulos. Explore aggressively, update conservatively: Stochastic extragradient methods with variable stepsize scaling. In Neural Info. Proc. Sys., 2020.   
+[15] Y.-P. Hsieh, P. Mertikopoulos, and V. Cevher. The limits of min-max optimization algorithms: convergence to spurious non-critical sets. In Proc. Intl. Conf. Mach. Learn, 2021.   
+[16] A. Juditsky, A. Nemirovski, and C. Tauvel. Solving variational inequalities with stochastic mirror-prox algorithm. Stochastic Systems, 1(1):17–58, 2011.   
+[17] D. Kim. Accelerated proximal point method for maximally monotone operators. Mathematical Programming, 190(1):57–87, 2021.   
+[18] U. Kohlenbach. On the proximal point algorithm and its Halpern-type variant for generalized monotone operators in Hilbert space. Optimization Letters, 2021.   
+[19] G. M. Korpelevich. An extragradient method for finding saddle points and other problems. Ekonomika i Mateaticheskie Metody, 12(4):747–56, 1976.   
+[20] A. Letcher. On the impossibility of global convergence in multi-loss optimization. In Proc. Intl. Conf. on Learning Representations, 2021.   
+[21] F. Lieder. On the convergence rate of the Halpern-iteration. Optimization Letters, 15(2):405–418, 2021.   
+[22] M. Liu, Y. Mroueh, J. Ross, W. Zhang, X. Cui, P. Das, and T. Yang. Towards better understanding of adaptive gradient algorithms in generative adversarial nets. In International Conference on Learning Representations, 2020.   
+[23] M. Liu, H. Rafique, Q. Lin, and T. Yang. First-order convergence theory for weakly-convexweakly-concave min-max problems. J. Mach. Learning Res., 22(169):1–34, 2021.   
+[24] Y. Malitsky. Golden ratio algorithms for variational inequalities. Mathematical Programming, 184(1):383–410, 2020.   
+[25] Y. Malitsky and T. Pock. A first-order primal-dual algorithm with linesearch. SIAM Journal on Optimization, 28(1):411–432, 2018.   
+[26] P. Mertikopoulos, B. Lecouat, H. Zenati, C.-S. Foo, V. Chandrasekhar, and G. Piliouras. Optimistic mirror descent in saddle-point problems: going the extra (gradient) mile. In Proc. Intl. Conf. on Learning Representations, 2019.   
+[27] A. M ˛adry, A. Makelov, L. Schmdit, D. Tsipras, and A. Vladu. Towards deep learning models resistant to adversarial attacks. In Proc. Intl. Conf. on Learning Representations, 2018.   
+[28] A. Mokhtari, A. Ozdaglar, and S. Pattathil. A unified analysis of extra-gradient and optimistic gradient methods for saddle point problems: Proximal point approach. In Proc. Intl. Conf. Artificial Intelligence and Stat. (AISTATS), 2020.   
+[29] R. D. C. Monteiro and B. F. Svaiter. On the complexity of the hybrid proximal extragradient method for the iterates and the ergodic mean. SIAM J. Optim., 20(6):2755–87, 2010.   
+[30] R. D. C. Monteiro and B. F. Svaiter. Complexity of variants of Tseng’s modified FB splitting and Korpelevich’s methods for hemivariational inequalities with applications to saddle-point and convex optimization problems. SIAM Journal on Optimization, 21(4):1688–1720, 2011.   
+[31] M. C. Mukkamala, P. Ochs, T. Pock, and S. Sabach. Convex-concave backtracking for inertial bregman proximal gradient algorithms in nonconvex optimization. SIAM Journal on Mathematics of Data Science, 2(3):658–682, 2020.   
+[32] 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 J. Optim., 15(1):229–51, 2004.   
+[33] A. Nemirovski, A. Juditsky, G. Lan, and A. Shapiro. Robust stochastic approximation approach to stochastic programming. SIAM J. Optim., 19(4):1574–609, 2009.   
+[34] A. Nemirovski and D. Yudin. Problem complexity and method efficiency in optimization. wiley, 1983.   
+[35] Y. Nesterov. A method for unconstrained convex minimization problem with the rate of convergence $O ( 1 / k ^ { 2 } )$ . Dokl. Akad. Nauk. USSR, 269(3):543–7, 1983.   
+[36] Y. Nesterov. Smooth minimization of non-smooth functions. Mathematical Programming, 103(1):127–52, May 2005.   
+[37] Y. Nesterov. Dual extrapolation and its applications to solving variational inequalities and related problems. Mathematical Programming, 109(2-3):319–44, March 2007.   
+[38] Y. Ouyang and Y. Xu. Lower complexity bounds of first-order methods for convex-concave bilinear saddle-point problems. Mathematical Programming, 185(1):1–35, 2021.   
+[39] L. D. Popov. A modification of the Arrow-Hurwicz method for search of saddle points. Mathematical notes of the Academy of Sciences of the USSR, 28(5):845–8, November 1980.   
+[40] E. K. Ryu, K. Yuan, and W. Yin. ODE analysis of stochastic gradient methods with optimism and anchoring for minimax problems and GANs, 2019. arxiv 1905.10899.   
+[41] M. V. Solodov and B. F. Svaiter. A hybrid approximate extragradient–proximal point algorithm using the enlargement of a maximal monotone operator. Set-Valued Analysis, 7(4):323–345, 1999.   
+[42] C. Song, Z. Zhou, Y. Zhou, Y. Jiang, and Y. Ma. Optimistic dual extrapolation for coherent non-monotone variational inequalities. In Neural Info. Proc. Sys., 2020.   
+[43] T. Yoon and E. K. Ryu. Accelerated algorithms for smooth convex-concave minimax problems with $\mathcal { O } ( 1 / k ^ { 2 } )$ rate on squared gradient norm. In Proc. Intl. Conf. Mach. Learn, 2021.   
+[44] Z. Zhou, P. Mertikopoulos, N. Bambos, S. Boyd, and P. Glynn. Stochastic mirror descent in variationally coherent optimization problems. In Neural Info. Proc. Sys., 2017.

parse/train/U7vVeHydyR/U7vVeHydyR_content_list.json

@@ -0,0 +1,1562 @@
+[
+    {
+        "type": "text",
+        "text": "Fast Extra Gradient Methods for Smooth Structured Nonconvex-Nonconcave Minimax Problems ",
+        "text_level": 1,
+        "bbox": [
+            181,
+            122,
+            818,
+            171
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Sucheol Lee Department of Mathematical Sciences KAIST Daejeon, Republic of Korea csfh1379@kaist.ac.kr ",
+        "bbox": [
+            220,
+            222,
+            472,
+            291
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Donghwan Kim Department of Mathematical Sciences KAIST Daejeon, Republic of Korea donghwankim@kaist.ac.kr ",
+        "bbox": [
+            526,
+            222,
+            777,
+            291
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            327,
+            535,
+            343
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Modern minimax problems, such as generative adversarial network and adversarial training, are often under a nonconvex-nonconcave setting, and developing an efficient method for such setting is of interest. Recently, two variants of the extragradient (EG) method are studied in that direction. First, a two-time-scale variant of the EG, named $\\mathrm { E G + }$ , was proposed under a smooth structured nonconvexnonconcave setting, with a slow $\\mathcal { O } ( \\bar { 1 } / k )$ rate on the squared gradient norm, where $k$ denotes the number of iterations. Second, another variant of EG with an anchoring technique, named extra anchored gradient (EAG), was studied under a smooth convex-concave setting, yielding a fast $\\mathcal { O } ( 1 / k ^ { 2 } )$ rate on the squared gradient norm. Built upon $\\mathrm { E G + }$ and EAG, this paper proposes a two-time-scale EG with anchoring, named fast extragradient (FEG), that has a fast $\\mathcal { O } ( 1 / k ^ { 2 } )$ rate on the squared gradient norm for smooth structured nonconvex-nonconcave problems; the corresponding saddle-gradient operator satisfies the negative comonotonicity condition. This paper further develops its backtracking line-search version, named FEG-A, for the case where the problem parameters are not available. The stochastic analysis of FEG is also provided. ",
+        "bbox": [
+            232,
+            358,
+            766,
+            579
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            604,
+            312,
+            622
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recently, nonconvex-nonconcave minimax problems have received an increased attention in the optimization community and the machine learning community due to their applications to generative adversarial network [10] and adversarial training [27]. In this paper, we consider a smooth structured nonconvex-nonconcave minimax problem: ",
+        "bbox": [
+            174,
+            637,
+            823,
+            693
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "equation",
+        "img_path": "images/34f3ac3a9e2482f1dbde9278f3df5217bf4d4b22aceb6ca5cce31ac1970b7f1b.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\pmb { x } \\in \\mathbb { R } ^ { d _ { \\boldsymbol { x } } } } \\operatorname* { m a x } _ { \\pmb { y } \\in \\mathbb { R } ^ { d _ { \\boldsymbol { y } } } } f ( \\pmb { x } , \\pmb { y } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            423,
+            699,
+            573,
+            724
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "where $f : \\mathbb { R } ^ { d _ { x } } \\times \\mathbb { R } ^ { d _ { y } }  \\mathbb { R }$ is smooth and is possibly nonconvex in $_ { \\textbf { \\em x } }$ for fixed $\\textbf {  { y } }$ , and possibly nonconcave in $\\textbf {  { y } }$ for fixed $_ { \\textbf { \\em x } }$ ; the saddle-gradient operator $\\pmb { F } : = ( \\nabla _ { x } f , - \\nabla _ { y } f )$ satisfies the negative comonotonicity [1]. We construct an efficient (first-order) method, using a saddle gradient operator $\\pmb { F }$ for finding a first-order stationary point of the problem (1). ",
+        "bbox": [
+            174,
+            733,
+            823,
+            790
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "So far little is known under the nonconvex-nonconcave setting, compared to the convex-concave setting. Recent works [4, 7, 22, 24, 26, 42, 44] studied extragradient-type methods [19, 39] for minimax problems under various structured nonconvex-nonconcave settings. In other words, they consider various non-monotone conditions on $\\pmb { F }$ , such as the Minty variational inequality (MVI) condition [4], the weak MVI condition [7], and the negative comonotonicity [1].1 Among them, this paper focuses on the negative comonotonicity condition for a Lipschitz continuous $\\pmb { F }$ . To the best of our knowledge, the following two-time-scale variant of the extragradient method, named $\\mathrm { E G + }$ : ",
+        "bbox": [
+            174,
+            796,
+            825,
+            866
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            90,
+            825,
+            119
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/be87972bb07ea37d3b1242f4c17bf83af8e769a3fe7fd27010661ac3ba8045a2.jpg",
+        "text": "$$\n\\begin{array} { c } { { z _ { k + 1 / 2 } = z _ { k } - \\frac { \\alpha _ { k } } { \\beta } { \\cal F } z _ { k } , } } \\\\ { { z _ { k + 1 } = z _ { k } - \\alpha _ { k } { \\cal F } z _ { k + 1 / 2 } , } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            401,
+            126,
+            596,
+            176
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "is the only known (explicit)2 method, using $\\pmb { F }$ , that converges under the considered setting3 [7], where $z _ { k } : = ( x _ { k } , y _ { k } )$ . The $\\mathrm { E G + }$ , however, has a slow $\\mathcal { O } ( 1 / k )$ rate on the squared gradient norm. Note that a similar two-time-scale approach has been found to stabilize the stochastic extragradient method with unbounded noise variance [14]. ",
+        "bbox": [
+            173,
+            181,
+            825,
+            238
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Meanwhile, under the smooth convex-concave setting, recent works [6, 17, 21, 40, 43] suggest that Halpern-type [12] (or anchoring) methods, performing a convex combination of an initial point $z _ { \\mathrm { 0 } }$ and the last updated point $z _ { k }$ at each iteration, has a fast $\\mathcal { O } ( 1 / k ^ { 2 } )$ rate in terms of the squared gradient norm. In particular, [43] developed the following anchoring variant of the extragradient method, named extra anchored gradient (EAG): ",
+        "bbox": [
+            173,
+            244,
+            825,
+            314
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fd4b411901765ff54f504100c3b3b692556308262a78daf7d60cabe8196e5b11.jpg",
+        "text": "$$\n\\begin{array} { r l } & { z _ { k + 1 / 2 } = z _ { k } + \\beta _ { k } ( z _ { 0 } - z _ { k } ) - \\alpha _ { k } F z _ { k } , } \\\\ & { \\quad z _ { k + 1 } = z _ { k } + \\beta _ { k } ( z _ { 0 } - z _ { k } ) - \\alpha _ { k } F z _ { k + 1 / 2 } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            349,
+            319,
+            648,
+            361
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "This is the first (explicit) method with a fast $\\mathcal { O } ( 1 / k ^ { 2 } )$ rate on the squared gradient norm, when $\\pmb { F }$ satisfies both the Lipschitz continuity and the monotonicity. [43] also showed that such $\\mathcal { O } ( 1 / k ^ { 2 } )$ rate is optimal for first-order methods using a Lipschitz continuous and monotone $\\pmb { F }$ . ",
+        "bbox": [
+            174,
+            364,
+            823,
+            409
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Built upon both $\\mathrm { E G + }$ and EAG, this paper studies the following class of two-time-scale anchored extragradient methods, named fast extragradient (FEG): ",
+        "bbox": [
+            171,
+            414,
+            823,
+            443
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/edd564677a00f9214a567ae965295ad19386acff4b2dc3661561eff2f334dcf9.jpg",
+        "text": "$$\n\\begin{array} { r l } & { z _ { k + 1 / 2 } = z _ { k } + \\beta _ { k } ( z _ { 0 } - z _ { k } ) - ( 1 - \\beta _ { k } ) ( \\alpha _ { k } + 2 \\rho _ { k } ) { \\cal F } z _ { k } , } \\\\ & { ~ z _ { k + 1 } = z _ { k } + \\beta _ { k } ( z _ { 0 } - z _ { k } ) - \\alpha _ { k } { \\cal F } z _ { k + 1 / 2 } - ( 1 - \\beta _ { k } ) 2 \\rho _ { k } { \\cal F } z _ { k } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            243,
+            448,
+            673,
+            488
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "(Class FEG) ",
+        "bbox": [
+            740,
+            460,
+            823,
+            474
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Note that (Class FEG) reuses the $\\pmb { F } z _ { k }$ term in the $z _ { k + 1 }$ update, unlike the standard extragradienttype methods, which we found essential for handling the negative comonotonicity condition. We leave further understanding the use of $\\pmb { F } z _ { k }$ and the formulation of (Class FEG) as future work. The proposed FEG method (with appropriately chosen step coefficients $\\alpha _ { k }$ , $\\beta _ { k }$ and $\\rho _ { k }$ discussed later) has an $\\mathcal { O } ( 1 / k ^ { 2 } )$ rate on the squared gradient norm, under the Lipschitz continuity and the negative comonotonicity conditions on $\\pmb { F }$ . To the best of our knowledge, this is the first accelerated method under the nonconvex-nonconcave setting. The FEG also has value under the smooth convex-concave setting. First, when $\\pmb { F }$ is Lipschitz continuous and monotone, the rate bound of FEG is about 27/4 times smaller than that of EAG. Also note that the rate bound of FEG is only about four times larger than the $\\mathcal { O } ( 1 / k ^ { 2 } )$ lower complexity bound of first-order methods under such setting [43], further closing the gap between the lower and upper complexity bounds. Second, when $\\pmb { F }$ is cocoercive, FEG has a rate faster than that of a version of Halpern iteration [12] in [6]. ",
+        "bbox": [
+            173,
+            492,
+            826,
+            659
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We also develop an adaptive variant of FEG, named FEG-A, which updates its parameters, $\\alpha _ { k }$ and $\\rho _ { k }$ in (Class FEG), adaptively using a backtracking line-search [2, 25, 31]. FEG requires the knowledge of the two problem parameters for the Lipschitz continuity and the comonotonicity of $\\pmb { F }$ . However, those global parameters can be conservative, and in practice, they are even usually unknown. For such cases, the FEG-A adaptively and locally estimates the problem parameters, while preserving the fast rate $\\mathcal { O } ( 1 / k ^ { 2 } )$ on the squared gradient norm for smooth structured nonconvex-nonconcave minimax problems. ",
+        "bbox": [
+            173,
+            665,
+            825,
+            762
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Lastly, we study a stochastic version of FEG, named S-FEG, which uses an unbiased stochastic estimate of $\\pmb { F } z$ , i.e., $\\tilde { F } z = F z + \\xi$ , instead of $\\pmb { F } z$ in FEG, where $\\xi$ denotes a stochastic noise. For a Lipschitz continuous and monotone $\\pmb { F }$ , we provide a convergence analysis in terms of the expected squared gradient norm. In specific, we show that the S-FEG is stable with a rate $\\mathcal { O } ( 1 / k ^ { 2 } ) \\overset { \\cdot } { + } \\mathcal { O } ( \\epsilon )$ , when the noise variance decreases in the order of $\\mathcal { O } ( \\epsilon / k )$ , while being unstable otherwise due to error accumulation. This is similar to the convergence behavior of a stochastic version of Nesterov’s fast gradient method [35, 36], observed in [5], for smooth convex minimization. ",
+        "bbox": [
+            173,
+            767,
+            825,
+            840
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            92,
+            823,
+            119
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our main contributions are summarized as follows. ",
+        "bbox": [
+            174,
+            126,
+            509,
+            140
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "• We propose the FEG method that has an accelerated convergence rate $\\mathcal { O } ( 1 / k ^ { 2 } )$ on the squared gradient norm for smooth structured nonconvex-nonconcave minimax problems.   \nWe present that the FEG method has a rate faster than those of the EAG and the Halpern iteration for smooth convex-concave problems. We construct a backtracking line-search version of FEG, named FEG-A, for the case where the Lipschitz constant and comonotonicity parameters of $\\pmb { F }$ are unavailable.   \n• We analyze a stochastic version of FEG, named S-FEG, for smooth convex-concave problems. ",
+        "bbox": [
+            215,
+            151,
+            825,
+            277
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 Related work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            301,
+            318,
+            318
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 Methods for convex-concave minimax problems ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            333,
+            544,
+            348
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The extragradient method [19] is one of the widely used methods for solving smooth convex-concave minimax problems (see, e.g., [4, 7, 22, 24, 26, 42, 44] for its extensions and applications). In terms of the duality gap, $\\begin{array} { r } { \\operatorname* { m a x } _ { { \\pmb y } ^ { \\prime } \\in \\mathcal { V } } f ( { \\pmb x } , { \\pmb y } ^ { \\prime } ) - \\operatorname* { m i n } _ { { \\pmb x } ^ { \\prime } \\in \\mathcal { X } } f ( { \\pmb x } ^ { \\prime } , { \\pmb y } ) } \\end{array}$ , where $\\mathcal { X }$ and $\\mathcal { V }$ are compact4 domains, the ergodic iterate of the extragradient-type methods [32, 37] have an $\\mathcal { O } ( 1 / k )$ rate. Such $\\mathcal { O } ( 1 / k )$ rate on the duality gap is order-optimal for the first-order methods [34, 38], leaving no room for√ improvement. On the other hand, the last iterate of the extragradient method has a slower $\\mathcal { O } ( 1 / \\sqrt { k } )$ rate on the duality gap, under an additional assumption that $\\pmb { F }$ has a Lipschitz derivative [9]. In terms of the squared gradient norm, $\\| \\ b { F z } \\| ^ { 2 }$ , the best iterate of the extragradient-type methods [19, 39] have an $\\mathcal { O } ( 1 / k )$ rate [40, 41, 43]. The last iterate of the extragradient method also has a rate $\\mathcal { O } ( 1 / k )$ , when $\\pmb { F }$ is further assumed to have a Lipschitz derivative [9]. Unlike the duality gap, the $\\mathcal { O } ( 1 / k )$ rate on the squared gradient norm is not optimal [43]. From now on throughout this paper, we mainly study and compare the convergence rates on the squared gradient norm, which still has room for improvement in convex-concave problems, and has meaning for nonconvex-nonconcave minimax problems, unlike the duality gap. ",
+        "bbox": [
+            173,
+            358,
+            826,
+            554
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Recently, [6, 17, 21, 40, 43] found that Halpern-type [12] (or anchoring) methods yield a fast $\\mathcal { O } ( 1 / k ^ { 2 } )$ rate in terms of the squared gradient norm for minimax problems. [17, 21] showed that the (implicit) Halpern iteration [12] with appropriately chosen step coefficients has an $\\mathcal { O } ( 1 / k ^ { 2 } )$ rate on the squared norm of a monotone $\\pmb { F }$ . Then, for a cocoercive $\\pmb { F }$ , an (explicit) version of the Halpern iteration was studied in [6, 17] that has the same fast rate. In addition, [6] constructed a double-loop version of the Halpern iteration for a Lipschitz continuous and monotone $\\pmb { F }$ , which has a rate $\\tilde { \\mathcal { O } } ( 1 / k ^ { 2 } )$ on the squared gradient norm, slower than the rate $\\mathcal { O } ( 1 / k ^ { 2 } )$ . While this is promising compared to the $\\bar { \\mathcal { O } ( 1 / k ) }$ rate of the extragradient methods on the squared gradient norm [40, 41, 43], the computational complexity due to its double-loop nature and a relatively slow rate remained a problem. Very recently, [43] proposed the extra anchored gradient (EAG) method, which is the first (explicit) method with a fast $\\bar { \\mathcal { O } } ( \\bar { 1 } / k ^ { 2 } )$ rate for smooth convex-concave minimax problems, i.e., for Lipschitz continuous and monotone operators. In addition, [43] proved that the EAG is order-optimal by showing that the lower complexity bound of first-order methods is $\\Omega ( 1 / k ^ { 2 } )$ . ",
+        "bbox": [
+            173,
+            560,
+            825,
+            741
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/809493f0af3a49bfb3fe1ede2a779bf7b12bcbbd732f36c6179ba488ea52db84.jpg",
+        "text": "$$\n\\begin{array} { c c c c c } { { \\mathrm { C o c o e r c i v e } } } & { { \\subseteq } } & { { \\bf M o n o t o n e } } & { { \\subseteq } } & { { \\mathrm { N e g a t i v e ~ c o m o n o t o n e } } } \\\\ { { } } & { { } } & { { | \\bigcap } } & { { } } & { { | \\bigcap } } \\\\ { { } } & { { } } & { { \\mathrm { M V I } } } & { { \\subseteq } } & { { \\mathrm { W e a k ~ M V I } } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            299,
+            762,
+            694,
+            810
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "",
+        "image_caption": [
+            "Figure 1: Relations between the conditions on $\\pmb { F }$ . "
+        ],
+        "image_footnote": [],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 Methods for nonconvex-nonconcave minimax problems ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            90,
+            598,
+            106
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Some recent literature considered relaxing the monotonicity condition of the saddle gradient operator to tackle modern nonconvex-nonconcave minimax problems. For example, the Minty variational inequality (MVI) condition, i.e., there exists $z _ { \\ast } \\in Z _ { \\ast } ( F )$ satisfying $\\langle F z , z - z _ { * } \\rangle \\ge 0$ for all $z \\in \\mathbb { R } ^ { d }$ where $Z _ { * } ( F ) : = \\{ z _ { * } \\in \\mathbb { R } ^ { d } : F z _ { * } = \\mathbf { 0 } \\}$ , is studied in [4, 23, 22, 24]. This condition is also studied under the name, the coherence, in [26, 42, 44]. Moreover, [7] considered a weaker condition, named the weak MVI condition, i.e., for some $\\rho < 0$ , there exists $z _ { \\ast } \\in Z _ { \\ast } ( F )$ satisfying $\\langle F z , z - z _ { * } \\rangle \\geq \\rho \\Vert F z \\Vert ^ { 2 }$ for all $z \\in \\mathbb { R } ^ { d }$ . The weak MVI condition is implied by the negative comonotonicity [1] or, equivalently, the (positive) cohypomonotonicity [3]. The comonotonicity will be further discussed in the upcoming section. ",
+        "bbox": [
+            173,
+            116,
+            825,
+            244
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For $L$ -Lipschitz continuous $\\pmb { F }$ , [4, 42] showed that the extragradient-type methods have an $\\mathcal { O } ( 1 / k )$ rate on the squared gradient norm under the MVI condition, and [7] developed the $( \\mathrm { E G + } )$ method under the weak MVI condition (and thus under the negative comonotonicty), which also has an $\\mathcal { O } ( 1 / k )$ rate on the squared gradient norm. To the best of our knowledge, there is no known accelerated method for the nonconvex-nonconcave setting; our proposed FEG method is the first method to have a fast $\\mathcal { O } ( 1 / k ^ { 2 } )$ rate under the nonconvex-nonconcave setting. The convergence rates of the existing methods and the FEG on the squared gradient norm are summarized in Table 1. ",
+        "bbox": [
+            173,
+            250,
+            825,
+            348
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/43e976f98ce2cace0267d5b149ecb9eb71a4e7aa783f17d781c0a7c59c073923.jpg",
+        "table_caption": [
+            "Table 1: Comparison of the convergence rates of the existing extragradient-type methods and the FEG, with respect to the squared gradient norm, for smooth structured minimax problems, under various assumptions on the Lipschitz continuous saddle gradient operator $\\pmb { F }$ . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\" colspan=\"2\">Method</td><td colspan=\"2\">Convex-concave</td><td colspan=\"3\">Nonconvex-nonconcave</td></tr><tr><td></td><td>Cocoercive Monotone</td><td>Negative comonotone</td><td>MVI</td><td>Weak MVI</td></tr><tr><td rowspan=\"2\">Normal</td><td>EG [4, 42]</td><td>0(1/k)</td><td>0(1/k）</td><td></td><td>0(1/k）</td><td></td></tr><tr><td>EG+[7]</td><td>0(1/k)</td><td>0(1/k)</td><td>0(1/k)</td><td>0(1/k）</td><td>0(1/k）</td></tr><tr><td rowspan=\"2\">Accelerated</td><td>Halpern [12, 6]</td><td>0(1/k²)</td><td>(1/k²)</td><td></td><td></td><td></td></tr><tr><td>EAG [43] FEG (this paper)</td><td>0(1/k2) 0(1/k2)</td><td>0(1/k²) 0(1/k2)</td><td>0(1/k2)</td><td></td><td></td></tr></table>",
+        "bbox": [
+            176,
+            407,
+            820,
+            529
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 Preliminaries ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            554,
+            318,
+            571
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The followings are the two main assumptions for the saddle gradient operator $\\pmb { F }$ of the smooth structured nonconvex-nonconcave problem (1). Under such assumptions, we develop efficient methods that find a first-order stationary point $z _ { \\ast } \\in Z _ { \\ast } ( F )$ where $Z _ { * } ( \\hat { F } ) : = \\{ z _ { * } \\in \\mathbb { R } ^ { d } : \\hat { F } z _ { * } = \\mathbf { 0 } \\}$ . ",
+        "bbox": [
+            174,
+            585,
+            826,
+            627
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Assumption 1 ( $L$ -Lipschitz continuity). For some $L \\in ( 0 , \\infty )$ , $\\pmb { F }$ satisfies ",
+        "bbox": [
+            174,
+            631,
+            665,
+            646
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/58b398d57fdabf5eae781a8cad620b97441318815530f3e4a6e3d730f59592d0.jpg",
+        "text": "$$\n\\| F z - F z ^ { \\prime } \\| \\le L \\| z - z ^ { \\prime } \\| , \\quad \\forall z , z ^ { \\prime } \\in \\mathbb R ^ { d } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            351,
+            651,
+            645,
+            670
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Assumption 2 ( $\\rho$ -Comonotonicity). For some $\\textstyle \\rho \\in { \\bigl ( } - { \\frac { 1 } { 2 L } } , \\infty { \\bigr ) }$ , $\\pmb { F }$ satisfies ",
+        "bbox": [
+            173,
+            676,
+            669,
+            694
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f517a07e39a41fd0b3b884dac93732d30c287f839e2f96809371b781868b805c.jpg",
+        "text": "$$\n\\begin{array} { r } { \\langle F z - F z ^ { \\prime } , z - z ^ { \\prime } \\rangle \\ge \\rho \\| F z - F z ^ { \\prime } \\| ^ { 2 } , \\quad \\forall z , z ^ { \\prime } \\in \\mathbb { R } ^ { d } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            310,
+            699,
+            687,
+            718
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The $\\rho$ -comonotonicity consists of three cases depending on the choice of $\\rho$ ; the negative comonotonicity when $\\rho < 0$ , the monotonicity when $\\rho = 0$ , and the cocoercivity when $\\rho > 0$ . The negative comonotonicity is weaker than the other two, and is the main focus of this paper. The following is an examplary nonconvex-nonconcave condition that is stronger than the negative comonotonicity [1, 3]. ",
+        "bbox": [
+            174,
+            729,
+            826,
+            786
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Example 1. Let $f$ be twice continuously differentiable and $\\gamma$ -weakly-convex-weakly-concave. Further assume that $f$ satisfies ",
+        "bbox": [
+            174,
+            790,
+            825,
+            819
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a80262cf18f822172cf8e321a77ba19488f8a7472e73f345fcb48c608c0dd382.jpg",
+        "text": "$$\n\\begin{array} { r } { \\nabla _ { x x } ^ { 2 } f + \\nabla _ { x y } ^ { 2 } f ( \\eta I - \\nabla _ { y y } ^ { 2 } f ) ^ { - 1 } \\nabla _ { y x } ^ { 2 } f \\succeq \\alpha I , } \\\\ { - \\nabla _ { y y } ^ { 2 } f + \\nabla _ { y x } ^ { 2 } f ( \\eta I + \\nabla _ { x x } ^ { 2 } f ) ^ { - 1 } \\nabla _ { x y } ^ { 2 } f \\succeq \\alpha I , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            339,
+            821,
+            655,
+            866
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "for some $\\alpha \\geq 0$ and $\\eta > \\gamma ,$ , named $\\alpha \\geq 0$ -interaction dominant condition in [11]. Then, the saddle gradient of $f$ satisfies the $- \\frac { 1 } { \\eta }$ -negative comonotonicity. (See Appendix A.1.) For any $\\gamma$ -weaklyconvex-weakly-concave function, the condition (2) holds with $\\alpha = - \\gamma < 0$ . Its extreme case is ",
+        "bbox": [
+            173,
+            867,
+            825,
+            912
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "$\\begin{array} { r } { f ( x , y ) = - \\frac { \\gamma } { 2 } x ^ { 2 } + \\frac { \\gamma } { 2 } y ^ { 2 } } \\end{array}$ , where there is no interaction between x and y. On the other hand, when the   \nthe second terms in the left-hand side of (2) are sufficently positive definite, a nonconvex-nonconave   \nfunction satisfies the condition (2) with a nonnegative condition is satisfied when the interaction term of Hess $\\alpha$ .n cific, the is domin $\\alpha \\geq 0$ -interaction dominantany negative curvature $\\nabla _ { \\substack { x y } } ^ { 2 } f$   \nin Hessians $\\nabla _ { x x } ^ { 2 } f$ and $- \\nabla _ { \\boldsymbol { y } \\boldsymbol { y } } ^ { 2 } f l l l \\boldsymbol { l } \\boldsymbol { l } \\boldsymbol { l } \\boldsymbol { l }$ . ",
+        "bbox": [
+            173,
+            89,
+            825,
+            166
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We next present our proposed FEG, and illustrate that the FEG outperforms existing methods such as $\\mathrm { E G + }$ , EAG, and the Halpern iteration, for each three comonoticity case, respectively. ",
+        "bbox": [
+            173,
+            174,
+            823,
+            204
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 Fast extragradient (FEG) method for Lipschitz continuous and comonotone operators ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            223,
+            730,
+            258
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This section considers an instance of (Class FEG) with $\\begin{array} { r } { \\alpha _ { k } = \\frac { 1 } { L } } \\end{array}$ , $\\begin{array} { r } { \\beta _ { k } = \\frac { 1 } { k + 1 } } \\end{array}$ , and $\\rho _ { k } = \\rho$ for all $k \\geq 0$ The resulting method, named FEG, is illustrated in Algorithm 1, which has an $\\mathcal { O } ( 1 / k ^ { 2 } )$ fast rate with respect to the squared gradient norm, in Theorem 4.1. The proof of Theorem 4.1 is provided in Section 7. ",
+        "bbox": [
+            173,
+            271,
+            826,
+            332
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Fast extragradient (FEG) method ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            344,
+            480,
+            359
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/e6f770a71e1f68a45474304fcaeed89a31d829b4be358d3bc85afcb0ac396edf.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Input: z0 ∈ Rd,L ∈ (0,∞o),ρ ∈(- 2,00) for k = 0,1,... do</td></tr><tr><td>2+1/=+1(2-（1-1）（+2）F 1</td></tr><tr><td></td></tr><tr><td>1 2 2k+1= 2k+ k+1</td></tr></table>",
+        "bbox": [
+            184,
+            361,
+            745,
+            460
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "end for ",
+        "bbox": [
+            189,
+            459,
+            243,
+            473
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Theorem 4.1. For the $L$ -Lipschitz continuous and $\\rho$ -comonotone operator $\\pmb { F }$ with $\\rho > - \\frac { 1 } { 2 L }$ and for any $z _ { \\ast } \\in Z _ { \\ast } ( F )$ , the sequence $\\{ z _ { k } \\} _ { k \\ge 0 }$ generated by FEG satisfies, for all $k \\geq 1$ , ",
+        "bbox": [
+            171,
+            500,
+            823,
+            529
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e2f6cd273461c9b92d8707e1f757dd91d03d1770236f8581afadd094ba3dcb75.jpg",
+        "text": "$$\n\\| F z _ { k } \\| ^ { 2 } \\leq \\frac { 4 \\| z _ { 0 } - z _ { * } \\| ^ { 2 } } { \\Big ( \\frac { 1 } { L } + 2 \\rho \\Big ) ^ { 2 } k ^ { 2 } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            408,
+            536,
+            589,
+            583
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The following example shows that the bound (3) of the FEG is exact for $\\rho = 0$ and $k = 4 l + 2$ . The bound (3) is not known to be exact in general, and we leave finding the exact bound as future work. ",
+        "bbox": [
+            173,
+            595,
+            825,
+            626
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Example 2. Let $f : \\mathbb { R } \\times \\mathbb { R } \\to \\mathbb { R }$ be $f ( x , y ) = L x y .$ . Its saddle gradient operator and solution are $\\pmb { F } ( x , y ) = ( L y , - L x )$ and $z _ { * } = ( 0 , 0 )$ , respectively. For the initial point $z _ { 0 } = ( x _ { 0 } , y _ { 0 } ) =$ $( 1 , 0 )$ , the sequence $\\{ z _ { k } \\} _ { k \\ge 0 }$ generated by FEG satisfies $\\begin{array} { r } { z _ { 4 l + 2 } = \\left( 0 , \\frac { 1 } { 2 l + 1 } \\right) } \\end{array}$ for all $l \\geq 0$ . Hence, $\\begin{array} { r } { \\| F z _ { 4 l + 2 } \\| ^ { 2 } = \\frac { L ^ { 2 } } { ( 2 l + 1 ) ^ { 2 } } = \\frac { 4 L ^ { 2 } \\| z _ { 0 } - z _ { * } \\| ^ { 2 } } { ( 4 l + 2 ) ^ { 2 } } } \\end{array}$ for all $l \\geq 0 .$ . (See Appendix B.1.) ",
+        "bbox": [
+            173,
+            628,
+            826,
+            699
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We next compare the rate bound (3) with existing analyses for the three cases $\\begin{array} { r } { - \\frac { 1 } { 2 L } < \\rho < 0 , \\rho = 0 } \\end{array}$ and $\\rho > 0$ . ",
+        "bbox": [
+            173,
+            709,
+            823,
+            739
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 Comparison to $\\mathbf { E G + }$ under the negative comonotonicity $( \\rho < 0 )$ ) ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            755,
+            651,
+            770
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Under the negative comonotonicity with $\\begin{array} { r } { - \\frac { 1 } { 8 L } < \\rho < 0 } \\end{array}$ , the $( \\mathrm { E G + } )$ method with $\\begin{array} { r } { \\alpha _ { k } = \\frac { 1 } { 2 L } } \\end{array}$ and $\\begin{array} { r } { \\beta = \\frac { 1 } { 2 } } \\end{array}$ rate on the squared gradient norm. To the best of our knowledge, this is the best known rate, and the FEG has a faster $\\mathcal { O } ( 1 \\bar { \\vert } k ^ { 2 } )$ rate with a wider region of convergence $\\begin{array} { r } { - \\frac { 1 } { 2 L } < \\rho < 0 } \\end{array}$ . ",
+        "bbox": [
+            174,
+            780,
+            825,
+            824
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 Comparison to EAG under the monotonicity $( \\rho = 0$ ) ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            839,
+            576,
+            856
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For an $L$ -Lipschitz continuous and monotone operator $\\pmb { F }$ , [43] proposed two EAG methods, named EAG-C and EAG-V, with same βk = 1k+2 but with different choices of $\\alpha _ { k }$ . EAG-C sets $\\alpha _ { k }$ to be a constant $\\frac { 1 } { 8 L }$ for all $k \\geq 0$ in (EAG), and has a large constant 260 in its convergence rate, $\\begin{array} { r } { \\| \\pmb { F } \\pmb { z } _ { k } \\| ^ { 2 } \\le \\frac { 2 6 0 L ^ { 2 } \\| \\pmb { z } _ { 0 } - \\pmb { z } _ { * } \\| ^ { 2 } } { ( k + 1 ) ^ { 2 } } } \\end{array}$ 260L2kz0−z∗k22 for all k ≥ 0. On the other hand, while EAG-V requires a complicated recursive update for {αk}, αk+1 = αk1−α2L2 \u0000 $\\begin{array} { r } { \\alpha _ { k + 1 } = \\frac { \\alpha _ { k } } { 1 - \\alpha _ { k } ^ { 2 } L ^ { 2 } } \\big ( 1 - \\frac { ( k + 2 ) ^ { 2 } } { ( k + 1 ) ( k + 3 ) } \\alpha _ { k } ^ { 2 } L ^ { 2 } \\big ) } \\end{array}$ for all $k \\geq 0$ , with $\\begin{array} { r } { \\alpha _ { 0 } = \\frac { 0 . 6 1 8 } { L } } \\end{array}$ , its rate has a smaller constant 27. ",
+        "bbox": [
+            174,
+            866,
+            825,
+            912
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/380353bbf2580099fbe770143af658fb4debcb8120afd75852aaa71dc5266deb.jpg",
+        "image_caption": [
+            "Figure 2: Numerical result with $\\begin{array} { r } { f ( x , y ) = - \\frac { 1 } { 6 } x ^ { 2 } + \\frac { 2 \\sqrt { 2 } } { 3 } x y + \\frac { 1 } { 6 } y ^ { 2 } } \\end{array}$ . The dashed line represents the theoretical bound (3) of FEG. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            333,
+            95,
+            643,
+            277
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            339,
+            826,
+            398
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The FEG takes a constant $\\begin{array} { r } { \\alpha _ { k } \\ = \\ \\frac { 1 } { L } } \\end{array}$ , unlike EAG-V, but has an even smaller constant 4 in its convergence rate $\\begin{array} { r } { \\| \\pmb { F } \\pmb { z } _ { k } \\| ^ { 2 } \\le \\frac { 4 L ^ { 2 } \\| \\pmb { z } _ { 0 } - \\pmb { z } _ { * } \\| ^ { 2 } } { k ^ { 2 } } } \\end{array}$ 4L2kz0−z∗k2k2 for ρ = 0. Therefore, the FEG with ρ = 0 has about $2 6 0 / 4$ -times and $2 7 / 4$ -times faster convergence rate compared to those of EAG-C and EAG-V, respectively. Furthermore, the rate bound of FEG with $\\rho = 0$ is only about 4-times larger than the lower complexity bound of first-order methods under the considered setting [43], reducing the gap between the lower and upper complexity bounds from 27 to 4. ",
+        "bbox": [
+            173,
+            404,
+            826,
+            494
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 Comparison to the Halpern iteration under the cocoercivity $( \\rho > 0 )$ ) ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            510,
+            679,
+            525
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For a $\\rho$ -cocoercive operator $\\pmb { F }$ , an (explicit) version of Halpern iteration [12], studied in [6], has a fast rate, $\\begin{array} { r } { \\| \\boldsymbol { F } \\boldsymbol { z } _ { k } \\| ^ { 2 } \\le \\frac { \\| \\boldsymbol { z } _ { 0 } - \\boldsymbol { z } _ { * } \\| ^ { 2 } } { \\rho ^ { 2 } k ^ { 2 } } } \\end{array}$ kz0−z∗k2ρ2k2 . Note that while the ρ-cocoercivity implies the 1ρ -Lipschitz continuity, there is case where the $\\rho$ -cocoercive (and thus Lipschitz continuous) operator has a Lipschitz constant $L$ smaller than $\\frac { 1 } { \\rho }$ . Since $\\begin{array} { r } { L \\le \\frac { 1 } { \\rho } } \\end{array}$ , the FEG has a rate $\\begin{array} { r } { \\| \\boldsymbol { F } \\boldsymbol { z } _ { k } \\| ^ { 2 } \\le \\frac { 4 \\| \\boldsymbol { z } _ { 0 } - \\boldsymbol { z } _ { * } \\| ^ { 2 } } { ( 1 / L + 2 \\rho ) ^ { 2 } k ^ { 2 } } = \\frac { 4 \\| \\boldsymbol { z } _ { 0 } - \\boldsymbol { z } _ { * } \\| ^ { 2 } } { 9 \\rho ^ { 2 } k ^ { 2 } } } \\end{array}$ that is faster than that of Halpern iteration. However, if we take into account that the FEG requires computing the saddle gradient twice per iteration, unlike Halpern iteration studied in [6], the FEG method has a slower rate in terms of the number of gradient computations. If we narrow down to the case $\\begin{array} { r } { L < \\frac { 1 } { 2 \\rho } } \\end{array}$ , the FEG has a faster rate, $\\begin{array} { r } { \\| \\ b { F } \\ b { z } _ { k } \\| ^ { 2 } \\leq \\frac { 4 \\| \\ b { z } _ { 0 } - \\ b { z } _ { * } \\| ^ { 2 } } { ( 1 / L + 2 \\rho ) ^ { 2 } k ^ { 2 } } < \\frac { \\| \\ b { z } _ { 0 } - \\ b { z } _ { * } \\| ^ { 2 } } { 4 \\rho ^ { 2 } k ^ { 2 } } } \\end{array}$ . For such case, the FEG has a rate faster than that of the Halpern iteration, even in terms of the number of gradient computations. ",
+        "bbox": [
+            173,
+            535,
+            826,
+            694
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.4 Toy example ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            710,
+            300,
+            727
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "rformed a toy exp, which has an iment on a simple quadratic-Lipschitz continuous and nction, -comon $\\begin{array} { r } { f ( x , y ) = \\frac { \\rho L ^ { 2 } } { 2 } x ^ { 2 } + L \\sqrt { 1 - \\rho ^ { 2 } L ^ { 2 } } x y - } \\end{array}$ ${ \\frac { \\rho L ^ { 2 } } { 2 } } y ^ { 2 }$ $L$ $\\rho$ $\\begin{array} { r } { \\rho = - \\frac { 1 } { 3 L } } \\end{array}$ and $L = 1$ , Figure 2 illustrates that the FEG converges with an accelerated rate whereas $\\mathrm { E G + }$ , EAG-C, EAG-V, and the (explicit) version of Halpern iteration [6] diverge. This example presents that the existing guarantees on convergence and acceleration of the aforementioned methods under the convex-concave setting do not generalize to the nonconvex-nonconcave setting. ",
+        "bbox": [
+            173,
+            736,
+            825,
+            832
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 FEG with backtracking line-search ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            852,
+            500,
+            869
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The FEG requires the knowledge of the two global parameters $L$ and $\\rho$ for Lipschitz continuity and comonotonicity, respectively. Those global parameters are often difficult to compute in practice and can be locally conservative. To handle these two disadvantages, we employ the backtracking line-search technique [2, 25, 31] in FEG. We adaptively decrease the two step size parameters, $\\tau$ and $\\eta$ , to satisfy the both conditions, the local $\\frac { 1 } { \\tau _ { - } }$ -Lipschitz continuity and the $\\frac { \\eta - \\tau } { 2 }$ -comonotonicity.5 A pseudocode of the resulting method, named FEG-A, is illustrated in Algorithm 2. For a detailed description of the FEG-A, see Algorithm 4 in Appendix C.1. ",
+        "bbox": [
+            174,
+            882,
+            823,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            825,
+            162
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 2 Fast extragradient method with adaptive step size (FEG-A) ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            175,
+            650,
+            190
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Input: $\\boldsymbol { z } _ { 0 } \\in \\mathbb { R } ^ { d }$ , $\\tau _ { - 1 } \\in ( \\operatorname* { m a x } \\{ 0 , - 2 \\rho \\} , \\infty )$ , $\\eta _ { 0 } \\in ( 0 , \\infty )$ , $\\delta \\in ( 0 , 1 )$   \nFind the smallest nonnegative integer $i _ { 0 }$ such that $\\hat { z } = { z _ { 0 } - \\tau _ { - 1 } ( 1 - \\delta ) ^ { i _ { 0 } } F z _ { 0 } }$ satisfies $\\Vert \\pmb { F } \\hat { z } -$   \n$\\begin{array} { r } { \\pmb { F } z _ { 0 } \\| \\leq \\frac { 1 } { \\tau _ { - 1 } ( 1 - \\delta ) ^ { i _ { 0 } } } \\| \\hat { \\pmb { z } } - z _ { 0 } \\| } \\end{array}$ .   \n$\\tau _ { 0 } = \\tau _ { - 1 } ( 1 - \\delta ) ^ { i _ { 0 } }$ , $z _ { \\mathrm { 1 } } = z _ { \\mathrm { 0 } } - \\tau _ { 0 } F z _ { \\mathrm { 0 } }$ .   \nfor $k = 1 , 2 , \\ldots$ do $i _ { k } = j _ { k } = 0$ . Increase each $i _ { k }$ and $j _ { k }$ one by one until ",
+        "bbox": [
+            184,
+            194,
+            823,
+            297
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/74a178cf962bc3b725f9e2bc1d72f3bdb7d7506cd2287b60cdddc3505b5ab96b.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\hat { z } _ { k + 1 / 2 } = z _ { k } + \\cfrac { 1 } { k + 1 } ( z _ { 0 } - z _ { k } ) - \\bigg ( 1 - \\cfrac { 1 } { k + 1 } \\bigg ) \\eta _ { k - 1 } ( 1 - \\delta ) ^ { j _ { k } } F z _ { k } \\qquad \\mathrm { a n d } } \\\\ & { \\hat { z } _ { k + 1 } = z _ { k } + \\cfrac { 1 } { k + 1 } ( z _ { 0 } - z _ { k } ) - \\tau _ { k - 1 } ( 1 - \\delta ) ^ { i _ { k } } F z _ { k + 1 / 2 } } \\\\ & { \\qquad - \\bigg ( 1 - \\cfrac { 1 } { k + 1 } \\bigg ) ( \\eta _ { k - 1 } ( 1 - \\delta ) ^ { j _ { k } } - \\tau _ { k - 1 } ( 1 - \\delta ) ^ { i _ { k } } ) F z _ { k } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            253,
+            303,
+            761,
+            398
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "satisfy both conditions, ",
+        "bbox": [
+            214,
+            402,
+            369,
+            416
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c660f47f968af31a63209b2ff8c54203fc5b0e6e1e84c18f83944ce1e9138c84.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\qquad \\| F \\hat { z } _ { k + 1 } - F \\hat { z } _ { k + 1 / 2 } \\| \\le \\frac { 1 } { \\tau _ { k - 1 } ( 1 - \\delta ) ^ { i _ { k } } } \\| \\hat { z } _ { k + 1 } - \\hat { z } _ { k + 1 / 2 } \\| \\qquad \\mathrm { a n d } } \\\\ & { \\qquad \\langle F \\hat { z } _ { k + 1 } - F z _ { k } , \\hat { z } _ { k + 1 } - z _ { k } \\rangle \\ge \\frac { \\eta _ { k - 1 } ( 1 - \\delta ) ^ { j _ { k } } - \\tau _ { k - 1 } ( 1 - \\delta ) ^ { i _ { k } } } { 2 } \\| F \\hat { z } _ { k + 1 } - F z _ { k } \\| ^ { 2 } . } \\\\ & { \\qquad \\frac { \\tilde { \\mathbf { \\phi } } _ { k } } { \\mathrm { \\Delta } r } = \\tau _ { k - 1 } ( 1 - \\delta ) ^ { i _ { k } } , \\eta _ { k } = \\eta _ { k - 1 } ( 1 - \\delta ) ^ { j _ { k } } , z _ { k + 1 } = \\hat { z } _ { k + 1 } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            220,
+            422,
+            784,
+            516
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The following lemma shows that each of the nonincreasing sequences $\\{ \\tau _ { k } \\} _ { k \\ge 0 }$ and $\\{ \\eta _ { k } \\} _ { k \\ge 0 }$ of the FEG-A has a positive lower bound, and thus FEG-A is well-defined6, under the condition $\\rho > - \\frac { \\tau _ { k } } { 2 }$ . This condition for ρ can be weaker than the condition ρ > − 12L of FEG, since the local Lipschitz parameter $\\scriptstyle { \\frac { 1 } { \\tau _ { k } } }$ can be smaller than $L$ . This is another benefit of using a backtracking line-search in FEG, over the standard FEG. ",
+        "bbox": [
+            173,
+            540,
+            826,
+            617
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Lemma 5.1. For the $L$ -Lipschitz and $\\rho$ -comonotone operator $\\pmb { F }$ and a given constant $\\delta \\in ( 0 , 1 )$ , the step size $\\tau _ { k }$ of FEG-A is lower bounded by a positive value $\\begin{array} { r } { \\underline { { \\tau } } : = \\operatorname* { m i n } \\left\\{ \\tau _ { - 1 } , { \\frac { 1 - \\delta } { L } } \\right\\} } \\end{array}$ for all $k \\geq 0$ , and $\\begin{array} { r } { { \\mathfrak { j } } f \\rho > - { \\frac { \\tau _ { k } } { 2 } } } \\end{array}$ , the step size $\\eta _ { k }$ is lower bounded by a positive value $\\operatorname* { m i n } \\left\\{ \\eta _ { 0 } , ( 1 - \\delta ) \\bigl ( \\tau _ { k } + 2 \\rho \\bigr ) \\right\\}$ for all $k \\geq 1$ . ",
+        "bbox": [
+            173,
+            621,
+            826,
+            681
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The FEG-A method also has the following $\\mathcal { O } ( 1 / k ^ { 2 } )$ rate with respect to the squared gradient norm in Theorem 5.1, when $\\rho > - \\frac { \\tau _ { k } } { 2 }$ . The proof is provided in Section 7 and Appendix C.3. ",
+        "bbox": [
+            171,
+            689,
+            823,
+            719
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Theorem 5.1. For the $L$ -Lipschitz and $\\rho$ -comonotone operator $\\pmb { F }$ and for any $z _ { \\ast } \\in Z _ { \\ast } ( F )$ , the sequence $\\{ z _ { k } \\} _ { k \\ge 0 }$ generated by FEG-A satisfies ",
+        "bbox": [
+            173,
+            720,
+            823,
+            750
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5164e93d7f1b4359c7f7f6dbd2162ce4c0504c4aa4073a8adaa11f4154f686bc.jpg",
+        "text": "$$\n\\| F z _ { k } \\| ^ { 2 } \\leq \\frac { 4 \\| z _ { 0 } - z _ { * } \\| ^ { 2 } } { ( ( k - 1 ) \\eta _ { k } + \\tau _ { k } + 2 \\rho ) ^ { 2 } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            377,
+            751,
+            619,
+            789
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "for all $k \\geq 1$ , if $\\rho > - \\frac { \\tau _ { k } } { 2 }$ ",
+        "bbox": [
+            173,
+            789,
+            344,
+            806
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "This rate bound of FEG-A reduces to that of FEG in Theorem 4.1, when we choose $\\begin{array} { r } { \\tau _ { - 1 } = \\frac { 1 } { L } } \\end{array}$ and $\\begin{array} { r } { \\eta _ { 0 } = \\frac { 1 } { L } + 2 \\rho } \\end{array}$ for FEG-A. ",
+        "bbox": [
+            173,
+            815,
+            825,
+            847
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "6 FEG under stochastic setting ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            88,
+            447,
+            107
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "When exactly computing $\\pmb { F } z$ is expensive in practice, one usually instead consider its stochastic estimate for computational efficiency (see, e.g., [13, 16, 26, 33, 40, 42, 44]). This section also considers using a stochastic oracle in FEG for smooth convex-concave problems. In specific, this section assumes that we only have access to a noisy saddle gradient oracle, $\\tilde { F } z _ { k / 2 } = F \\bar { z } _ { k / 2 } + \\xi _ { k / 2 }$ , where $\\{ \\xi _ { k / 2 } \\} _ { k \\geq 0 }$ are independent random variables satisfying $\\mathbb { E } [ \\xi _ { k / 2 } ] = 0$ and $\\mathbb { E } [ \\| \\xi _ { k / 2 } \\| ^ { 2 } ] = \\sigma _ { k / 2 } ^ { 2 }$ for all $k \\geq 0$ . Under this setting, we study a stochastic first-order method, named stochastic fast extragradient (S-FEG) method, illustrated in Algorithm 3. ",
+        "bbox": [
+            173,
+            118,
+            826,
+            224
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 3 Stochastic fast extragradient (S-FEG) method ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            237,
+            562,
+            252
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Input: $\\boldsymbol { z } _ { 0 } \\in \\mathbb { R } ^ { d }$ , $L \\in ( 0 , \\infty )$ . for $k = 0 , 1 , \\ldots$ do ",
+        "bbox": [
+            186,
+            255,
+            387,
+            285
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/382b2e06eef0b6657f3ff684e9fe2da5e9d7a5a736d6b52f6b28cc4a4ba49a8c.jpg",
+        "text": "$$\n\\begin{array} { l } { { z _ { k + 1 / 2 } = z _ { k } + \\displaystyle \\frac { 1 } { k + 1 } ( z _ { 0 } - z _ { k } ) - \\left( 1 - \\displaystyle \\frac { 1 } { k + 1 } \\right) \\displaystyle \\frac { 1 } { L } \\tilde { F } z _ { k } } } \\\\ { { z _ { k + 1 } = z _ { k } + \\displaystyle \\frac { 1 } { k + 1 } ( z _ { 0 } - z _ { k } ) - \\displaystyle \\frac { 1 } { L } \\tilde { F } z _ { k + 1 / 2 } } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            320,
+            282,
+            692,
+            348
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "end for ",
+        "text_level": 1,
+        "bbox": [
+            189,
+            352,
+            243,
+            364
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The following theorem provides an upper bound of the expected squared gradient norm for the S-FEG. (See Appendix D.3 for the proof.) ",
+        "bbox": [
+            173,
+            381,
+            823,
+            410
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Theorem 6.1. Let $\\tilde { F } z _ { k / 2 } = F z _ { k / 2 } + \\xi _ { k / 2 }$ , where $\\{ \\xi _ { k / 2 } \\} _ { k \\geq 0 }$ are independent random variables satisfying $\\mathbb { E } [ \\xi _ { k / 2 } ] = 0$ and $\\mathbb { E } [ \\| \\xi _ { k / 2 } \\| ^ { 2 } ] = \\sigma _ { k / 2 } ^ { 2 }$ for all $k \\geq 0$ . Then, for the $L$ -Lipschitz continuous and monotone operator $F$ and for any $z _ { * } \\in Z _ { * } ( F )$ , the sequence $\\{ z _ { k } \\} _ { k \\ge 0 }$ generated by S-FEG satisfies ",
+        "bbox": [
+            173,
+            412,
+            825,
+            476
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7f9606efa3d23c5eceeaa2b97aa883b0f48834a7c9f80110e6314d9c3d452b63.jpg",
+        "text": "$$\n\\mathbb { E } [ \\| F z _ { k } \\| ^ { 2 } ] \\le \\frac { 4 L ^ { 2 } \\| z _ { 0 } - z _ { * } \\| ^ { 2 } } { k ^ { 2 } } + \\frac { 6 } { k ^ { 2 } } \\left[ \\sigma _ { 0 } ^ { 2 } + \\sum _ { l = 1 } ^ { k - 1 } ( l ^ { 2 } \\sigma _ { l } ^ { 2 } + ( l + 1 ) ^ { 2 } \\sigma _ { l + 1 / 2 } ^ { 2 } ) \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            253,
+            477,
+            743,
+            521
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "for all $k \\geq 1$ . Furthermore, if $\\sigma _ { 0 } ^ { 2 } \\le \\frac { \\epsilon } { 6 }$ , $\\sigma _ { k } ^ { 2 } \\le \\frac { \\epsilon } { 6 k }$ and $\\textstyle \\sigma _ { k + 1 / 2 } ^ { 2 } \\leq \\frac { \\epsilon } { 6 ( k + 1 ) }$ for all $k \\geq 1$ , then the bound (4) reduces to ",
+        "bbox": [
+            171,
+            523,
+            826,
+            554
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/673a740db6b460eeffefa1d512531991080b20378946835845d2546c335a2530.jpg",
+        "text": "$$\n\\mathbb { E } [ \\| F z _ { k } \\| ^ { 2 } ] \\le \\frac { 4 L ^ { 2 } \\| z _ { 0 } - z _ { * } \\| ^ { 2 } } { k ^ { 2 } } + \\epsilon\n$$",
+        "text_format": "latex",
+        "bbox": [
+            380,
+            556,
+            617,
+            589
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "for all $k \\geq 1$ ",
+        "bbox": [
+            171,
+            590,
+            263,
+            606
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Here, we needed the noise variance $\\sigma _ { k / 2 } ^ { 2 }$ to decrease in the order of $\\mathcal { O } ( 1 / k )$ so that the stochastic error of the S-FEG does not accumulate. Otherwise, if $\\sigma _ { k / 2 } ^ { 2 }$ is a constant for all $k$ , the error accumulates with rate ${ \\mathcal { O } } ( k )$ . In short, the S-FEG will suffer from error accumulation, unless the stochastic error decreases with rate $\\mathcal { O } ( 1 / k )$ . Such error accumulation behavior also appears in a stochastic version of Nesterov’s fast gradient method [35, 36] for smooth convex minimization [5, 8]. Similar to [5], we believe that adjusting the step coefficients of the S-FEG can make the S-FEG become relatively stable even with a constant noise, which we leave as future work. ",
+        "bbox": [
+            173,
+            613,
+            826,
+            719
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "7 Convergence analysis with nonincreasing potential lemma ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            737,
+            687,
+            756
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We analyze FEG and FEG-A by finding a nonincreasing potential function in a form $V _ { k } ~ =$ $a _ { k } \\| F z _ { k } \\| ^ { 2 } - b _ { k } \\left. F z _ { k } , z _ { 0 } - z _ { k } \\right.$ in the lemma below. We provide a similar potential lemma for S-FEG in Appendix D.2. The convergence analyses of EAG and Halpern iteration are also based on such potential function [6, 43]. ",
+        "bbox": [
+            173,
+            767,
+            826,
+            824
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Lemma 7.1. Let $\\{ z _ { k } \\} _ { k \\ge 0 }$ be the sequence generated by (Class FEG) with $\\{ \\alpha _ { k } \\} _ { k \\geq 0 } , \\{ \\beta _ { k } \\} _ { k \\geq 0 } ,$ $\\{ L _ { k } \\} _ { k \\ge 0 } \\subset ( 0 , \\infty )$ and $\\{ \\rho _ { k } \\} _ { k \\ge 0 } \\subset \\mathbb { R } ,$ , satisfying $\\alpha _ { 0 } \\in ( 0 , \\infty )$ , $\\textstyle \\alpha _ { k } \\in { \\bigl ( } 0 , { \\frac { 1 } { L _ { k } } } { \\bigr ] }$ , $\\beta _ { 0 } = 1$ , $\\{ \\beta _ { k } \\} _ { k \\ge 1 } \\subseteq$ $( 0 , 1 )$ for all $k \\geq 1$ , and ",
+        "bbox": [
+            173,
+            825,
+            825,
+            873
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e295973a7169ca644968b92ff5d1a1fa708621d1fbf16782684725f666275069.jpg",
+        "text": "$$\n\\frac { ( 1 - \\beta _ { k + 1 } ) } { 2 \\beta _ { k + 1 } } ( \\alpha _ { k + 1 } + 2 \\rho _ { k + 1 } ) - \\rho _ { k + 1 } \\leq \\frac { 1 } { 2 \\beta _ { k } } ( \\alpha _ { k } + 2 \\rho _ { k } ) - \\rho _ { k }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            295,
+            876,
+            700,
+            910
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "for all $k \\geq 0$ . Assume that the following conditions are satisfied. ",
+        "bbox": [
+            171,
+            90,
+            596,
+            106
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/49b2b519ba42b6693179bf8ae5dd8a3bd4b5c97be3b8c358b5251c46eff12ccb.jpg",
+        "text": "$$\n\\begin{array} { c } { { \\| { \\pmb F } { \\boldsymbol z } _ { 1 } - { \\pmb F } { \\boldsymbol z } _ { 0 } \\| \\leq L _ { 0 } \\| { \\boldsymbol z } _ { 1 } - { \\boldsymbol z } _ { 0 } \\| } } \\\\ { { \\| { \\pmb F } { \\boldsymbol z } _ { k + 1 } - { \\pmb F } { \\boldsymbol z } _ { k + 1 / 2 } \\| \\leq L _ { k } \\| { \\boldsymbol z } _ { k + 1 } - { \\boldsymbol z } _ { k + 1 / 2 } \\| } } \\\\ { { \\langle { \\pmb F } { \\boldsymbol z } _ { k + 1 } - { \\pmb F } { \\boldsymbol z } _ { k } , { \\boldsymbol z } _ { k + 1 } - { \\pmb z } _ { k } \\rangle \\geq \\rho _ { k } \\| { \\pmb F } { \\boldsymbol z } _ { k + 1 } - { \\pmb F } { \\boldsymbol z } _ { k } \\| ^ { 2 } } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            267,
+            108,
+            630,
+            165
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Then the potential function ",
+        "bbox": [
+            173,
+            167,
+            352,
+            181
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1d43dcacaaf4f5dd94eb7f8ec44f9db705f678335179477f50b44f6a1ddb97a2.jpg",
+        "text": "$$\nV _ { k } = a _ { k } \\| F z _ { k } \\| ^ { 2 } - b _ { k } \\left. F z _ { k } , z _ { 0 } - z _ { k } \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            369,
+            184,
+            629,
+            202
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "with $\\begin{array} { r } { a _ { 0 } = \\frac { \\alpha _ { 0 } ( L _ { 0 } ^ { 2 } \\alpha _ { 0 } ^ { 2 } - 1 ) } { 2 } } \\end{array}$ , $b _ { 0 } = 0 , b _ { 1 } = 1 ,$ ",
+        "bbox": [
+            174,
+            205,
+            431,
+            227
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4be93e42dfda0c79f0664cc896405edf4cc225f1e62124c32060169ffdeba45f.jpg",
+        "text": "$$\na _ { k } = { \\frac { b _ { k } ( 1 - \\beta _ { k } ) } { 2 \\beta _ { k } } } ( \\alpha _ { k } + 2 \\rho _ { k } ) - b _ { k } \\rho _ { k } a n d b _ { k + 1 } = { \\frac { b _ { k } } { 1 - \\beta _ { k } } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            295,
+            229,
+            702,
+            263
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "for all $k \\geq 1$ satisfies $V _ { k } \\le V _ { k - 1 }$ for all $k \\geq 1$ ",
+        "bbox": [
+            173,
+            265,
+            482,
+            281
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Based on the above potential lemma, we next provide a convergence analysis of FEG. The analyses for the convergence rate of FEG-A and S-FEG, i.e., the proofs of Theorem 5.1 and Theorem 6.1, are similar to that of FEG and are provided in Appendix C.3 and Appendix D.3. ",
+        "bbox": [
+            174,
+            290,
+            825,
+            333
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "7.1 Convergence analysis for FEG ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            347,
+            423,
+            363
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Proof of Theorem 4.1. Recall that FEG is equivalent to (Class FEG) with $\\begin{array} { r } { \\alpha _ { k } = \\frac { 1 } { L } , \\beta _ { k } = \\frac { 1 } { k + 1 } } \\end{array}$ , and $\\rho _ { k } = \\rho$ . It is straightforward to verify that the given $\\{ \\alpha _ { k } \\} _ { k \\ge 0 }$ and $\\{ \\beta _ { k } \\} _ { k \\ge 0 }$ satisfy the conditions in Lemma 7.1 with $L _ { k } = L$ for all $k \\geq 0$ . Since ",
+        "bbox": [
+            176,
+            372,
+            825,
+            416
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/36e62d72f9634c54f042ed2fe814f1d388d8ee2c8e91ac2076dd3ce1bef1823a.jpg",
+        "text": "$$\n\\begin{array} { c } { { a _ { k } = \\displaystyle \\frac { b _ { k } ( 1 - \\beta _ { k } ) } { 2 \\beta _ { k } } ( \\alpha _ { k } + 2 \\rho _ { k } ) - b _ { k } \\rho _ { k } = \\displaystyle \\frac { k ^ { 2 } } { 2 } \\Big ( \\frac 1 L + 2 \\rho \\Big ) - k \\rho \\qquad \\mathrm { a n d } } } \\\\ { { b _ { k } = \\displaystyle \\frac { 1 } { 1 - \\beta _ { k - 1 } } b _ { k - 1 } = \\Big ( \\prod _ { i = 1 } ^ { k - 1 } \\frac 1 { 1 - \\beta _ { i } } \\Big ) b _ { 1 } = k , } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            271,
+            420,
+            728,
+            498
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Lemma 7.1 implies that ",
+        "bbox": [
+            173,
+            501,
+            331,
+            515
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/98caa60be890fc6b4faf7b664b065c56e97985f31c6546a7f24b54a8a26e579e.jpg",
+        "text": "$$\n0 = V _ { 0 } \\geq V _ { k } = \\left( \\frac { k ^ { 2 } } { 2 } \\Big ( \\frac { 1 } { L } + 2 \\rho \\Big ) - k \\rho \\right) \\| F z _ { k } \\| ^ { 2 } - k \\left. F z _ { k } , z _ { 0 } - z _ { k } \\right. .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            264,
+            517,
+            732,
+            553
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Therefore, ",
+        "bbox": [
+            173,
+            555,
+            245,
+            569
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1dfdd9ea91944e95ca9d03700e1fc5e2d6630d84ba1c74aedd4c0e3604a09ecd.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\displaystyle \\frac { k ^ { 2 } } { 2 } \\Big ( \\frac { 1 } { L } + 2 \\rho \\Big ) \\| F z _ { k } \\| ^ { 2 } \\leq k \\langle F z _ { k } , z _ { 0 } - z _ { k } \\rangle + k \\rho \\| F z _ { k } \\| ^ { 2 } } \\\\ & { \\quad \\quad \\quad \\quad = k \\langle F z _ { k } , z _ { 0 } - z _ { * } \\rangle + k \\langle F z _ { k } , z _ { * } - z _ { k } \\rangle + k \\rho \\| F z _ { k } \\| ^ { 2 } } \\\\ & { \\quad \\quad \\quad \\leq k \\langle F z _ { k } , z _ { 0 } - z _ { * } \\rangle \\quad \\quad \\quad \\quad ( \\because \\rho \\mathrm { - c o m o n o t o n i c i t y ~ o f ~ } F ) } \\\\ & { \\quad \\quad \\quad \\quad \\leq k \\| F z _ { k } \\| \\| z _ { 0 } - z _ { * } \\| . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            243,
+            571,
+            754,
+            660
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The desired result follows directly by dividing both sides by $\\begin{array} { r } { \\frac { k ^ { 2 } } { 2 } \\left( \\frac { 1 } { L } + 2 \\rho \\right) \\| F z _ { k } \\| } \\end{array}$ . ",
+        "bbox": [
+            171,
+            661,
+            704,
+            683
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "8 Discussion: first-order methods for Lipschitz continuous operators ",
+        "text_level": 1,
+        "bbox": [
+            169,
+            698,
+            761,
+            715
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Throughout this paper, we studied and constructed efficient methods in a class of first-order methods: ",
+        "bbox": [
+            169,
+            728,
+            823,
+            743
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/03be5922e9969d2018e6ac91d4ae72346b3eff2a43120b876c721ba8237810a6.jpg",
+        "text": "$$\nz _ { k } \\in z _ { 0 } + \\operatorname { s p a n } \\{ F z _ { 0 } , \\cdot \\cdot \\cdot , F z _ { k } \\}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            387,
+            747,
+            611,
+            763
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "denoted by $\\mathcal { A }$ , for smooth structured nonconvex-nonconcave problems. We observed that all existing first-order methods, including the FEG, required an additional condition, such as the negative comonoticity, on a Lipschitz continuous $\\pmb { F }$ to guarantee convergence. One would then be curious whether or not there exists an (efficient) method in class $\\mathcal { A }$ that guarantees convergence without any additional condition on a Lipschitz continuous $\\pmb { F }$ . Unfortunately, the following lemma states that there exists a worst-case7 smooth example that none of the methods in $\\mathcal { A }$ can find its stationary point. The corresponding smooth function is illustrated in Figure 3. ",
+        "bbox": [
+            173,
+            766,
+            826,
+            864
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/417af2708fada253c811f0d36e8f36eb36b53d148b42635dd18fbe25dc8f1b31.jpg",
+        "image_caption": [
+            "Figure 3: A smooth worst-case example $f ( x , y )$ (5) with $L = R = 1$ for first-order methods. any sequence $\\{ z _ { k } \\} _ { k \\ge 0 }$ generated by a first-order method in class $\\mathcal { A }$ starting from $( 0 , 0 )$ is contained in the line $x = y$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            333,
+            114,
+            643,
+            275
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Lemma 8.1. Let us consider the following function $f : \\mathbb { R } ^ { 2 } \\to \\mathbb { R }$ for some $L , R > 0$ : ",
+        "bbox": [
+            171,
+            354,
+            730,
+            372
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "equation",
+        "img_path": "images/337423b721db43d80d764145e8e0607d246394769080daa8296b7c981a4a7770.jpg",
+        "text": "$$\n\\begin{array} { r } { f ( x , y ) = \\left\\{ \\begin{array} { l l } { \\frac { R } { 2 } } & { f o r x < y - \\sqrt { \\frac { R } { L } } } \\\\ { - \\frac { L } { 2 } ( x - y ) ^ { 2 } - \\sqrt { L R } ( x - y ) } & { f o r y - \\sqrt { \\frac { R } { L } } \\leq x < y } \\\\ { \\frac { L } { 2 } ( x - y ) ^ { 2 } - \\sqrt { L R } ( x - y ) } & { f o r y \\leq x < y + \\sqrt { \\frac { R } { L } } } \\\\ { - \\frac { R } { 2 } } & { f o r y + \\sqrt { \\frac { R } { L } } < x . } \\end{array} \\right. } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            277,
+            377,
+            720,
+            474
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Its saddle-gradient operator $\\pmb { F }$ is $L$ -Lipschitz continuous but not comonotone.8 Then, the sequence $\\{ z _ { k } \\} _ { k \\ge 0 }$ generated by any first-order method in class $\\mathcal { A }$ with $z _ { 0 } = ( 0 , 0 )$ satisfies $\\| { \\pmb { F } } { \\pmb { z } } _ { k } \\| ^ { 2 } = 2 L R$ for all $k \\geq 0$ . ",
+        "bbox": [
+            174,
+            482,
+            823,
+            525
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Proof. $\\pmb { F }$ satisfies $F ( x , y ) = ( - \\sqrt { L R } , - \\sqrt { L R } )$ whenever $x = y$ . Hence, for all sequences $\\{ z _ { k } \\} _ { k \\ge 0 }$ satisfying $z _ { 0 } = ( 0 , 0 )$ and $z _ { k } \\in z _ { 0 } + \\operatorname { s p a n } \\{ F z _ { 0 } , \\cdot \\cdot \\cdot , F z _ { k } \\}$ for all $k \\geq 0$ , we have that $\\{ z _ { k } \\} _ { k \\ge 0 } \\subseteq$ $\\{ z = ( x , y ) \\in \\mathbb { R } ^ { 2 } | x = y \\}$ ; thus, $\\| { \\pmb { F } } z _ { k } \\| ^ { 2 } = 2 L R$ for all $k \\geq 0$ . ",
+        "bbox": [
+            173,
+            539,
+            825,
+            584
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The lemma implies that one should consider a class of methods, other than the class $\\mathcal { A }$ , to guarantee finding a stationary point of any smooth problem, which we leave as future work. We also leave finding additional conditions for a Lipschitz continuous $\\pmb { F }$ , weaker than the weak MVI condition and the negative comonotonicity (with $\\begin{array} { r } { { \\Dot { \\rho } } > - \\frac { 1 } { 2 L } ) } \\end{array}$ , which guarantee convergence or its accelerated rate, respectively, as future work. ",
+        "bbox": [
+            173,
+            597,
+            825,
+            667
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "9 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            686,
+            299,
+            704
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This paper proposed a two-time-scale and anchored extragradient method, named FEG, for smooth structured nonconvex-nonconcave problems. The proposed FEG has an accelerated $\\mathcal { O } ( 1 / k ^ { 2 } )$ rate, with respect to the squared gradient norm, for the Lipschitz continuous and negative comonotone operators for the first time. The FEG also has value for smooth convex-concave problems, compared to existing works. We further studied its backtracking line-search version, named FEG-A, for the smooth structured nonconvex-nonconcave problems and studied its stochastic version, named S-FEG, for smooth convex-concave problems. We leave extending this work to stochastic, composite, or more general nonconvex-nonconcave setting and applying to more realistic problems as future work. ",
+        "bbox": [
+            173,
+            718,
+            826,
+            830
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments and Disclosure of Funding ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            88,
+            553,
+            107
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "This work was supported in part by the National Research Foundation of Korea (NRF) grant funded by the Korea government (MSIT) (No. 2019R1A5A1028324), the POSCO Science Fellowship of POSCO TJ Park Foundation, and the Samsung Science and Technology Foundation (No. SSTFBA2101-02). ",
+        "bbox": [
+            174,
+            121,
+            826,
+            178
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            196,
+            267,
+            213
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[1] H. H. Bauschke, W. M. Moursi, and X. Wang. Generalized monotone operators and their averaged resolvents. Mathematical Programming, 189(1):55–74, 2021.   \n[2] A. Beck and M. Teboulle. A fast iterative shrinkage-thresholding algorithm for linear inverse problems. SIAM J. Imaging Sci., 2(1):183–202, 2009.   \n[3] P. L. Combettes and T. Pennanen. Proximal methods for cohypomonotone operators. SIAM J. Control Optim., 43(2):731–42, 2004.   \n[4] C. D. Dang and G. Lan. On the convergence properties of non-Euclidean extragradient methods for variational inequalities with generalized monotone operators. Computational Optimization and Applications, 60(2):277–310, 2015.   \n[5] O. Devolder. Stochastic first order methods in smooth convex optimization, 2011.   \n[6] J. Diakonikolas. Halpern iteration for near-optimal and parameter-free monotone inclusion and strong solutions to variational inequalities. In Conference on Learning Theory, pages 1428–1451. PMLR, 2020.   \n[7] J. Diakonikolas, C. Daskalakis, and M. Jordan. Efficient methods for structured nonconvexnonconcave min-max optimization. In International Conference on Artificial Intelligence and Statistics, pages 2746–2754. PMLR, 2021.   \n[8] S. Ghadimi and G. Lan. Accelerated gradient methods for nonconvex nonlinear and stochastic programming. Mathematical Programming, 156(1):59–99, March 2016.   \n[9] N. Golowich, S. Pattathil, C. Daskalakis, and A. Ozdaglar. Last iterate is slower than averaged iterate in smooth convex-concave saddle point problems. In Conference on Learning Theory (COLT), 2020.   \n[10] I. J. Goodfellow, J. Pouget-Abadie, M. Mirza, B. Xu, D. Warde-Farley, S. Ozair, A. Courville, and Y. Bengio. Generative adversarial networks. In Neural Info. Proc. Sys., 2014.   \n[11] B. Grimmer, H. Lu, P. Worah, and V. Mirrokni. The landscape of the proximal point method for nonconvex-nonconcave minimax optimization, 2020.   \n[12] B. Halpern. Fixed points of nonexpanding maps. Bull. Amer. Math. Soc, 73:957–961, 1967.   \n[13] Y.-G. Hsieh, F. Iutzeler, J. Malick, and P. Mertikopoulos. On the convergence of single-call stochastic extra-gradient methods. In Neural Info. Proc. Sys., 2019.   \n[14] Y.-G. Hsieh, F. Iutzeler, J. Malick, and P. Mertikopoulos. Explore aggressively, update conservatively: Stochastic extragradient methods with variable stepsize scaling. In Neural Info. Proc. Sys., 2020.   \n[15] Y.-P. Hsieh, P. Mertikopoulos, and V. Cevher. The limits of min-max optimization algorithms: convergence to spurious non-critical sets. In Proc. Intl. Conf. Mach. Learn, 2021.   \n[16] A. Juditsky, A. Nemirovski, and C. Tauvel. Solving variational inequalities with stochastic mirror-prox algorithm. Stochastic Systems, 1(1):17–58, 2011.   \n[17] D. Kim. Accelerated proximal point method for maximally monotone operators. Mathematical Programming, 190(1):57–87, 2021.   \n[18] U. Kohlenbach. On the proximal point algorithm and its Halpern-type variant for generalized monotone operators in Hilbert space. Optimization Letters, 2021.   \n[19] G. M. Korpelevich. An extragradient method for finding saddle points and other problems. Ekonomika i Mateaticheskie Metody, 12(4):747–56, 1976.   \n[20] A. Letcher. On the impossibility of global convergence in multi-loss optimization. In Proc. Intl. Conf. on Learning Representations, 2021.   \n[21] F. Lieder. On the convergence rate of the Halpern-iteration. Optimization Letters, 15(2):405–418, 2021.   \n[22] M. Liu, Y. Mroueh, J. Ross, W. Zhang, X. Cui, P. Das, and T. Yang. Towards better understanding of adaptive gradient algorithms in generative adversarial nets. In International Conference on Learning Representations, 2020.   \n[23] M. Liu, H. Rafique, Q. Lin, and T. Yang. First-order convergence theory for weakly-convexweakly-concave min-max problems. J. Mach. Learning Res., 22(169):1–34, 2021.   \n[24] Y. Malitsky. Golden ratio algorithms for variational inequalities. Mathematical Programming, 184(1):383–410, 2020.   \n[25] Y. Malitsky and T. Pock. A first-order primal-dual algorithm with linesearch. SIAM Journal on Optimization, 28(1):411–432, 2018.   \n[26] P. Mertikopoulos, B. Lecouat, H. Zenati, C.-S. Foo, V. Chandrasekhar, and G. Piliouras. Optimistic mirror descent in saddle-point problems: going the extra (gradient) mile. In Proc. Intl. Conf. on Learning Representations, 2019.   \n[27] A. M ˛adry, A. Makelov, L. Schmdit, D. Tsipras, and A. Vladu. Towards deep learning models resistant to adversarial attacks. In Proc. Intl. Conf. on Learning Representations, 2018.   \n[28] A. Mokhtari, A. Ozdaglar, and S. Pattathil. A unified analysis of extra-gradient and optimistic gradient methods for saddle point problems: Proximal point approach. In Proc. Intl. Conf. Artificial Intelligence and Stat. (AISTATS), 2020.   \n[29] R. D. C. Monteiro and B. F. Svaiter. On the complexity of the hybrid proximal extragradient method for the iterates and the ergodic mean. SIAM J. Optim., 20(6):2755–87, 2010.   \n[30] R. D. C. Monteiro and B. F. Svaiter. Complexity of variants of Tseng’s modified FB splitting and Korpelevich’s methods for hemivariational inequalities with applications to saddle-point and convex optimization problems. SIAM Journal on Optimization, 21(4):1688–1720, 2011.   \n[31] M. C. Mukkamala, P. Ochs, T. Pock, and S. Sabach. Convex-concave backtracking for inertial bregman proximal gradient algorithms in nonconvex optimization. SIAM Journal on Mathematics of Data Science, 2(3):658–682, 2020.   \n[32] 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 J. Optim., 15(1):229–51, 2004.   \n[33] A. Nemirovski, A. Juditsky, G. Lan, and A. Shapiro. Robust stochastic approximation approach to stochastic programming. SIAM J. Optim., 19(4):1574–609, 2009.   \n[34] A. Nemirovski and D. Yudin. Problem complexity and method efficiency in optimization. wiley, 1983.   \n[35] Y. Nesterov. A method for unconstrained convex minimization problem with the rate of convergence $O ( 1 / k ^ { 2 } )$ . Dokl. Akad. Nauk. USSR, 269(3):543–7, 1983.   \n[36] Y. Nesterov. Smooth minimization of non-smooth functions. Mathematical Programming, 103(1):127–52, May 2005.   \n[37] Y. Nesterov. Dual extrapolation and its applications to solving variational inequalities and related problems. Mathematical Programming, 109(2-3):319–44, March 2007.   \n[38] Y. Ouyang and Y. Xu. Lower complexity bounds of first-order methods for convex-concave bilinear saddle-point problems. Mathematical Programming, 185(1):1–35, 2021.   \n[39] L. D. Popov. A modification of the Arrow-Hurwicz method for search of saddle points. Mathematical notes of the Academy of Sciences of the USSR, 28(5):845–8, November 1980.   \n[40] E. K. Ryu, K. Yuan, and W. Yin. ODE analysis of stochastic gradient methods with optimism and anchoring for minimax problems and GANs, 2019. arxiv 1905.10899.   \n[41] M. V. Solodov and B. F. Svaiter. A hybrid approximate extragradient–proximal point algorithm using the enlargement of a maximal monotone operator. Set-Valued Analysis, 7(4):323–345, 1999.   \n[42] C. Song, Z. Zhou, Y. Zhou, Y. Jiang, and Y. Ma. Optimistic dual extrapolation for coherent non-monotone variational inequalities. In Neural Info. Proc. Sys., 2020.   \n[43] T. Yoon and E. K. Ryu. Accelerated algorithms for smooth convex-concave minimax problems with $\\mathcal { O } ( 1 / k ^ { 2 } )$ rate on squared gradient norm. In Proc. Intl. Conf. Mach. Learn, 2021.   \n[44] Z. Zhou, P. Mertikopoulos, N. Bambos, S. Boyd, and P. Glynn. Stochastic mirror descent in variationally coherent optimization problems. In Neural Info. Proc. Sys., 2017. ",
+        "bbox": [
+            176,
+            209,
+            828,
+            920
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            63,
+            828,
+            919
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            89,
+            828,
+            361
+        ],
+        "page_idx": 12
+    }
+]

parse/train/rm0I5y2zkG8/rm0I5y2zkG8.md

@@ -0,0 +1,295 @@
+# Learning to Delegate for Large-scale Vehicle Routing
+
+Sirui Li⇤   
+MIT   
+siruil@mit.edu
+
+Zhongxia Yan\* MIT zxyan@mit.edu
+
+Cathy Wu   
+MIT   
+cathywu@mit.edu
+
+# Abstract
+
+Vehicle routing problems (VRPs) form a class of combinatorial problems with wide practical applications. While previous heuristic or learning-based works achieve decent solutions on small problem instances, their performance deteriorates in large problems. This article presents a novel learning-augmented local search framework to solve large-scale VRP. The method iteratively improves the solution by identifying appropriate subproblems and delegating their improvement to a black box subsolver. At each step, we leverage spatial locality to consider only a linear number of subproblems, rather than exponential. We frame subproblem selection as regression and train a Transformer on a generated training set of problem instances. Our method accelerates state-of-the-art VRP solvers by $1 0 \mathrm { x }$ to $1 0 0 \mathrm { x }$ while achieving competitive solution qualities for VRPs with sizes ranging from 500 to 3000. Learned subproblem selection offers a $1 . 5 \mathrm { x }$ to $2 \mathbf { x }$ speedup over heuristic or random selection. Our results generalize to a variety of VRP distributions, variants, and solvers.
+
+# 1 Introduction
+
+Vehicle routing problems (VRPs) have enjoyed ample applications in logistics and ride-hailing services $\mathbb { \left| \left[ 2 . 3 \right] \right| }$ around the world for decades. While determining the optimal solution to a VRP is NP-hard $[ [ 2 5 ] ]$ , there have been numerous attempts to solve VRPs both exactly and approximately: provable algorithms have been designed for specific problem instances up to size $1 3 0 \ \textcircled { 1 2 8 } \textcircled { 1 }$ , and powerful heuristic solvers such as LKH-3 [13] and HGS [49, 48] find good solutions in practice for problems of size more than 1000. However, heuristics methods often suffer from inflexibility due to extensive hand-crafting and the heavy computational burden from lengthy iterative procedures, as in the case of LKH-3. For example, LKH-3 takes more than an hour to solve a size 2000 CVRP instance (Table 1), which is impractical for applications such as large-scale courier or municipal services.
+
+More recently, machine learning methods inspired by the Pointer Network $\left[ \left[ 5 0 \right] \right]$ provide alternatives to traditional solvers: the learning-based methods greatly reduce computation time while maintaining decent solution quality on small problem instances (less than 100 cities), by training on diverse sets of problem distributions either via supervised $\pmb { \| 5 0 \| }$ or reinforcement learning [29, 20]. However, these methods remain difficult to scale, and few report results on problems of size more than 200.
+
+Our work aims to address scalability by learning to identify smaller subproblems which can be readily solved by existing methods. Our learned subproblem selector guides the problem-solving process to focus local improvement on promising subregions. While there exists a combinatorial number of subproblems that can be selected at each step, we leverage spatial locality commonly found in combinatorial optimization problems to restrict the selection space size to be linear in the problem size. Intuitively, objects far away from each other generally have very small influence on each other’s solution and are likely to be in different routes, so they should not be part of the same subproblem. The greatly reduced search space enables us to feasibly train an attention-based subproblem selector.
+
+Our framework combines the advantages of learning and heuristics: our network identifies promising subproblems to improve upon, dramatically speeding up solution times. Using a competitive subsolver on subproblems, we achieve good solution quality without the high computational costs of running the subsolver on large problem instances. In summary, our contributions are:
+
+• We propose learning-to-delegate, a learning-based framework for solving large-scale VRPs by iteratively identifying and solving smaller subproblems. • Despite the high dimensionality and NP-hardness of subproblems, we design a Transformer architecture that effectively predicts the subsolver’s solution quality for a subproblem. • With extensive validation, we show that learning-to-delegate offers significant speedups and/or objective improvements over both its base subsolver and random (or heuristic) subproblem selection, for a variety of VRP variants, distributions, and solvers.
+
+# 2 Preliminary: Capacitated Vehicle Routing Problems (CVRP)
+
+In CVRP, there is a depot node 0 and city nodes $\{ 1 , . . . , N \}$ . Each city node $i$ has demand $d _ { i }$ to fulfill. A vehicle with capacity $C$ starts and ends at the depot and visits a route of city nodes such that the sum of city demands along the route does not exceed $C$ , after which the vehicle starts a new route again. The objective is to find a valid solution minimizing the solution cost. We define the following:
+
+• Route: a sequence of nodes, where the first and last node are the depot 0, and the rest are city nodes. In a valid route, the sum of demands of the city nodes does not exceed $C$ . • Route cost: the sum of edge costs for the sequence of nodes. For an edge from node $i$ to node $j$ , the edge cost is the Euclidean distance between node $i$ and $j$ . • Solution: a feasible solution consists of a set of valid routes visiting each city exactly once. • Solution cost: the sum of route costs for all routes in the solution. An optimal solution is a feasible solution with the minimum solution cost. • Subproblem: a CVRP consisting of the depot, a subset of cities, and corresponding demands.
+
+# 3 Related Work
+
+Classical methods. Heuristics for solving combinatorial optimization problems have been studied for decades. The most powerful methods, such as local search $\mathbb { M }$ , genetic algorithms $\left[ \left[ 3 6 \right] \right]$ , and ant colony methods $\mathbb { m }$ , involve iteratively improving the solution in a hand-designed neighborhood. For example, move, swap $[ [ 5 2 ] ]$ , and 2-opt $\dot { \bigtriangledown }$ are well-known heuristics for the traveling salesman and vehicle routing problems. The competitive VRP solver LKH-3 [13] uses the Lin–Kernighan heuristic $\pmb { \Vert 2 6 \Vert }$ as a backbone, which involves swapping pairs of sub-routes to create new routes, whereas the CVRP solver HGS [49, 48] uses a hybrid genetic and local search procedure to achieve state-of-the-art solution qualities on problems up to size 1000. While LKH- $3 ^ { \overset { . } { 2 } }$ tackles a variety of VRP variants, the publicly available implementation of $\mathrm { H G S } \big \triangledown$ only solves CVRP.
+
+For large problems, low-level heuristics are combined with meta-heuristics, including Tabu Search with Adaptive Memory $\mathbb { \left[ \left[ 4 0 \right] \right] }$ , guided local search $\mathbb { B }$ , and Large Neighborhood Search $\pmb { \Vert 3 5 \Vert }$ . The inspiration for our work derives from Partial OPtimization Metaheuristic Under Special Intensification Conditions (POPMUSIC), which iteratively optimizes problem subparts and has been used to solve problems as diverse as map labeling $\pmb { \Vert 2 4 \Vert }$ , berth allocation $[ [ 2 2 ] ]$ , and $p$ -median clustering $\pmb { \| 3 9 \| }$ .
+
+Despite the promise of the POPMUSIC framework for large-scale combinatorial optimization, the impact of certain design choices is not well understood, such as the subproblem selection ordering and size $\mathbb { \lVert \rVert 3 \rVert }$ . For example, it is not clear how to meaningfully order the subproblems. One early work in this direction demonstrated that a last-in-first-out stack order performs better than random $\pmb { \| }$ Our work provides a natural approach to order the subproblems based on predicted improvement.
+
+![](images/c61c357c5ae3dd7e7a7a4b1eb79b16268270b1826629f535d2cc4ba39a18d619.jpg)  
+Figure 1: Our iterative framework for VRPs. (a) At each time step, we start with a current solution $X$ . Circles are city nodes, blue lines are route segments, and the red star is the depot. (b) We aggregate each route by taking the centroid of all city nodes in the route. (c) For each route, we define a corresponding subproblem as the $k$ -nearest neighbors of the route. Two such subproblems with $k = 3$ are shown. (d) Our subproblem selector selects a subproblem $S$ (yellow). (e) We feed $S$ into the subsolver to get a new subsolution $X _ { S } ^ { \prime }$ . The red edges are updated by the subsolver. (f) We update $X$ to new solution $X ^ { \prime }$ with $X _ { S } ^ { \prime }$ , then repeat (b)-(f).
+
+Deep learning methods. Recently, there has been a surge of interest in training deep neural networks (DNN) to solve combinatorial problems. As observed by Kwon et al. [21], most methods fall into one of the following two categories: 1) construction methods $\pm \pmb { \mathbb { Z } } 9 \pm \pmb { \mathbb { Z } } 0 \|$ , where an autoregressive model such as the Pointer Network $\pmb { \Vert 5 0 \Vert }$ directly outputs a solution, and 2) improvement methods [7, 15], where the DNN iteratively performs local updates to the solution, resembling local search.
+
+These methods are approaching the solution quality of LKH-3 [13] on small problem instances. For example, Kwon et al. $\pmb { \mathbb { \left| \left[ 2 \right] \right| } }$ extends a construction approach $\pmb { \mathbb { Z } } 0 \|$ to encourage more diverse output samples on $N \leq 1 0 0$ VRPs. Among improvement methods, Lu et al. $\mathbb { \left[ \left[ 2 \right] \right] }$ learn a meta-controller to select among a set of local search heuristics, marking the first learning-based approach to outperform LKH-3 on $N \leq 1 0 0$ VRPs. Despite these successes, learning-based approaches for large-scale VRPs are poorly understood. In addition, all of the aforementioned methods are trained using deep reinforcement learning; for large problems, trajectory collection becomes prohibitively expensive.
+
+Scaling up learning methods. A few recent works have begun to investigate scaling of learned networks for NP-hard graph problems. For example, Ahn et al. [2] propose an iterative scheme called learning-what-to-defer for maximum independent set. At each stage, for each node in the graph, the network either outputs the solution for the node or defers the determination to later stages. Song et al. $\pmb { \Vert 3 8 \Vert }$ proposes an imitation-learning-based pipeline for Integer Linear Programs (ILP), where at each stage they partition all variables into disjoint subsets, and use the Gurobi $\lVert \overline { { 1 2 } } \rVert$ ILP solver to solve the partitions. Due to differences in graph structure, our work presents a more natural scheme to handle VRP constraints and structures. A few works attempt to incorporate learning to decompose large-scale VRPs [6, 47, 31]. However, the decomposition approaches proposed appear to be experimentally less effective than ours.
+
+# 4 An Iterative Framework for VRPs
+
+While CVRPs are NP-hard and thus require worst-case exponential time in the problem size to solve optimally, typical CVRPs exhibit structure that practical solvers may exploit. We hypothesize that in such situations, the larger problem can be efficiently approximately solved as a sequence of smaller subproblems, which can be delegated to efficient subsolvers. To test this hypothesis, we propose a learning-based, iterative framework with two components: 1) a subsolver capable of solving a small problem instance (exactly or approximately), and 2) a learned model for identifying suitable subproblems within a larger problem to delegate to the subsolver.
+
+# Algorithm 1: Learning to Delegate
+
+Input: Problem instance $P$ , initialized solution $X$ , subproblem selector $f _ { \theta }$ , subsolver Subsolver, number of steps $T$ , parameter $k$ denoting the size of subproblems 1 for Step $t = l \colon T$ do 2 $S _ { k , \mathrm { l o c a l } } $ ConstructSubproblems $( P , X , k )$ 3 $S \gets f _ { \theta } ( S _ { k , \mathrm { l o c a l } } )$ 4 $X _ { S } ^ { \prime } \gets \mathrm { S u b s o l v e r } ( S )$ 5 $X  X _ { S } ^ { \prime } \cup X _ { P \backslash S }$ 6 end for
+
+We illustrate our iterative framework in Figure $\bigtriangledown$ which takes in a problem instance $P$ with a feasible initial solution $X _ { 0 }$ . At each step, given the current solution $X$ , we select a smaller subproblem $S \subset P$ with our learned model $f _ { \theta }$ then apply the subsolver to solve $S$ ; we then update $X$ with the new solution for $S$ . To maintain feasibility after an update, we restrict $S$ to be the set $s$ of visited cities of a subset of routes from $X$ . Since routes with cities in $P \backslash S$ remain valid routes, we obtain a new feasible solution $X ^ { \prime } = X _ { S } ^ { \prime } \cup X _ { P \backslash S }$ , where $X _ { S } ^ { \prime }$ is the subsolution for $S$ and $X _ { P \backslash S }$ consists of unselected routes from $X$ . Intuitively, a strong $f _ { \theta }$ should identify a subproblem $S$ such that the subsolver solution $X _ { S } ^ { \prime }$ results in a large improvement in objective from $X$ to $X ^ { \prime }$ .
+
+# 4.1 The Restricted Subproblem Selection Space
+
+As the number of routes in $P$ is $R = O ( N )$ , the cardinality of the selection space $s$ is $O ( 2 ^ { R } )$ , which is exponential in the problem size $N$ and difficult for learned models to consider. If we restrict each subproblem to cities from exactly $k$ routes, there are still ${ \binom { R } { k } } = O ( R ^ { k } )$ subproblems to consider. Therefore we further restrict selection to subproblems with spatial locality. As shown in Figure $1 ( \mathrm { d } )$ , we only consider subproblems from $\boldsymbol { S } _ { k , \mathrm { l o c a l } }$ , where each subproblem is centered around a particular route $r$ and contains the $k$ routes whose centroids have the smallest Euclidean distance to the centroid of $r$ . In this way, we reduce the selection space to $| S _ { k , \mathrm { l o c a l } } | = R = O ( N )$ from $| S | = O ( 2 ^ { N } )$ . In Algorithm 1, we refer to this restriction as ConstructSubproblems. Our restriction to a local selection space is motivated by the fact that many combinatorial optimizations problems have inherent spatial locality, i.e. problem entities are more strongly affected by nearby entities than faraway entities. Earlier heuristical methods such as POPMUSIC $\lVert \boldsymbol { 4 2 } \rVert$ leverage similar spatial locality.
+
+# 5 Learning to Delegate
+
+In this section, we discuss criteria for selecting subproblems, and how to train the subproblem selector.
+
+Improvement as the criteria for subproblem selection. Given a selected subproblem $S$ with a current solution $X _ { S }$ on the subproblem, we obtain from LKH-3 a new solution $X _ { S } ^ { \prime }$ on the same subproblem (step $( d )$ to $( e )$ in Figure $\textcircled { 1 }$ . We then define the immediate improvement
+
+$$
+\delta ( S ) = c ( X _ { S } ) - c ( X _ { S } ^ { \prime } )
+$$
+
+where $c ( X _ { S } )$ is the total cost of subsolution $X _ { S }$ and $\delta ( S )$ is the improvement in the solution cost. In this way, the sum of improvements along $T$ steps is the total improvement in solution quality. As we empirically find that providing the previous subsolution $X _ { S }$ to the subsolver may trap the subsolver in a local optimum, we withhold $X _ { S }$ from the solver and thus may see non-positive improvement $\delta ( S ) \leq 0$ , especially after many steps of subproblem selection. At test time, to avoid worsening the objective, we adopt a hill-climbing procedure such that when $\delta ( S ) \leq 0$ , we keep $X _ { S }$ instead of $X _ { S } ^ { \prime }$ (Figure $^ { 1 , }$ step $( e )$ ). With proper masking, we avoid selecting the same non-improving subproblem $S$ again. The hill-climbing and masking procedures are applied to both our subproblem-selection network $f _ { \theta }$ and the three heuristic selection rules, described in $6 . 1 ,$ to maintain fair comparisons.
+
+![](images/338568a46cb8baf3cd5a80c1ef63c6249f557837d16e45735f3b99631eeda14b.jpg)  
+Figure 2: Our Transformer architecture. At each step of our framework (Figure $1 ( \mathrm { c } ) \mathrm { \sharp ~ }$ , we featurize subproblem $S \in S _ { k , \mathrm { l o c a l } }$ into a column vector of unordered cities. We apply the Transformer encoder with multiple multi-head attention layers and a final linear layer, before mean-pooling over the cities to generate the predictions $f _ { \theta } ( S )$ , which we fit to the subsolution cost $c ( X _ { S } ^ { \prime } )$ . When possible, we retrieve a previously predicted subproblem from a cache to minimize computation.
+
+Subproblem selection. The goal of our subproblem selector is to select the subproblem leading to the best immediate improvement. While our subproblem selection does not directly optimize for the total improvement, we observe that (1) our subsolver may perform many low-level operations internally, so high-level problem selection may still benefit greatly from maximizing the immediate improvement, and (2) numerous reinforcement learning approaches to VRP $\lVert \tilde { 5 3 } \rVert \textcircled { 1 8 } \rVert$ choose a small discount factor such as $\gamma = 0 . 2 5$ when optimizing a multi-step objective $\sum _ { t = 1 } ^ { T } \gamma ^ { t } \delta _ { t }$ , as doing so encourage faster convergence. Moreover, our subproblem selector may instead be trained on multi-step search data to select subproblems offering the best multi-step improvement.
+
+Ground-truth labels. Our restricted selection space allows us to enumerate all possible subproblems at each step. In a typical large scale CVRP instance with $N = 2 0 0 0$ cities, a solution consists of roughly $R = 2 0 0$ routes, so the size of the selection space is 200. We obtain the immediate improvement $\delta ( S )$ by running the subsolver on each subproblem $S \in S _ { k , \mathrm { l o c a l } }$ . Although our enumeration strategy is feasible for generating training data, it is much too slow to execute on a test CVRP instance. However, if our subproblem selector can predict the best immediate improvement at test time (that is, without running the subsolver on multiple subproblems), then we can combine the best of both worlds to obtain a fast and accurate selection strategy.
+
+Selection strategies: regression vs classification. Given a labeled dataset, we may treat the task of identifying the best subproblem as either regression or classification. In the context of imitation learning with a greedy expert, the former learns a value function while the latter learns a policy. Due to space limitation, we focus discussion on regression and reserve comparison with classification for Appendix A.5.1. The regression-based subproblem selector uses a trained $f _ { \theta }$ to predict the subsolution cost $c ( X _ { S } ^ { \prime } )$ ; we then simply compute arg maxS $c ( X _ { S } ) - f _ { \theta } ( S )$ to select the best subproblem.
+
+Network architecture. We define $f _ { \theta }$ with a Transformer encoder architecture $\lVert \rVert 5 \rVert$ . The input representing each subproblem $S$ is the unordered set of featurized cities in $S$ . The features for each city consist of the demand $d$ and the location of the city $( x , y )$ relative to the depot. As we do not feed the existing subsolution $X _ { S }$ to the subsolver, the dense multi-head attention mechanism does not need to be modified to take the routes in $X _ { S }$ into account. The output of the Transformer encoder is fed into a linear layer then mean-pooled to obtain the scalar prediction $f _ { \theta } ( S )$ . In Appendix A.5.5, we perform an ablation study with simpler architectures.
+
+Loss function. We empirically find mean squared error to be less stable than Huber loss $\mathbb { \lVert \boldsymbol { 1 6 } \rVert }$ , which we set as our loss function
+
+$$
+L ( \theta ; S ) = \left\{ \begin{array} { l l } { \frac { 1 } { 2 } ( f _ { \theta } ( S ) - c ( X _ { S } ^ { \prime } ) ) ^ { 2 } , } & { \mathrm { i f ~ } \lvert f _ { \theta } ( S ) - c ( X _ { S } ^ { \prime } ) \rvert \le 1 } \\ { \lvert f _ { \theta } ( S ) - c ( X _ { S } ^ { \prime } ) \rvert - \frac { 1 } { 2 } , } & { \mathrm { o t h e r w i s e } } \end{array} \right.
+$$
+
+![](images/eb27d355ab5068322cf3b126dced1febb93f07ae703733694405d907d2eb5fc0.jpg)  
+Figure 3: Instances from $N = 2 0 0 0$ CVRP distributions. From left to right: instance from uniform, mixed ${ \mathrm { ' } n _ { c } = 7 }$ cluster centers), clustered ${ { n } _ { c } } = 3$ cluster centers), and real-world. The red star is the location of the depot, while blue dots are cities sized proportional to demand.
+
+# 6 Experiments and Analysis
+
+We illustrate the CVRP distributions considered in our work in Figure $\textcircled{3}$ We perform extensive experiments to evaluate our learning framework, aiming to answer the following questions:
+
+1. Uniform distribution. How does our method compare with baselines, in terms of solution time and quality, on problems with uniformly distributed cities?   
+2. Clustered distributions. How does our method perform on problems with clustered cities?   
+3. Out-of-distribution. Can our model generalize, such as to larger or real-world instances?   
+4. VRP variants. Can our method address more sophisticated VRPs? E.g., CVRP with Time Windows (CVRPTW) $\pmb { \Vert 3 7 } \Vert$ or VRP with Mixed Pickup and Delivery (VRPMPD) [33].   
+5. VRP solvers. Can our method be adapted to leverage other VRP subsolvers?
+
+We reserve additional ablations on subproblem selection as classification, effect of subproblem size $k$ and discussion of asymptotic behavior, subproblem selection with the HGS subsolver, effect of weaker initialization methods, and comparison with simpler architectures for Appendix A.5.
+
+# 6.1 Setup
+
+We briefly describe experimental setup in the main text and defer full details to Appendix A.1. Given a particular distribution of VRP, we generate separate sets of training, validation, and test problem instances. Unless otherwise stated, our validation and test sets contain 40 instances each. For each problem instance, we generate a rough initial solution by partitioning it into disjoint subsets of cities and briefly running the subsolver on each subset. Due to its compatibility with many VRP variants, we use LKH-3 $\checkmark$ as the subsolver for all VRP distributions unless otherwise stated.
+
+We generate the training set by running our iterative framework and selecting subproblems by enumerating the subsolver on all $S \in S _ { k , \mathrm { l o c a l } }$ . As many subproblems remain unchanged from $X$ to $X ^ { \prime }$ , we use previously cached subsolutions when possible instead of re-running the subsolver. While generation times differ depending on several factors, typically it takes less than 10 hours with 200 Intel Xeon Platinum 8260 CPUs to generate a training set of 2000 instances.
+
+To avoid training multiple models for different problem sizes $N$ , we train a single model for each VRP distribution with combined data from multiple $N \in \{ 5 0 0 , 1 0 0 0 , 2 0 0 0 \}$ . Training takes at most 8 hours on a single NVIDIA V100 GPU. To exploit symmetry in problem instances, we apply rotation and flip augmentation at training time. To evaluate trained selectors on a problem instance, we run the iterative selection framework on a single CPU, with disabled multithreading and no GPU.
+
+We select the best hyperparameters via manual search based on validation set performance. We record final results on the test set as the mean and standard error over 5 runs with different random seeds.
+
+Baselines. By default, as we use LKH-3 as the subsolver, we run LKH-3 on the full problem instances with our initialization for 30000 local update steps, which takes 2-3 hours on average for $N = 2 0 0 0$ . If using HGS as the subsolver, we also run HGS on the full problem instances for the same amount of time as our LKH-3 baseline. These baselines allow us to compute the speedup of our framework over the subsolver alone. We also compare against OR Tools $\pmb { \mathbb { B } } \mathbf { \bar { 0 } } \mathbf { \mathbb { I } }$ , another open source heuristic VRP solver employing iterative search, terminating runs at 15 minutes, as OR Tools stops improving the solution within this time for all instances.
+
+Table 1: Performance and computation time for uniform CVRP. For problem instance sizes $N \in \{ 5 0 0 , 1 0 0 0 , 2 0 0 0 \}$ , we report the objective values (lower is better) of our method and baseline methods, averaged across all instances in the test set. Note that the cost is the total distance of routes in the solution. LKH-3 (30k) runs LKH-3 for $3 0 \mathrm { k }$ steps to near convergence, while LKH-3 $( 9 5 \% )$ is the $9 5 \%$ solution quality. Random, Count-based, Max Min Distance, and Ours (Short) run until matching LKH-3 $( 9 5 \% )$ in solution quality, with the speedup reported in parentheses, while Ours (long) runs for twice amount time as Ours (Short).   
+
+<table><tr><td></td><td colspan="2">N= 500</td><td colspan="2">N = 1000</td><td colspan="2">N = 2000</td></tr><tr><td>Method</td><td>Cost</td><td>Time</td><td>Cost</td><td>Time</td><td>Cost</td><td>Time</td></tr><tr><td>LKH-3 (95%)</td><td>62.00</td><td>4.4min</td><td>120.02</td><td>18min</td><td>234.89</td><td>52min</td></tr><tr><td>LKH-3 (30k)</td><td>61.87</td><td>30min</td><td>119.88</td><td>77min</td><td>234.65</td><td>149min</td></tr><tr><td>OR Tools</td><td>65.59</td><td>15min</td><td>126.52</td><td>15min</td><td>244.65</td><td>15min</td></tr><tr><td>AM sampling</td><td>69.08</td><td>4.70s</td><td>151.01</td><td>17.40s</td><td>356.69</td><td>32.29s</td></tr><tr><td>AM greedy</td><td>68.58</td><td>25ms</td><td>142.84</td><td>56ms</td><td>307.86</td><td>147ms</td></tr><tr><td>NeuRewriter</td><td>73.60</td><td>58s</td><td>136.29</td><td>2.3min</td><td>257.61</td><td>8.1min</td></tr><tr><td>Random</td><td>61.99</td><td>71s (3.8x)</td><td>120.02</td><td>3.2min (5.5x)</td><td>234.88</td><td>6.4min (8.0x)</td></tr><tr><td>Count-based</td><td>61.99</td><td>59s (4.5x)</td><td>120.02</td><td>2.1min (8.2x)</td><td>234.88</td><td>5.3min (10x)</td></tr><tr><td>Max Min</td><td>61.99</td><td>59s (4.5x)</td><td>120.02</td><td>2.5min (7.0x)</td><td>234.89</td><td>5.2min (10x)</td></tr><tr><td>Ours (Short)</td><td>61.99</td><td>38s (7.0x)</td><td>119.87</td><td>1.5min (12x)</td><td>234.89</td><td>3.4min (15x)</td></tr><tr><td>Ours (Long)</td><td>61.70</td><td>76s</td><td>119.55</td><td>3.0min</td><td>233.86</td><td>6.8min</td></tr></table>
+
+We include results for previous learning methods AM $\mathbb { \left[ \left[ 2 0 \right] \right] }$ and NeuRewriter $\mathbb { H }$ . These do not outperform LKH-3 even on small problem sizes, and learning methods have had more difficulty generalizing to larger instances. In fact, these methods are trained on problems of size $N \leq 1 0 0$ , and we find that they yield poor solutions on $N \geq 5 0 0$ without architecture modifications and extensive re-training. The AM and NeuRewriter results demonstrate the difficulty of scaling up previous learning methods. We do not initialize OR-Tools, AM, and NeuRewriter because we empirically find that these methods have limited solution capability and do not improve our decent initialization.
+
+To validate our subproblem selector’s ability to identify promising subproblems, we design three additional baselines that employ our iterative framework using hand-crafted heuristics to select subproblems. The three heuristics that we use are: (1) Random, selecting subproblem $S$ from $\boldsymbol { S } _ { k , \mathrm { l o c a l } }$ uniformly; (2) Count-based, which avoids repetitive selections by selecting the subproblem centered at the route whose city nodes have been selected cumulatively the least often in previous steps; and (3) Max Min Distance, which encourages coverage of the entire problem instance by selecting subproblems with the maximum distance from the nearest centroid of previously selected subproblems. We run the heuristic baselines with the same setup as our learned subproblem selector.
+
+Metrics. We refer to two metrics to compare our method against baseline methods.
+
+1. Improvement over method $\mathbf { X }$ : at a specified computation time, the improvement of method Y over method X is the total improvement of method Y minus that of method X.
+
+2. Speedup over method X: at a specified solution quality that method X attains, the speedup of method $\mathrm { Y }$ over method $\mathbf { X }$ is the computation time required for method $\mathbf { X }$ to attain the solution quality divided by the time for method $\mathrm { Y }$ to attain the solution quality.
+
+We define $9 5 \%$ solution quality of running a method $\mathbf { X }$ over a computation time as the solution quality with $9 5 \%$ of the total improvement. We report speedup at $9 5 \%$ solution quality of a method $\mathrm { X }$ because X may take a disproportionate amount of time on the last $5 \%$ of improvement; reporting speedup at $100 \%$ solution quality inflates the speedup.
+
+![](images/7ad23903e592d1abb1776322c0f1bf396cadb17f92185bbbd5cea15b8b84bde5.jpg)  
+Figure 4: Improvement over LKH-3 for uniform CVRP. The $\mathbf { X }$ -axis is the computation time and extends until LKH-3 has completed $3 0 \mathrm { k }$ steps. The vertical lines represent the computation times of Ours (Short) and Ours (Long) from Table $^ { 1 . }$ The three subplots correspond to $N = 5 0 0$ (left), $N = 1 0 0 0$ (middle), and $N = 2 0 0 0$ (right).
+
+![](images/cf8f6b9efdfada0d6762a9ae9da29538986f7ab8068d7f68b1169a5c3f497f53.jpg)  
+Figure 5: Speedup over LKH-3 for uniform CVRP. The $\mathbf { X }$ -axis is the solution quality attained, measured as a percentage of the LKH-3’s maximum improvement. The dashed vertical line represents the $9 5 \%$ solution quality used to compute the speedup, as mentioned in Table 1. The three subplots correspond to $N = 5 0 0$ (left), $N = 1 0 0 0$ (middle), and $N = 2 0 0 0$ (right).
+
+# 6.2 Uniform CVRP Distribution
+
+As seen in Table $^ { 1 , }$ our method achieves the best performance for all problem sizes, matching LKH-3’s solution quality with more than $7 \mathbf { x }$ to $1 5 \mathrm { x }$ less computation time and offering even more improvements with longer computation time. Although we need to evaluate all $R = { \bar { O } } ( N )$ subproblems of the initial solution with our subproblem selector, subsequent per-step computation time of our method is mostly independent of the problem size $N$ since we only evaluate changed subproblems.
+
+Running LKH-3 for $3 0 \mathrm { k }$ local update steps achieves superior performance to all previous other heuristic and learning-based baselines. Its solution quality scales well to large problem sizes, yet the solution time is significantly longer. Previous learning-based methods, though fast, result in much worse solution qualities. Our heuristic baselines Random, Count-based, and Max Min Distance demonstrate that our iterative framework, even without the learned subproblem selector, may achieve over $5 \mathbf { x }$ to $1 0 \mathrm { x }$ speedup over LKH-3. Nevertheless, our results demonstrate that learning the subproblem selector may offer an additional $1 . 5 \mathrm { x }$ speedup over non-learning heuristics.
+
+In Figure 4, we demonstrate the solution quality of our method and baselines compared to LKH-3. We see that, compared to baseline methods, the learned subproblem selector obtains the best solution quality when run for a reasonable amount of time. The improvement of most methods based on our iterative framework converge when run for an excessive amount of time; this is unsurprising, as Random and other baselines are eventually able to select all subproblems offering improvements.
+
+In Figure $5 ,$ we demonstrate the speedup of our method over LKH-3, comparing to baseline methods. The speedup is often significant even at low levels of solution quality, and improves with higher solution quality. The speedup is not as meaningful beyond $9 5 \%$ LKH-3 solution quality, as LKH-3 takes a disproportionate amount of time to attain the last $5 \%$ of improvement.
+
+# 6.3 Clustered and Mixed CVRP Distributions
+
+We further examine the framework’s performance on CVRP distributions with clusters of cities, such as studied in $\pmb { \bigtriangledown } \boxed { \boxed { 8 } } \boxed { \boxed { 4 4 } }$ . We generate a clustered instance by first sampling $( x , y )$ locations of $n _ { c }$ cluster centroids then sampling the cities around the centroids. The mixed distribution samples $50 \%$ of the cities from a uniform distribution and the rest from around cluster centers. We generate a dataset of instances for every $( N , n _ { c } , m ) \in \{ 5 0 0 , 1 0 0 0 , 2 0 0 0 \} \times \{ 3 , 5 , 7 \} \times \{ \mathrm { C l u s t e r e d , M i x e d } \}$ and train a single model on the entire dataset. We evaluate the model on validation and test sets of 10 instances per $( N , n _ { c } , m )$ combination (i.e. 60 instances per $N$ ). Due to space limitation, we provide more details about the data distribution and full results in Appendix A.2.
+
+![](images/f4bba9674817fbed9f176bfecd1c7b4c3db2c80e4d56ba57701549eb52d36453.jpg)  
+Figure 6: Speedup in out-of-distribution CVRPs. The speedup of our model on the $N = 3 0 0 0$ uniform distribution (left) and $N = 2 0 0 0$ real-world distribution (right) without finetuning. Ours (Uniform) and Ours (Clustered) are trained on the uniform and clustered CVRP distributions, respectively. Note that LKH-3 is run for $5 0 \mathrm { k }$ steps for $N = 3 0 0 0$ instances.
+
+Table $2$ reports speedups of our method and the Random baseline over LKH-3. Our method sees at least $2 \mathbf { x }$ speedup over Random in all settings. We see larger speedups for clustered distributions than for mixed or uniform distributions (Table 1).
+
+Table 2: Speedup for $N \ = \ 2 0 0 0$ clustered and mixed CVRPs at $9 5 \%$ LKH-3 30k solution quality.   
+
+<table><tr><td colspan="2">Setting</td><td>nc=3</td><td>nc=5</td><td>nc=7</td></tr><tr><td rowspan="2">Clustered</td><td>Ours</td><td>26x</td><td>18x</td><td>25x</td></tr><tr><td>Random</td><td>11x</td><td>7.5x</td><td>9.0x</td></tr><tr><td rowspan="2">Mixed</td><td>Ours</td><td>13x</td><td>14x</td><td>14x</td></tr><tr><td>Random</td><td>6.6x</td><td>6.4x</td><td>7.6x</td></tr></table>
+
+# 6.4 Out-of-distribution Generalization
+
+We study how our subproblem selector generalize to a uniform CVRP distribution with larger problem size $N = 3 0 0 0$ and to a realworld CVRP distributions, both unseen at
+
+training time. The real-world CVRP distribution derives from a CVRP dataset $\mathbb { H }$ consisting of 10 very-large-scale instances on 5 Belgium regions with $N$ ranging from 3000 to 30000 and randomly generated demand distribution. To generate an instance, we subsample the cities in a region without replacement to $N = 2 0 0 0$ , while regenerating the demands to match our training distribution. For each original instance, we generate 5 subsampled instances to form the test set of 50 total instances. We visualize the original and subsampled datasets in Appendix A.3.
+
+We apply subproblem selectors trained on uniform and clustered data without finetuning on the new data distributions and report the speedup comparison with the Random baseline in Figure 6. We see that when transferring to $N = 3 0 0 0$ , subproblem selectors trained on uniform and clustered data offer similar performance. However, the model trained on the clustered distribution generalizes well to the real-world distribution while the model trained on the uniform distribution fails to generalize, with worse speedup than the Random baseline. These results suggest that the domain variability of the clustered distribution strongly improves generalization performance.
+
+# 6.5 Other VRP Variants
+
+While our previous experiments vary the distribution of city locations in CVRP, here we consider two VRP variants with uniform city distribution but with additional constraints: CVRPTW $\pmb { \mathbb { B 7 } }$ and VRPMPD $\mathbb { \lVert 3 3 \rVert }$ . The former specifies a hard time window constraint for visiting each city, while the latter specifies pick up and delivery constraints in addition to capacity constraint. A detailed description of the variants can be found in Appendix A.4.
+
+Similar to CVRP, we observe significant speedup with our iterative framework alone, while learning offers additional speedup. For CVRPTW, our method offers a $8 . 2 \mathbf { x }$ speedup while our Random baseline offers a $5 . 9 \mathrm { x }$ speedup; for VRPMPD, our method offers a $3 1 \mathrm { x }$ speedup while our Random baseline offers a $2 0 \mathrm { x }$ speedup. We suspect that the time window constraint in CVRPTW imposes strict orderings on the order of city visitations, increasing the difficulty for the subproblem selector.
+
+![](images/5b2c3c1204df33fdf8342b47e33cf63ff8eaef5d4323ce1590eda9bc72f8e552.jpg)  
+Figure 7: Speedup in other $N = 2 0 0 0$ VRP variants, CVRPTW (left) and VRPMPD (right).
+
+![](images/cba4db98b0ff9971bd2200c4d737c0e0c2bb38ad1c0d12202d050085b168f85d.jpg)  
+Figure 8: Speedup with the HGS subsolver on uniform CVRP. We compare the speedup of our method equipped with LKH-3 or HGS as the subsolver for $N = 2 0 0 0$ (left) and $N = 3 0 0 0$ (right).
+
+# 6.6 A State-of-the-Art CVRP Subsolver: HGS
+
+While we focus our analysis on LKH-3 due to its applicability to many variants of VRPs, HGS [49, 48] is a state-of-the-art solver focused on CVRP. Thus, we apply our method to train subproblem selectors for the HGS subsolver. We discuss the full experimental setup and results in Appendix A.5.3.
+
+With HGS as the subsolver, we observe a $1 0 3 \mathrm { x }$ speedup for our method on $N = 2 0 0 0$ , compared with a $7 7 \mathbf { x }$ speedup for the Random baseline. Similarly, we observe a $1 9 8 \mathrm { x }$ speedup for our method on $N = 3 0 0 0$ , compared with a $1 5 2 \mathrm { x }$ speedup for our Random baseline. The large speedup may be due to the fact that HGS is designed and calibrated for medium-scale problems of 500 to 1000 cities, allowing it to function better as a subsolver for large-scale VRPs.
+
+# 7 Conclusion
+
+This paper presents a learning-based framework which learns which subproblems to delegate to a subsolver when solving large VRPs. Spatial locality allows us to learn the subproblem selector over a reduced selection space. The proposed method accelerates competitive VRP solvers on problems of sizes up to 3000, requiring an order of magnitude less computation time. We identify a $1 . 5 \mathrm { x }$ to 2x speedup over non-learning selection strategies. Our results generalize to a variety of VRP distributions, variants, and solvers.
+
+While most previous learning-based combinatorial optimization methods [20, 21, 2] rely on reinforcement learning due to the unavailability of optimal solutions as high-quality labels, our work highlights the counterintuitive effectiveness of supervised learning with only moderate-quality labels to achieve high-quality solutions with iterative subproblem selection. An interesting line of future work may explore other ways to effectively leverage moderate-quality labels for combinatorial optimization tasks. In particular, we discuss in Appendix A.6 the applicability of our method to other combinatorial optimization problems with spatial locality. We believe that our learning framework can serve as a powerful technique for both the learning and operations research communities to scale up combinatorial optimization solvers.
+
+Our code is publicly available at https://github.com/mit-wu-lab/learning-to-delegate.
+
+Negative Social Impact. Enabling more efficient solutions of large-scale VRPs may exhibit negative externalities such as inducing additional traffic from delivery vehicles and centralizing services that pose a stronger competition to brick-and-mortar retail.
+
+# 8 Acknowledgements
+
+This research was supported by MIT Indonesia Seed Fund, US DOT DDETFP, and the MIT-IBM Watson AI Lab. The authors are grateful to the anonymous reviewers for detailed comments that substantially improved the article. The authors acknowledge the MIT SuperCloud and Lincoln Laboratory Supercomputing Center for providing (HPC, database, consultation) resources that have contributed to the research results reported within this paper. We also thank Zongyi Li for helpful discussions and technical advice throughout the project.
+
+# References
+
+[1] Aarts, E., Aarts, E. H., and Lenstra, J. K. (2003). Local search in combinatorial optimization. Princeton University Press.   
+[2] Ahn, S., Seo, Y., and Shin, J. (2020). Learning what to defer for maximum independent sets. In International Conference on Machine Learning, pages 134–144. PMLR.   
+[3] Alvim, A. C. and Taillard, E. D. (2013). Popmusic for the world location-routing problem. EURO Journal on Transportation and Logistics, 2(3):231–254.   
+[4] Arnold, F., Gendreau, M., and Sörensen, K. (2019). Efficiently solving very large-scale routing problems. Computers & Operations Research, 107:32–42.   
+[5] Błazewicz, J., Domschke, W., and Pesch, E. (1996). The job shop scheduling problem: Conven- ˙ tional and new solution techniques. European journal of operational research, 93(1):1–33.   
+[6] Bosman, P. A. and La Poutré, H. (2006). Computationally intelligent online dynamic vehicle routing by explicit load prediction in an evolutionary algorithm. In Parallel Problem Solving from Nature-PPSN IX, pages 312–321. Springer.   
+[7] Chen, X. and Tian, Y. (2019). Learning to perform local rewriting for combinatorial optimization. In Wallach, H., Larochelle, H., Beygelzimer, A., d Alché-Buc, F., Fox, E., and Garnett, R., editors, Advances in Neural Information Processing Systems, volume 32. Curran Associates, Inc.   
+[8] Christofides, N., Mingozzi, A., and Toth, P. (1979). Loading problems. N. Christofides and al., editors, Combinatorial Optimization, pages 339–369.   
+[9] Croes, G. A. (1958). A method for solving traveling-salesman problems. Operations research, 6(6):791–812.   
+[10] Dorigo, M., Birattari, M., and Stutzle, T. (2006). Ant colony optimization. IEEE computational intelligence magazine, 1(4):28–39.   
+[11] Gehring, H. and Homberger, J. (1999). A parallel hybrid evolutionary metaheuristic for the vehicle routing problem with time windows. In Proceedings of EUROGEN99, volume 2, pages 57–64. Citeseer.   
+[12] Gurobi Optimization, L. (2021). Gurobi optimizer reference manual.   
+[13] Helsgaun, K. (2017). An extension of the lin-kernighan-helsgaun tsp solver for constrained traveling salesman and vehicle routing problems. http://akira.ruc.dk/\~keld/research/ LKH-3/.   
+[14] Helsgaun, K. (2018). Using popmusic for candidate set generation in the lin-kernighan-helsgaun tsp solver. Roskilde Universitet, 7.   
+[15] Hottung, A. and Tierney, K. (2020). Neural large neighborhood search for the capacitated vehicle routing problem. In 24th European Conference on Artificial Intelligence (ECAI 2020).   
+[16] Huber, P. J. (1992). Robust estimation of a location parameter. In Breakthroughs in statistics, pages 492–518. Springer.   
+[17] Kallehauge, B., Larsen, J., Madsen, O. B., and Solomon, M. M. (2005). Vehicle routing problem with time windows. In Column generation, pages 67–98. Springer.   
+[18] Khalil, E. B., Dai, H., Zhang, Y., Dilkina, B., and Song, L. (2017). Learning combinatorial optimization algorithms over graphs. In Advances in Neural Information Processing Systems.   
+[19] Kohl, N., Desrosiers, J., Madsen, O. B., Solomon, M. M., and Soumis, F. (1999). 2-path cuts for the vehicle routing problem with time windows. Transportation Science, 33(1):101–116.   
+[20] Kool, W., van Hoof, H., and Welling, M. (2019). Attention, learn to solve routing problems! In International Conference on Learning Representations.   
+[21] Kwon, Y.-D., Choo, J., Kim, B., Yoon, I., Gwon, Y., and Min, S. (2020). Pomo: Policy optimization with multiple optima for reinforcement learning. In Larochelle, H., Ranzato, M., Hadsell, R., Balcan, M. F., and Lin, H., editors, Advances in Neural Information Processing Systems, volume 33, pages 21188–21198. Curran Associates, Inc.   
+[22] Lalla-Ruiz, E. and Voss, S. (2016). Popmusic as a matheuristic for the berth allocation problem. Annals of Mathematics and Artificial Intelligence, 76(1-2):173–189.   
+[23] Laporte, G. (2009). Fifty years of vehicle routing. Transportation science, 43(4):408–416.   
+[24] Laurent, M., Taillard, É. D., Ertz, O., Grin, F., Rappo, D., and Roh, S. (2009). From point feature label placement to map labelling. In Proceedings, metaheuristic international conference (MIC’09), Hamburg. Citeseer.   
+[25] Lenstra, J. K. and Kan, A. R. (1981). Complexity of vehicle routing and scheduling problems. Networks, 11(2):221–227.   
+[26] Lin, S. and Kernighan, B. W. (1973). An effective heuristic algorithm for the traveling-salesman problem. Operations research, 21(2):498–516.   
+[27] Lu, H., Zhang, X., and Yang, S. (2020). A learning-based iterative method for solving vehicle routing problems. In International Conference on Learning Representations.   
+[28] Lysgaard, J., Letchford, A. N., and Eglese, R. W. (2004). A new branch-and-cut algorithm for the capacitated vehicle routing problem. Mathematical Programming, 100(2):423–445.   
+[29] Nazari, M., Oroojlooy, A., Snyder, L., and Takac, M. (2018). Reinforcement learning for solving the vehicle routing problem. In Bengio, S., Wallach, H., Larochelle, H., Grauman, K., Cesa-Bianchi, N., and Garnett, R., editors, Advances in Neural Information Processing Systems, volume 31. Curran Associates, Inc.   
+[30] Perron, L. and Furnon, V. (2019). Or-tools.   
+[31] Poullet, J. (2020). Leveraging machine learning to solve The vehicle Routing Problem with Time Windows. PhD thesis, Massachusetts Institute of Technology.   
+[32] Renaud, J. and Boctor, F. F. (2002). A sweep-based algorithm for the fleet size and mix vehicle routing problem. European Journal of Operational Research, 140(3):618–628.   
+[33] Salhi, S. and Nagy, G. (1999). A cluster insertion heuristic for single and multiple depot vehicle routing problems with backhauling. Journal of the operational Research Society, 50(10):1034– 1042.   
+[34] Santini, A., Schneider, M., Vidal, T., and Vigo, D. (2021). Decomposition strategies for vehicle routing heuristics.   
+[35] Shaw, P. (1998). Using constraint programming and local search methods to solve vehicle routing problems. In International conference on principles and practice of constraint programming, pages 417–431. Springer.   
+[36] Sivanandam, S. and Deepa, S. (2008). Genetic algorithms. In Introduction to genetic algorithms, pages 15–37. Springer.   
+[37] Solomon, M. M. (1987). Algorithms for the vehicle routing and scheduling problems with time window constraints. Operations research, 35(2):254–265.   
+[38] Song, J., Lanka, R., Yue, Y., and Dilkina, B. (2020). A general large neighborhood search framework for solving integer linear programs. In Larochelle, H., Ranzato, M., Hadsell, R., Balcan, M. F., and Lin, H., editors, Advances in Neural Information Processing Systems, volume 33, pages 20012–20023. Curran Associates, Inc.   
+[39] Taillard, É. D. (2003). Heuristic methods for large centroid clustering problems. Journal of heuristics, 9(1):51–73.   
+[40] Taillard, É. D., Gambardella, L. M., Gendreau, M., and Potvin, J.-Y. (2001). Adaptive memory programming: A unified view of metaheuristics. European Journal of Operational Research, 135(1):1–16.   
+[41] Taillard, É. D. and Helsgaun, K. (2019). Popmusic for the travelling salesman problem. European Journal of Operational Research, 272(2):420–429.   
+[42] Taillard, É. D. and Voss, S. (2002). Popmusic—partial optimization metaheuristic under special intensification conditions. In Essays and surveys in metaheuristics, pages 613–629. Springer.   
+[43] Taillard, É. D. and Voß, S. (2018). POPMUSIC, pages 687–701. Springer International Publishing, Cham.   
+[44] Uchoa, E., Pecin, D., Pessoa, A., Poggi, M., Vidal, T., and Subramanian, A. (2017). New benchmark instances for the capacitated vehicle routing problem. European Journal of Operational Research, 257(3):845–858.   
+[45] Vaswani, A., Shazeer, N., Parmar, N., Uszkoreit, J., Jones, L., Gomez, A. N., Kaiser, L. u., and Polosukhin, I. (2017). Attention is all you need. In Guyon, I., Luxburg, U. V., Bengio, S., Wallach, H., Fergus, R., Vishwanathan, S., and Garnett, R., editors, Advances in Neural Information Processing Systems, volume 30. Curran Associates, Inc.   
+[46] Velickovi ˇ c, P., Cucurull, G., Casanova, A., Romero, A., Liò, P., and Bengio, Y. (2018). Graph ´ Attention Networks. International Conference on Learning Representations.   
+[47] Ventresca, M., Ombuki-Berman, B., and Runka, A. (2013). Predicting genetic algorithm performance on the vehicle routing problem using information theoretic landscape measures. In European Conference on Evolutionary Computation in Combinatorial Optimization, pages 214–225. Springer.   
+[48] Vidal, T. (2020). Hybrid genetic search for the cvrp: Open-source implementation and swap\* neighborhood. arXiv preprint arXiv:2012.10384.   
+[49] Vidal, T., Crainic, T. G., Gendreau, M., Lahrichi, N., and Rei, W. (2012). A hybrid genetic algorithm for multidepot and periodic vehicle routing problems. Operations Research, 60(3):611– 624.   
+[50] Vinyals, O., Fortunato, M., and Jaitly, N. (2015). Pointer networks. In Cortes, C., Lawrence, N., Lee, D., Sugiyama, M., and Garnett, R., editors, Advances in Neural Information Processing Systems, volume 28. Curran Associates, Inc.   
+[51] Voudouris, C. and Tsang, E. P. (2003). Guided local search. In Handbook of metaheuristics, pages 185–218. Springer.   
+[52] Wu, C., Shankari, K., Kamar, E., Katz, R., Culler, D., Papadimitriou, C., Horvitz, E., and Bayen, A. (2016). Optimizing the diamond lane: A more tractable carpool problem and algorithms. In 2016 IEEE 19th International Conference on Intelligent Transportation Systems (ITSC), pages 1389–1396. IEEE.   
+[53] Yolcu, E. and Poczos, B. (2019). Learning local search heuristics for boolean satisfiability. In Wallach, H., Larochelle, H., Beygelzimer, A., d'Alché-Buc, F., Fox, E., and Garnett, R., editors, Advances in Neural Information Processing Systems, volume 32. Curran Associates, Inc.
+
+# Checklist
+
+1. For all authors...
+
+(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   
+(b) Did you describe the limitations of your work? [Yes] See Section 6.5. We discuss our method gets slightly less speedup on CVRPTW than CVRP or VRPMPD; in section 6.2, we also discuss our learned subproblem-selection order at convergence are the same as Random and Min Count order, which can be seen as a potential limitation, but we provide justification in the same Section (6.2) as well.   
+(c) Did you discuss any potential negative societal impacts of your work? [Yes] See the negative social impact paragraph in Section 7 (Conclusion)   
+(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] As stated in Section 7 (Conclusion), our code is released at https://github.com/mit-wu-lab/ learning-to-delegate.   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] We briefly mention the training details in Section 6.1 of the main paper, and we put the full details in Appendix A.1.   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes] We plot error bars on all of our experiment figures in Section 6.   
+(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 6.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 the LKH-3 and HGS VRP solvers as a part of our component. We cite the creator as [13] (LKH-3) and [49, 48] (HGS) in our paper. We compare with existing learning and heuristic baseline using their code. We cite the creators in our paper, and provide exerpeiment setup (including github links to the repos) in the supplementary material.   
+(b) Did you mention the license of the assets? [N/A] All the assets (code and data) we use are open source.   
+(c) Did you include any new assets either in the supplemental material or as a URL? [No]   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A] We generate synthetic data for most of our experiments. The only real dataset in Section 6.4 is open source.   
+(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/rm0I5y2zkG8/rm0I5y2zkG8_content_list.json

@@ -0,0 +1,1289 @@
+[
+    {
+        "type": "text",
+        "text": "Learning to Delegate for Large-scale Vehicle Routing ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            122,
+            820,
+            148
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Sirui Li⇤   \nMIT   \nsiruil@mit.edu ",
+        "bbox": [
+            310,
+            200,
+            431,
+            242
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Zhongxia Yan\\* MIT zxyan@mit.edu ",
+        "bbox": [
+            575,
+            200,
+            686,
+            242
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Cathy Wu   \nMIT   \ncathywu@mit.edu ",
+        "bbox": [
+            433,
+            263,
+            563,
+            305
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            342,
+            535,
+            358
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Vehicle routing problems (VRPs) form a class of combinatorial problems with wide practical applications. While previous heuristic or learning-based works achieve decent solutions on small problem instances, their performance deteriorates in large problems. This article presents a novel learning-augmented local search framework to solve large-scale VRP. The method iteratively improves the solution by identifying appropriate subproblems and delegating their improvement to a black box subsolver. At each step, we leverage spatial locality to consider only a linear number of subproblems, rather than exponential. We frame subproblem selection as regression and train a Transformer on a generated training set of problem instances. Our method accelerates state-of-the-art VRP solvers by $1 0 \\mathrm { x }$ to $1 0 0 \\mathrm { x }$ while achieving competitive solution qualities for VRPs with sizes ranging from 500 to 3000. Learned subproblem selection offers a $1 . 5 \\mathrm { x }$ to $2 \\mathbf { x }$ speedup over heuristic or random selection. Our results generalize to a variety of VRP distributions, variants, and solvers. ",
+        "bbox": [
+            233,
+            375,
+            766,
+            566
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            594,
+            310,
+            611
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Vehicle routing problems (VRPs) have enjoyed ample applications in logistics and ride-hailing services $\\mathbb { \\left| \\left[ 2 . 3 \\right] \\right| }$ around the world for decades. While determining the optimal solution to a VRP is NP-hard $[ [ 2 5 ] ]$ , there have been numerous attempts to solve VRPs both exactly and approximately: provable algorithms have been designed for specific problem instances up to size $1 3 0 \\ \\textcircled { 1 2 8 } \\textcircled { 1 }$ , and powerful heuristic solvers such as LKH-3 [13] and HGS [49, 48] find good solutions in practice for problems of size more than 1000. However, heuristics methods often suffer from inflexibility due to extensive hand-crafting and the heavy computational burden from lengthy iterative procedures, as in the case of LKH-3. For example, LKH-3 takes more than an hour to solve a size 2000 CVRP instance (Table 1), which is impractical for applications such as large-scale courier or municipal services. ",
+        "bbox": [
+            174,
+            626,
+            825,
+            751
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "More recently, machine learning methods inspired by the Pointer Network $\\left[ \\left[ 5 0 \\right] \\right]$ provide alternatives to traditional solvers: the learning-based methods greatly reduce computation time while maintaining decent solution quality on small problem instances (less than 100 cities), by training on diverse sets of problem distributions either via supervised $\\pmb { \\| 5 0 \\| }$ or reinforcement learning [29, 20]. However, these methods remain difficult to scale, and few report results on problems of size more than 200. ",
+        "bbox": [
+            174,
+            757,
+            825,
+            827
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Our work aims to address scalability by learning to identify smaller subproblems which can be readily solved by existing methods. Our learned subproblem selector guides the problem-solving process to focus local improvement on promising subregions. While there exists a combinatorial number of subproblems that can be selected at each step, we leverage spatial locality commonly found in combinatorial optimization problems to restrict the selection space size to be linear in the problem size. Intuitively, objects far away from each other generally have very small influence on each other’s solution and are likely to be in different routes, so they should not be part of the same subproblem. The greatly reduced search space enables us to feasibly train an attention-based subproblem selector. ",
+        "bbox": [
+            176,
+            833,
+            823,
+            875
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            92,
+            825,
+            161
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our framework combines the advantages of learning and heuristics: our network identifies promising subproblems to improve upon, dramatically speeding up solution times. Using a competitive subsolver on subproblems, we achieve good solution quality without the high computational costs of running the subsolver on large problem instances. In summary, our contributions are: ",
+        "bbox": [
+            176,
+            166,
+            825,
+            223
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We propose learning-to-delegate, a learning-based framework for solving large-scale VRPs by iteratively identifying and solving smaller subproblems. • Despite the high dimensionality and NP-hardness of subproblems, we design a Transformer architecture that effectively predicts the subsolver’s solution quality for a subproblem. • With extensive validation, we show that learning-to-delegate offers significant speedups and/or objective improvements over both its base subsolver and random (or heuristic) subproblem selection, for a variety of VRP variants, distributions, and solvers. ",
+        "bbox": [
+            217,
+            233,
+            825,
+            342
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Preliminary: Capacitated Vehicle Routing Problems (CVRP) ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            359,
+            712,
+            377
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In CVRP, there is a depot node 0 and city nodes $\\{ 1 , . . . , N \\}$ . Each city node $i$ has demand $d _ { i }$ to fulfill. A vehicle with capacity $C$ starts and ends at the depot and visits a route of city nodes such that the sum of city demands along the route does not exceed $C$ , after which the vehicle starts a new route again. The objective is to find a valid solution minimizing the solution cost. We define the following: ",
+        "bbox": [
+            176,
+            391,
+            826,
+            446
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• Route: a sequence of nodes, where the first and last node are the depot 0, and the rest are city nodes. In a valid route, the sum of demands of the city nodes does not exceed $C$ . • Route cost: the sum of edge costs for the sequence of nodes. For an edge from node $i$ to node $j$ , the edge cost is the Euclidean distance between node $i$ and $j$ . • Solution: a feasible solution consists of a set of valid routes visiting each city exactly once. • Solution cost: the sum of route costs for all routes in the solution. An optimal solution is a feasible solution with the minimum solution cost. • Subproblem: a CVRP consisting of the depot, a subset of cities, and corresponding demands. ",
+        "bbox": [
+            217,
+            458,
+            825,
+            590
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            607,
+            323,
+            625
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Classical methods. Heuristics for solving combinatorial optimization problems have been studied for decades. The most powerful methods, such as local search $\\mathbb { M }$ , genetic algorithms $\\left[ \\left[ 3 6 \\right] \\right]$ , and ant colony methods $\\mathbb { m }$ , involve iteratively improving the solution in a hand-designed neighborhood. For example, move, swap $[ [ 5 2 ] ]$ , and 2-opt $\\dot { \\bigtriangledown }$ are well-known heuristics for the traveling salesman and vehicle routing problems. The competitive VRP solver LKH-3 [13] uses the Lin–Kernighan heuristic $\\pmb { \\Vert 2 6 \\Vert }$ as a backbone, which involves swapping pairs of sub-routes to create new routes, whereas the CVRP solver HGS [49, 48] uses a hybrid genetic and local search procedure to achieve state-of-the-art solution qualities on problems up to size 1000. While LKH- $3 ^ { \\overset { . } { 2 } }$ tackles a variety of VRP variants, the publicly available implementation of $\\mathrm { H G S } \\big \\triangledown$ only solves CVRP. ",
+        "bbox": [
+            173,
+            638,
+            825,
+            765
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "For large problems, low-level heuristics are combined with meta-heuristics, including Tabu Search with Adaptive Memory $\\mathbb { \\left[ \\left[ 4 0 \\right] \\right] }$ , guided local search $\\mathbb { B }$ , and Large Neighborhood Search $\\pmb { \\Vert 3 5 \\Vert }$ . The inspiration for our work derives from Partial OPtimization Metaheuristic Under Special Intensification Conditions (POPMUSIC), which iteratively optimizes problem subparts and has been used to solve problems as diverse as map labeling $\\pmb { \\Vert 2 4 \\Vert }$ , berth allocation $[ [ 2 2 ] ]$ , and $p$ -median clustering $\\pmb { \\| 3 9 \\| }$ . ",
+        "bbox": [
+            174,
+            770,
+            825,
+            840
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Despite the promise of the POPMUSIC framework for large-scale combinatorial optimization, the impact of certain design choices is not well understood, such as the subproblem selection ordering and size $\\mathbb { \\lVert \\rVert 3 \\rVert }$ . For example, it is not clear how to meaningfully order the subproblems. One early work in this direction demonstrated that a last-in-first-out stack order performs better than random $\\pmb { \\| }$ Our work provides a natural approach to order the subproblems based on predicted improvement. ",
+        "bbox": [
+            176,
+            845,
+            825,
+            875
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/c61c357c5ae3dd7e7a7a4b1eb79b16268270b1826629f535d2cc4ba39a18d619.jpg",
+        "image_caption": [
+            "Figure 1: Our iterative framework for VRPs. (a) At each time step, we start with a current solution $X$ . Circles are city nodes, blue lines are route segments, and the red star is the depot. (b) We aggregate each route by taking the centroid of all city nodes in the route. (c) For each route, we define a corresponding subproblem as the $k$ -nearest neighbors of the route. Two such subproblems with $k = 3$ are shown. (d) Our subproblem selector selects a subproblem $S$ (yellow). (e) We feed $S$ into the subsolver to get a new subsolution $X _ { S } ^ { \\prime }$ . The red edges are updated by the subsolver. (f) We update $X$ to new solution $X ^ { \\prime }$ with $X _ { S } ^ { \\prime }$ , then repeat (b)-(f). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            259,
+            88,
+            843,
+            320
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            450,
+            826,
+            493
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Deep learning methods. Recently, there has been a surge of interest in training deep neural networks (DNN) to solve combinatorial problems. As observed by Kwon et al. [21], most methods fall into one of the following two categories: 1) construction methods $\\pm \\pmb { \\mathbb { Z } } 9 \\pm \\pmb { \\mathbb { Z } } 0 \\|$ , where an autoregressive model such as the Pointer Network $\\pmb { \\Vert 5 0 \\Vert }$ directly outputs a solution, and 2) improvement methods [7, 15], where the DNN iteratively performs local updates to the solution, resembling local search. ",
+        "bbox": [
+            173,
+            507,
+            825,
+            577
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "These methods are approaching the solution quality of LKH-3 [13] on small problem instances. For example, Kwon et al. $\\pmb { \\mathbb { \\left| \\left[ 2 \\right] \\right| } }$ extends a construction approach $\\pmb { \\mathbb { Z } } 0 \\|$ to encourage more diverse output samples on $N \\leq 1 0 0$ VRPs. Among improvement methods, Lu et al. $\\mathbb { \\left[ \\left[ 2 \\right] \\right] }$ learn a meta-controller to select among a set of local search heuristics, marking the first learning-based approach to outperform LKH-3 on $N \\leq 1 0 0$ VRPs. Despite these successes, learning-based approaches for large-scale VRPs are poorly understood. In addition, all of the aforementioned methods are trained using deep reinforcement learning; for large problems, trajectory collection becomes prohibitively expensive. ",
+        "bbox": [
+            173,
+            583,
+            825,
+            681
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Scaling up learning methods. A few recent works have begun to investigate scaling of learned networks for NP-hard graph problems. For example, Ahn et al. [2] propose an iterative scheme called learning-what-to-defer for maximum independent set. At each stage, for each node in the graph, the network either outputs the solution for the node or defers the determination to later stages. Song et al. $\\pmb { \\Vert 3 8 \\Vert }$ proposes an imitation-learning-based pipeline for Integer Linear Programs (ILP), where at each stage they partition all variables into disjoint subsets, and use the Gurobi $\\lVert \\overline { { 1 2 } } \\rVert$ ILP solver to solve the partitions. Due to differences in graph structure, our work presents a more natural scheme to handle VRP constraints and structures. A few works attempt to incorporate learning to decompose large-scale VRPs [6, 47, 31]. However, the decomposition approaches proposed appear to be experimentally less effective than ours. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            833
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4 An Iterative Framework for VRPs ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            852,
+            493,
+            869
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "While CVRPs are NP-hard and thus require worst-case exponential time in the problem size to solve optimally, typical CVRPs exhibit structure that practical solvers may exploit. We hypothesize that in such situations, the larger problem can be efficiently approximately solved as a sequence of smaller subproblems, which can be delegated to efficient subsolvers. To test this hypothesis, we propose a learning-based, iterative framework with two components: 1) a subsolver capable of solving a small problem instance (exactly or approximately), and 2) a learned model for identifying suitable subproblems within a larger problem to delegate to the subsolver. ",
+        "bbox": [
+            174,
+            883,
+            823,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            825,
+            161
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1: Learning to Delegate ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            179,
+            406,
+            194
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Input: Problem instance $P$ , initialized solution $X$ , subproblem selector $f _ { \\theta }$ , subsolver Subsolver, number of steps $T$ , parameter $k$ denoting the size of subproblems 1 for Step $t = l \\colon T$ do 2 $S _ { k , \\mathrm { l o c a l } } $ ConstructSubproblems $( P , X , k )$ 3 $S \\gets f _ { \\theta } ( S _ { k , \\mathrm { l o c a l } } )$ 4 $X _ { S } ^ { \\prime } \\gets \\mathrm { S u b s o l v e r } ( S )$ 5 $X  X _ { S } ^ { \\prime } \\cup X _ { P \\backslash S }$ 6 end for ",
+        "bbox": [
+            158,
+            196,
+            740,
+            314
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We illustrate our iterative framework in Figure $\\bigtriangledown$ which takes in a problem instance $P$ with a feasible initial solution $X _ { 0 }$ . At each step, given the current solution $X$ , we select a smaller subproblem $S \\subset P$ with our learned model $f _ { \\theta }$ then apply the subsolver to solve $S$ ; we then update $X$ with the new solution for $S$ . To maintain feasibility after an update, we restrict $S$ to be the set $s$ of visited cities of a subset of routes from $X$ . Since routes with cities in $P \\backslash S$ remain valid routes, we obtain a new feasible solution $X ^ { \\prime } = X _ { S } ^ { \\prime } \\cup X _ { P \\backslash S }$ , where $X _ { S } ^ { \\prime }$ is the subsolution for $S$ and $X _ { P \\backslash S }$ consists of unselected routes from $X$ . Intuitively, a strong $f _ { \\theta }$ should identify a subproblem $S$ such that the subsolver solution $X _ { S } ^ { \\prime }$ results in a large improvement in objective from $X$ to $X ^ { \\prime }$ . ",
+        "bbox": [
+            173,
+            330,
+            825,
+            444
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 The Restricted Subproblem Selection Space ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            458,
+            516,
+            474
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "As the number of routes in $P$ is $R = O ( N )$ , the cardinality of the selection space $s$ is $O ( 2 ^ { R } )$ , which is exponential in the problem size $N$ and difficult for learned models to consider. If we restrict each subproblem to cities from exactly $k$ routes, there are still ${ \\binom { R } { k } } = O ( R ^ { k } )$ subproblems to consider. Therefore we further restrict selection to subproblems with spatial locality. As shown in Figure $1 ( \\mathrm { d } )$ , we only consider subproblems from $\\boldsymbol { S } _ { k , \\mathrm { l o c a l } }$ , where each subproblem is centered around a particular route $r$ and contains the $k$ routes whose centroids have the smallest Euclidean distance to the centroid of $r$ . In this way, we reduce the selection space to $| S _ { k , \\mathrm { l o c a l } } | = R = O ( N )$ from $| S | = O ( 2 ^ { N } )$ . In Algorithm 1, we refer to this restriction as ConstructSubproblems. Our restriction to a local selection space is motivated by the fact that many combinatorial optimizations problems have inherent spatial locality, i.e. problem entities are more strongly affected by nearby entities than faraway entities. Earlier heuristical methods such as POPMUSIC $\\lVert \\boldsymbol { 4 2 } \\rVert$ leverage similar spatial locality. ",
+        "bbox": [
+            173,
+            483,
+            826,
+            638
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "5 Learning to Delegate ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            656,
+            380,
+            674
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this section, we discuss criteria for selecting subproblems, and how to train the subproblem selector. ",
+        "bbox": [
+            169,
+            688,
+            825,
+            703
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Improvement as the criteria for subproblem selection. Given a selected subproblem $S$ with a current solution $X _ { S }$ on the subproblem, we obtain from LKH-3 a new solution $X _ { S } ^ { \\prime }$ on the same subproblem (step $( d )$ to $( e )$ in Figure $\\textcircled { 1 }$ . We then define the immediate improvement ",
+        "bbox": [
+            174,
+            717,
+            825,
+            760
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/89055982bba8a47310c05af3fadb2bc9a8cea2ba4e62e44af67ccf6cb3cf5ae7.jpg",
+        "text": "$$\n\\delta ( S ) = c ( X _ { S } ) - c ( X _ { S } ^ { \\prime } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            416,
+            763,
+            580,
+            781
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $c ( X _ { S } )$ is the total cost of subsolution $X _ { S }$ and $\\delta ( S )$ is the improvement in the solution cost. In this way, the sum of improvements along $T$ steps is the total improvement in solution quality. As we empirically find that providing the previous subsolution $X _ { S }$ to the subsolver may trap the subsolver in a local optimum, we withhold $X _ { S }$ from the solver and thus may see non-positive improvement $\\delta ( S ) \\leq 0$ , especially after many steps of subproblem selection. At test time, to avoid worsening the objective, we adopt a hill-climbing procedure such that when $\\delta ( S ) \\leq 0$ , we keep $X _ { S }$ instead of $X _ { S } ^ { \\prime }$ (Figure $^ { 1 , }$ step $( e )$ ). With proper masking, we avoid selecting the same non-improving subproblem $S$ again. The hill-climbing and masking procedures are applied to both our subproblem-selection network $f _ { \\theta }$ and the three heuristic selection rules, described in $6 . 1 ,$ to maintain fair comparisons. ",
+        "bbox": [
+            173,
+            786,
+            825,
+            912
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/338568a46cb8baf3cd5a80c1ef63c6249f557837d16e45735f3b99631eeda14b.jpg",
+        "image_caption": [
+            "Figure 2: Our Transformer architecture. At each step of our framework (Figure $1 ( \\mathrm { c } ) \\mathrm { \\sharp ~ }$ , we featurize subproblem $S \\in S _ { k , \\mathrm { l o c a l } }$ into a column vector of unordered cities. We apply the Transformer encoder with multiple multi-head attention layers and a final linear layer, before mean-pooling over the cities to generate the predictions $f _ { \\theta } ( S )$ , which we fit to the subsolution cost $c ( X _ { S } ^ { \\prime } )$ . When possible, we retrieve a previously predicted subproblem from a cache to minimize computation. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            209,
+            90,
+            789,
+            267
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Subproblem selection. The goal of our subproblem selector is to select the subproblem leading to the best immediate improvement. While our subproblem selection does not directly optimize for the total improvement, we observe that (1) our subsolver may perform many low-level operations internally, so high-level problem selection may still benefit greatly from maximizing the immediate improvement, and (2) numerous reinforcement learning approaches to VRP $\\lVert \\tilde { 5 3 } \\rVert \\textcircled { 1 8 } \\rVert$ choose a small discount factor such as $\\gamma = 0 . 2 5$ when optimizing a multi-step objective $\\sum _ { t = 1 } ^ { T } \\gamma ^ { t } \\delta _ { t }$ , as doing so encourage faster convergence. Moreover, our subproblem selector may instead be trained on multi-step search data to select subproblems offering the best multi-step improvement. ",
+        "bbox": [
+            173,
+            371,
+            825,
+            501
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Ground-truth labels. Our restricted selection space allows us to enumerate all possible subproblems at each step. In a typical large scale CVRP instance with $N = 2 0 0 0$ cities, a solution consists of roughly $R = 2 0 0$ routes, so the size of the selection space is 200. We obtain the immediate improvement $\\delta ( S )$ by running the subsolver on each subproblem $S \\in S _ { k , \\mathrm { l o c a l } }$ . Although our enumeration strategy is feasible for generating training data, it is much too slow to execute on a test CVRP instance. However, if our subproblem selector can predict the best immediate improvement at test time (that is, without running the subsolver on multiple subproblems), then we can combine the best of both worlds to obtain a fast and accurate selection strategy. ",
+        "bbox": [
+            173,
+            513,
+            825,
+            626
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Selection strategies: regression vs classification. Given a labeled dataset, we may treat the task of identifying the best subproblem as either regression or classification. In the context of imitation learning with a greedy expert, the former learns a value function while the latter learns a policy. Due to space limitation, we focus discussion on regression and reserve comparison with classification for Appendix A.5.1. The regression-based subproblem selector uses a trained $f _ { \\theta }$ to predict the subsolution cost $c ( X _ { S } ^ { \\prime } )$ ; we then simply compute arg maxS $c ( X _ { S } ) - f _ { \\theta } ( S )$ to select the best subproblem. ",
+        "bbox": [
+            173,
+            638,
+            825,
+            723
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Network architecture. We define $f _ { \\theta }$ with a Transformer encoder architecture $\\lVert \\rVert 5 \\rVert$ . The input representing each subproblem $S$ is the unordered set of featurized cities in $S$ . The features for each city consist of the demand $d$ and the location of the city $( x , y )$ relative to the depot. As we do not feed the existing subsolution $X _ { S }$ to the subsolver, the dense multi-head attention mechanism does not need to be modified to take the routes in $X _ { S }$ into account. The output of the Transformer encoder is fed into a linear layer then mean-pooled to obtain the scalar prediction $f _ { \\theta } ( S )$ . In Appendix A.5.5, we perform an ablation study with simpler architectures. ",
+        "bbox": [
+            173,
+            736,
+            825,
+            834
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Loss function. We empirically find mean squared error to be less stable than Huber loss $\\mathbb { \\lVert \\boldsymbol { 1 6 } \\rVert }$ , which we set as our loss function ",
+        "bbox": [
+            171,
+            847,
+            826,
+            876
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/34c1141b07dc9f4b6d9ffc215f70b9c92fc2f068239f1f7e8a9b92c4b4edf7ea.jpg",
+        "text": "$$\nL ( \\theta ; S ) = \\left\\{ \\begin{array} { l l } { \\frac { 1 } { 2 } ( f _ { \\theta } ( S ) - c ( X _ { S } ^ { \\prime } ) ) ^ { 2 } , } & { \\mathrm { i f ~ } \\lvert f _ { \\theta } ( S ) - c ( X _ { S } ^ { \\prime } ) \\rvert \\le 1 } \\\\ { \\lvert f _ { \\theta } ( S ) - c ( X _ { S } ^ { \\prime } ) \\rvert - \\frac { 1 } { 2 } , } & { \\mathrm { o t h e r w i s e } } \\end{array} \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            295,
+            878,
+            700,
+            915
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/eb27d355ab5068322cf3b126dced1febb93f07ae703733694405d907d2eb5fc0.jpg",
+        "image_caption": [
+            "Figure 3: Instances from $N = 2 0 0 0$ CVRP distributions. From left to right: instance from uniform, mixed ${ \\mathrm { ' } n _ { c } = 7 }$ cluster centers), clustered ${ { n } _ { c } } = 3$ cluster centers), and real-world. The red star is the location of the depot, while blue dots are cities sized proportional to demand. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            214,
+            94,
+            784,
+            188
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "6 Experiments and Analysis ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            267,
+            423,
+            285
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We illustrate the CVRP distributions considered in our work in Figure $\\textcircled{3}$ We perform extensive experiments to evaluate our learning framework, aiming to answer the following questions: ",
+        "bbox": [
+            174,
+            299,
+            825,
+            328
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "1. Uniform distribution. How does our method compare with baselines, in terms of solution time and quality, on problems with uniformly distributed cities?   \n2. Clustered distributions. How does our method perform on problems with clustered cities?   \n3. Out-of-distribution. Can our model generalize, such as to larger or real-world instances?   \n4. VRP variants. Can our method address more sophisticated VRPs? E.g., CVRP with Time Windows (CVRPTW) $\\pmb { \\Vert 3 7 } \\Vert$ or VRP with Mixed Pickup and Delivery (VRPMPD) [33].   \n5. VRP solvers. Can our method be adapted to leverage other VRP subsolvers? ",
+        "bbox": [
+            204,
+            339,
+            825,
+            462
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We reserve additional ablations on subproblem selection as classification, effect of subproblem size $k$ and discussion of asymptotic behavior, subproblem selection with the HGS subsolver, effect of weaker initialization methods, and comparison with simpler architectures for Appendix A.5. ",
+        "bbox": [
+            178,
+            472,
+            826,
+            513
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "6.1 Setup",
+        "text_level": 1,
+        "bbox": [
+            174,
+            531,
+            253,
+            545
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We briefly describe experimental setup in the main text and defer full details to Appendix A.1. Given a particular distribution of VRP, we generate separate sets of training, validation, and test problem instances. Unless otherwise stated, our validation and test sets contain 40 instances each. For each problem instance, we generate a rough initial solution by partitioning it into disjoint subsets of cities and briefly running the subsolver on each subset. Due to its compatibility with many VRP variants, we use LKH-3 $\\checkmark$ as the subsolver for all VRP distributions unless otherwise stated. ",
+        "bbox": [
+            174,
+            556,
+            825,
+            640
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We generate the training set by running our iterative framework and selecting subproblems by enumerating the subsolver on all $S \\in S _ { k , \\mathrm { l o c a l } }$ . As many subproblems remain unchanged from $X$ to $X ^ { \\prime }$ , we use previously cached subsolutions when possible instead of re-running the subsolver. While generation times differ depending on several factors, typically it takes less than 10 hours with 200 Intel Xeon Platinum 8260 CPUs to generate a training set of 2000 instances. ",
+        "bbox": [
+            174,
+            646,
+            825,
+            715
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To avoid training multiple models for different problem sizes $N$ , we train a single model for each VRP distribution with combined data from multiple $N \\in \\{ 5 0 0 , 1 0 0 0 , 2 0 0 0 \\}$ . Training takes at most 8 hours on a single NVIDIA V100 GPU. To exploit symmetry in problem instances, we apply rotation and flip augmentation at training time. To evaluate trained selectors on a problem instance, we run the iterative selection framework on a single CPU, with disabled multithreading and no GPU. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            791
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We select the best hyperparameters via manual search based on validation set performance. We record final results on the test set as the mean and standard error over 5 runs with different random seeds. ",
+        "bbox": [
+            174,
+            797,
+            825,
+            827
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Baselines. By default, as we use LKH-3 as the subsolver, we run LKH-3 on the full problem instances with our initialization for 30000 local update steps, which takes 2-3 hours on average for $N = 2 0 0 0$ . If using HGS as the subsolver, we also run HGS on the full problem instances for the same amount of time as our LKH-3 baseline. These baselines allow us to compute the speedup of our framework over the subsolver alone. We also compare against OR Tools $\\pmb { \\mathbb { B } } \\mathbf { \\bar { 0 } } \\mathbf { \\mathbb { I } }$ , another open source heuristic VRP solver employing iterative search, terminating runs at 15 minutes, as OR Tools stops improving the solution within this time for all instances. ",
+        "bbox": [
+            174,
+            842,
+            823,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/cced8b3f177fd9c19194720755693d854f8368c16cd24566f5b9caf2759d83e5.jpg",
+        "table_caption": [
+            "Table 1: Performance and computation time for uniform CVRP. For problem instance sizes $N \\in \\{ 5 0 0 , 1 0 0 0 , 2 0 0 0 \\}$ , we report the objective values (lower is better) of our method and baseline methods, averaged across all instances in the test set. Note that the cost is the total distance of routes in the solution. LKH-3 (30k) runs LKH-3 for $3 0 \\mathrm { k }$ steps to near convergence, while LKH-3 $( 9 5 \\% )$ is the $9 5 \\%$ solution quality. Random, Count-based, Max Min Distance, and Ours (Short) run until matching LKH-3 $( 9 5 \\% )$ in solution quality, with the speedup reported in parentheses, while Ours (long) runs for twice amount time as Ours (Short). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"2\">N= 500</td><td colspan=\"2\">N = 1000</td><td colspan=\"2\">N = 2000</td></tr><tr><td>Method</td><td>Cost</td><td>Time</td><td>Cost</td><td>Time</td><td>Cost</td><td>Time</td></tr><tr><td>LKH-3 (95%)</td><td>62.00</td><td>4.4min</td><td>120.02</td><td>18min</td><td>234.89</td><td>52min</td></tr><tr><td>LKH-3 (30k)</td><td>61.87</td><td>30min</td><td>119.88</td><td>77min</td><td>234.65</td><td>149min</td></tr><tr><td>OR Tools</td><td>65.59</td><td>15min</td><td>126.52</td><td>15min</td><td>244.65</td><td>15min</td></tr><tr><td>AM sampling</td><td>69.08</td><td>4.70s</td><td>151.01</td><td>17.40s</td><td>356.69</td><td>32.29s</td></tr><tr><td>AM greedy</td><td>68.58</td><td>25ms</td><td>142.84</td><td>56ms</td><td>307.86</td><td>147ms</td></tr><tr><td>NeuRewriter</td><td>73.60</td><td>58s</td><td>136.29</td><td>2.3min</td><td>257.61</td><td>8.1min</td></tr><tr><td>Random</td><td>61.99</td><td>71s (3.8x)</td><td>120.02</td><td>3.2min (5.5x)</td><td>234.88</td><td>6.4min (8.0x)</td></tr><tr><td>Count-based</td><td>61.99</td><td>59s (4.5x)</td><td>120.02</td><td>2.1min (8.2x)</td><td>234.88</td><td>5.3min (10x)</td></tr><tr><td>Max Min</td><td>61.99</td><td>59s (4.5x)</td><td>120.02</td><td>2.5min (7.0x)</td><td>234.89</td><td>5.2min (10x)</td></tr><tr><td>Ours (Short)</td><td>61.99</td><td>38s (7.0x)</td><td>119.87</td><td>1.5min (12x)</td><td>234.89</td><td>3.4min (15x)</td></tr><tr><td>Ours (Long)</td><td>61.70</td><td>76s</td><td>119.55</td><td>3.0min</td><td>233.86</td><td>6.8min</td></tr></table>",
+        "bbox": [
+            196,
+            196,
+            802,
+            395
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            434,
+            821,
+            463
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We include results for previous learning methods AM $\\mathbb { \\left[ \\left[ 2 0 \\right] \\right] }$ and NeuRewriter $\\mathbb { H }$ . These do not outperform LKH-3 even on small problem sizes, and learning methods have had more difficulty generalizing to larger instances. In fact, these methods are trained on problems of size $N \\leq 1 0 0$ , and we find that they yield poor solutions on $N \\geq 5 0 0$ without architecture modifications and extensive re-training. The AM and NeuRewriter results demonstrate the difficulty of scaling up previous learning methods. We do not initialize OR-Tools, AM, and NeuRewriter because we empirically find that these methods have limited solution capability and do not improve our decent initialization. ",
+        "bbox": [
+            174,
+            469,
+            825,
+            566
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To validate our subproblem selector’s ability to identify promising subproblems, we design three additional baselines that employ our iterative framework using hand-crafted heuristics to select subproblems. The three heuristics that we use are: (1) Random, selecting subproblem $S$ from $\\boldsymbol { S } _ { k , \\mathrm { l o c a l } }$ uniformly; (2) Count-based, which avoids repetitive selections by selecting the subproblem centered at the route whose city nodes have been selected cumulatively the least often in previous steps; and (3) Max Min Distance, which encourages coverage of the entire problem instance by selecting subproblems with the maximum distance from the nearest centroid of previously selected subproblems. We run the heuristic baselines with the same setup as our learned subproblem selector. ",
+        "bbox": [
+            174,
+            571,
+            825,
+            684
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Metrics. We refer to two metrics to compare our method against baseline methods. ",
+        "bbox": [
+            173,
+            714,
+            727,
+            729
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "1. Improvement over method $\\mathbf { X }$ : at a specified computation time, the improvement of method Y over method X is the total improvement of method Y minus that of method X. ",
+        "bbox": [
+            214,
+            747,
+            825,
+            776
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "2. Speedup over method X: at a specified solution quality that method X attains, the speedup of method $\\mathrm { Y }$ over method $\\mathbf { X }$ is the computation time required for method $\\mathbf { X }$ to attain the solution quality divided by the time for method $\\mathrm { Y }$ to attain the solution quality. ",
+        "bbox": [
+            214,
+            795,
+            823,
+            837
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We define $9 5 \\%$ solution quality of running a method $\\mathbf { X }$ over a computation time as the solution quality with $9 5 \\%$ of the total improvement. We report speedup at $9 5 \\%$ solution quality of a method $\\mathrm { X }$ because X may take a disproportionate amount of time on the last $5 \\%$ of improvement; reporting speedup at $100 \\%$ solution quality inflates the speedup. ",
+        "bbox": [
+            176,
+            856,
+            823,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/7ad23903e592d1abb1776322c0f1bf396cadb17f92185bbbd5cea15b8b84bde5.jpg",
+        "image_caption": [
+            "Figure 4: Improvement over LKH-3 for uniform CVRP. The $\\mathbf { X }$ -axis is the computation time and extends until LKH-3 has completed $3 0 \\mathrm { k }$ steps. The vertical lines represent the computation times of Ours (Short) and Ours (Long) from Table $^ { 1 . }$ The three subplots correspond to $N = 5 0 0$ (left), $N = 1 0 0 0$ (middle), and $N = 2 0 0 0$ (right). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            92,
+            823,
+            196
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/cf8f6b9efdfada0d6762a9ae9da29538986f7ab8068d7f68b1169a5c3f497f53.jpg",
+        "image_caption": [
+            "Figure 5: Speedup over LKH-3 for uniform CVRP. The $\\mathbf { X }$ -axis is the solution quality attained, measured as a percentage of the LKH-3’s maximum improvement. The dashed vertical line represents the $9 5 \\%$ solution quality used to compute the speedup, as mentioned in Table 1. The three subplots correspond to $N = 5 0 0$ (left), $N = 1 0 0 0$ (middle), and $N = 2 0 0 0$ (right). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            277,
+            823,
+            385
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6.2 Uniform CVRP Distribution ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            477,
+            410,
+            492
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "As seen in Table $^ { 1 , }$ our method achieves the best performance for all problem sizes, matching LKH-3’s solution quality with more than $7 \\mathbf { x }$ to $1 5 \\mathrm { x }$ less computation time and offering even more improvements with longer computation time. Although we need to evaluate all $R = { \\bar { O } } ( N )$ subproblems of the initial solution with our subproblem selector, subsequent per-step computation time of our method is mostly independent of the problem size $N$ since we only evaluate changed subproblems. ",
+        "bbox": [
+            174,
+            502,
+            825,
+            573
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Running LKH-3 for $3 0 \\mathrm { k }$ local update steps achieves superior performance to all previous other heuristic and learning-based baselines. Its solution quality scales well to large problem sizes, yet the solution time is significantly longer. Previous learning-based methods, though fast, result in much worse solution qualities. Our heuristic baselines Random, Count-based, and Max Min Distance demonstrate that our iterative framework, even without the learned subproblem selector, may achieve over $5 \\mathbf { x }$ to $1 0 \\mathrm { x }$ speedup over LKH-3. Nevertheless, our results demonstrate that learning the subproblem selector may offer an additional $1 . 5 \\mathrm { x }$ speedup over non-learning heuristics. ",
+        "bbox": [
+            174,
+            579,
+            825,
+            676
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In Figure 4, we demonstrate the solution quality of our method and baselines compared to LKH-3. We see that, compared to baseline methods, the learned subproblem selector obtains the best solution quality when run for a reasonable amount of time. The improvement of most methods based on our iterative framework converge when run for an excessive amount of time; this is unsurprising, as Random and other baselines are eventually able to select all subproblems offering improvements. ",
+        "bbox": [
+            174,
+            683,
+            825,
+            752
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In Figure $5 ,$ we demonstrate the speedup of our method over LKH-3, comparing to baseline methods. The speedup is often significant even at low levels of solution quality, and improves with higher solution quality. The speedup is not as meaningful beyond $9 5 \\%$ LKH-3 solution quality, as LKH-3 takes a disproportionate amount of time to attain the last $5 \\%$ of improvement. ",
+        "bbox": [
+            174,
+            758,
+            825,
+            814
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6.3 Clustered and Mixed CVRP Distributions ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            830,
+            504,
+            845
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We further examine the framework’s performance on CVRP distributions with clusters of cities, such as studied in $\\pmb { \\bigtriangledown } \\boxed { \\boxed { 8 } } \\boxed { \\boxed { 4 4 } }$ . We generate a clustered instance by first sampling $( x , y )$ locations of $n _ { c }$ cluster centroids then sampling the cities around the centroids. The mixed distribution samples $50 \\%$ of the cities from a uniform distribution and the rest from around cluster centers. We generate a dataset of instances for every $( N , n _ { c } , m ) \\in \\{ 5 0 0 , 1 0 0 0 , 2 0 0 0 \\} \\times \\{ 3 , 5 , 7 \\} \\times \\{ \\mathrm { C l u s t e r e d , M i x e d } \\}$ and train a single model on the entire dataset. We evaluate the model on validation and test sets of 10 instances per $( N , n _ { c } , m )$ combination (i.e. 60 instances per $N$ ). Due to space limitation, we provide more details about the data distribution and full results in Appendix A.2. ",
+        "bbox": [
+            174,
+            856,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/f4bba9674817fbed9f176bfecd1c7b4c3db2c80e4d56ba57701549eb52d36453.jpg",
+        "image_caption": [
+            "Figure 6: Speedup in out-of-distribution CVRPs. The speedup of our model on the $N = 3 0 0 0$ uniform distribution (left) and $N = 2 0 0 0$ real-world distribution (right) without finetuning. Ours (Uniform) and Ours (Clustered) are trained on the uniform and clustered CVRP distributions, respectively. Note that LKH-3 is run for $5 0 \\mathrm { k }$ steps for $N = 3 0 0 0$ instances. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            192,
+            90,
+            805,
+            193
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            287,
+            825,
+            343
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Table $2$ reports speedups of our method and the Random baseline over LKH-3. Our method sees at least $2 \\mathbf { x }$ speedup over Random in all settings. We see larger speedups for clustered distributions than for mixed or uniform distributions (Table 1). ",
+        "bbox": [
+            174,
+            349,
+            460,
+            434
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/efddb84a1684fa1c8b30647eca6ff646051f67aca1696f9ee6a1a5d417dc2a9b.jpg",
+        "table_caption": [
+            "Table 2: Speedup for $N \\ = \\ 2 0 0 0$ clustered and mixed CVRPs at $9 5 \\%$ LKH-3 30k solution quality. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">Setting</td><td>nc=3</td><td>nc=5</td><td>nc=7</td></tr><tr><td rowspan=\"2\">Clustered</td><td>Ours</td><td>26x</td><td>18x</td><td>25x</td></tr><tr><td>Random</td><td>11x</td><td>7.5x</td><td>9.0x</td></tr><tr><td rowspan=\"2\">Mixed</td><td>Ours</td><td>13x</td><td>14x</td><td>14x</td></tr><tr><td>Random</td><td>6.6x</td><td>6.4x</td><td>7.6x</td></tr></table>",
+        "bbox": [
+            473,
+            402,
+            830,
+            489
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6.4 Out-of-distribution Generalization ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            452,
+            454,
+            467
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We study how our subproblem selector generalize to a uniform CVRP distribution with larger problem size $N = 3 0 0 0$ and to a realworld CVRP distributions, both unseen at ",
+        "bbox": [
+            174,
+            478,
+            460,
+            534
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "training time. The real-world CVRP distribution derives from a CVRP dataset $\\mathbb { H }$ consisting of 10 very-large-scale instances on 5 Belgium regions with $N$ ranging from 3000 to 30000 and randomly generated demand distribution. To generate an instance, we subsample the cities in a region without replacement to $N = 2 0 0 0$ , while regenerating the demands to match our training distribution. For each original instance, we generate 5 subsampled instances to form the test set of 50 total instances. We visualize the original and subsampled datasets in Appendix A.3. ",
+        "bbox": [
+            174,
+            534,
+            825,
+            617
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We apply subproblem selectors trained on uniform and clustered data without finetuning on the new data distributions and report the speedup comparison with the Random baseline in Figure 6. We see that when transferring to $N = 3 0 0 0$ , subproblem selectors trained on uniform and clustered data offer similar performance. However, the model trained on the clustered distribution generalizes well to the real-world distribution while the model trained on the uniform distribution fails to generalize, with worse speedup than the Random baseline. These results suggest that the domain variability of the clustered distribution strongly improves generalization performance. ",
+        "bbox": [
+            173,
+            622,
+            825,
+            720
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6.5 Other VRP Variants ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            739,
+            354,
+            753
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "While our previous experiments vary the distribution of city locations in CVRP, here we consider two VRP variants with uniform city distribution but with additional constraints: CVRPTW $\\pmb { \\mathbb { B 7 } }$ and VRPMPD $\\mathbb { \\lVert 3 3 \\rVert }$ . The former specifies a hard time window constraint for visiting each city, while the latter specifies pick up and delivery constraints in addition to capacity constraint. A detailed description of the variants can be found in Appendix A.4. ",
+        "bbox": [
+            174,
+            766,
+            825,
+            835
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Similar to CVRP, we observe significant speedup with our iterative framework alone, while learning offers additional speedup. For CVRPTW, our method offers a $8 . 2 \\mathbf { x }$ speedup while our Random baseline offers a $5 . 9 \\mathrm { x }$ speedup; for VRPMPD, our method offers a $3 1 \\mathrm { x }$ speedup while our Random baseline offers a $2 0 \\mathrm { x }$ speedup. We suspect that the time window constraint in CVRPTW imposes strict orderings on the order of city visitations, increasing the difficulty for the subproblem selector. ",
+        "bbox": [
+            174,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/5b2c3c1204df33fdf8342b47e33cf63ff8eaef5d4323ce1590eda9bc72f8e552.jpg",
+        "image_caption": [
+            "Figure 7: Speedup in other $N = 2 0 0 0$ VRP variants, CVRPTW (left) and VRPMPD (right). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            192,
+            90,
+            805,
+            193
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/cba4db98b0ff9971bd2200c4d737c0e0c2bb38ad1c0d12202d050085b168f85d.jpg",
+        "image_caption": [
+            "Figure 8: Speedup with the HGS subsolver on uniform CVRP. We compare the speedup of our method equipped with LKH-3 or HGS as the subsolver for $N = 2 0 0 0$ (left) and $N = 3 0 0 0$ (right). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            192,
+            238,
+            805,
+            339
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6.6 A State-of-the-Art CVRP Subsolver: HGS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            409,
+            508,
+            424
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "While we focus our analysis on LKH-3 due to its applicability to many variants of VRPs, HGS [49, 48] is a state-of-the-art solver focused on CVRP. Thus, we apply our method to train subproblem selectors for the HGS subsolver. We discuss the full experimental setup and results in Appendix A.5.3. ",
+        "bbox": [
+            174,
+            436,
+            825,
+            478
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "With HGS as the subsolver, we observe a $1 0 3 \\mathrm { x }$ speedup for our method on $N = 2 0 0 0$ , compared with a $7 7 \\mathbf { x }$ speedup for the Random baseline. Similarly, we observe a $1 9 8 \\mathrm { x }$ speedup for our method on $N = 3 0 0 0$ , compared with a $1 5 2 \\mathrm { x }$ speedup for our Random baseline. The large speedup may be due to the fact that HGS is designed and calibrated for medium-scale problems of 500 to 1000 cities, allowing it to function better as a subsolver for large-scale VRPs. ",
+        "bbox": [
+            174,
+            484,
+            825,
+            555
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "7 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            579,
+            299,
+            597
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This paper presents a learning-based framework which learns which subproblems to delegate to a subsolver when solving large VRPs. Spatial locality allows us to learn the subproblem selector over a reduced selection space. The proposed method accelerates competitive VRP solvers on problems of sizes up to 3000, requiring an order of magnitude less computation time. We identify a $1 . 5 \\mathrm { x }$ to 2x speedup over non-learning selection strategies. Our results generalize to a variety of VRP distributions, variants, and solvers. ",
+        "bbox": [
+            174,
+            613,
+            825,
+            696
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "While most previous learning-based combinatorial optimization methods [20, 21, 2] rely on reinforcement learning due to the unavailability of optimal solutions as high-quality labels, our work highlights the counterintuitive effectiveness of supervised learning with only moderate-quality labels to achieve high-quality solutions with iterative subproblem selection. An interesting line of future work may explore other ways to effectively leverage moderate-quality labels for combinatorial optimization tasks. In particular, we discuss in Appendix A.6 the applicability of our method to other combinatorial optimization problems with spatial locality. We believe that our learning framework can serve as a powerful technique for both the learning and operations research communities to scale up combinatorial optimization solvers. ",
+        "bbox": [
+            174,
+            703,
+            825,
+            829
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Our code is publicly available at https://github.com/mit-wu-lab/learning-to-delegate. ",
+        "bbox": [
+            176,
+            834,
+            821,
+            849
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Negative Social Impact. Enabling more efficient solutions of large-scale VRPs may exhibit negative externalities such as inducing additional traffic from delivery vehicles and centralizing services that pose a stronger competition to brick-and-mortar retail. ",
+        "bbox": [
+            174,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "8 Acknowledgements ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            367,
+            107
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "This research was supported by MIT Indonesia Seed Fund, US DOT DDETFP, and the MIT-IBM Watson AI Lab. The authors are grateful to the anonymous reviewers for detailed comments that substantially improved the article. The authors acknowledge the MIT SuperCloud and Lincoln Laboratory Supercomputing Center for providing (HPC, database, consultation) resources that have contributed to the research results reported within this paper. We also thank Zongyi Li for helpful discussions and technical advice throughout the project. ",
+        "bbox": [
+            173,
+            119,
+            825,
+            204
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            223,
+            266,
+            239
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[1] Aarts, E., Aarts, E. H., and Lenstra, J. K. (2003). Local search in combinatorial optimization. Princeton University Press.   \n[2] Ahn, S., Seo, Y., and Shin, J. (2020). Learning what to defer for maximum independent sets. In International Conference on Machine Learning, pages 134–144. PMLR.   \n[3] Alvim, A. C. and Taillard, E. D. (2013). Popmusic for the world location-routing problem. EURO Journal on Transportation and Logistics, 2(3):231–254.   \n[4] Arnold, F., Gendreau, M., and Sörensen, K. (2019). Efficiently solving very large-scale routing problems. Computers & Operations Research, 107:32–42.   \n[5] Błazewicz, J., Domschke, W., and Pesch, E. (1996). The job shop scheduling problem: Conven- ˙ tional and new solution techniques. European journal of operational research, 93(1):1–33.   \n[6] Bosman, P. A. and La Poutré, H. (2006). Computationally intelligent online dynamic vehicle routing by explicit load prediction in an evolutionary algorithm. In Parallel Problem Solving from Nature-PPSN IX, pages 312–321. Springer.   \n[7] Chen, X. and Tian, Y. (2019). Learning to perform local rewriting for combinatorial optimization. In Wallach, H., Larochelle, H., Beygelzimer, A., d Alché-Buc, F., Fox, E., and Garnett, R., editors, Advances in Neural Information Processing Systems, volume 32. Curran Associates, Inc.   \n[8] Christofides, N., Mingozzi, A., and Toth, P. (1979). Loading problems. N. Christofides and al., editors, Combinatorial Optimization, pages 339–369.   \n[9] Croes, G. A. (1958). A method for solving traveling-salesman problems. Operations research, 6(6):791–812.   \n[10] Dorigo, M., Birattari, M., and Stutzle, T. (2006). Ant colony optimization. IEEE computational intelligence magazine, 1(4):28–39.   \n[11] Gehring, H. and Homberger, J. (1999). A parallel hybrid evolutionary metaheuristic for the vehicle routing problem with time windows. In Proceedings of EUROGEN99, volume 2, pages 57–64. Citeseer.   \n[12] Gurobi Optimization, L. (2021). Gurobi optimizer reference manual.   \n[13] Helsgaun, K. (2017). An extension of the lin-kernighan-helsgaun tsp solver for constrained traveling salesman and vehicle routing problems. http://akira.ruc.dk/\\~keld/research/ LKH-3/.   \n[14] Helsgaun, K. (2018). Using popmusic for candidate set generation in the lin-kernighan-helsgaun tsp solver. Roskilde Universitet, 7.   \n[15] Hottung, A. and Tierney, K. (2020). Neural large neighborhood search for the capacitated vehicle routing problem. In 24th European Conference on Artificial Intelligence (ECAI 2020).   \n[16] Huber, P. J. (1992). Robust estimation of a location parameter. In Breakthroughs in statistics, pages 492–518. Springer.   \n[17] Kallehauge, B., Larsen, J., Madsen, O. B., and Solomon, M. M. (2005). Vehicle routing problem with time windows. In Column generation, pages 67–98. Springer.   \n[18] Khalil, E. B., Dai, H., Zhang, Y., Dilkina, B., and Song, L. (2017). Learning combinatorial optimization algorithms over graphs. In Advances in Neural Information Processing Systems.   \n[19] Kohl, N., Desrosiers, J., Madsen, O. B., Solomon, M. M., and Soumis, F. (1999). 2-path cuts for the vehicle routing problem with time windows. Transportation Science, 33(1):101–116.   \n[20] Kool, W., van Hoof, H., and Welling, M. (2019). Attention, learn to solve routing problems! In International Conference on Learning Representations.   \n[21] Kwon, Y.-D., Choo, J., Kim, B., Yoon, I., Gwon, Y., and Min, S. (2020). Pomo: Policy optimization with multiple optima for reinforcement learning. In Larochelle, H., Ranzato, M., Hadsell, R., Balcan, M. F., and Lin, H., editors, Advances in Neural Information Processing Systems, volume 33, pages 21188–21198. Curran Associates, Inc.   \n[22] Lalla-Ruiz, E. and Voss, S. (2016). Popmusic as a matheuristic for the berth allocation problem. Annals of Mathematics and Artificial Intelligence, 76(1-2):173–189.   \n[23] Laporte, G. (2009). Fifty years of vehicle routing. Transportation science, 43(4):408–416.   \n[24] Laurent, M., Taillard, É. D., Ertz, O., Grin, F., Rappo, D., and Roh, S. (2009). From point feature label placement to map labelling. In Proceedings, metaheuristic international conference (MIC’09), Hamburg. Citeseer.   \n[25] Lenstra, J. K. and Kan, A. R. (1981). Complexity of vehicle routing and scheduling problems. Networks, 11(2):221–227.   \n[26] Lin, S. and Kernighan, B. W. (1973). An effective heuristic algorithm for the traveling-salesman problem. Operations research, 21(2):498–516.   \n[27] Lu, H., Zhang, X., and Yang, S. (2020). A learning-based iterative method for solving vehicle routing problems. In International Conference on Learning Representations.   \n[28] Lysgaard, J., Letchford, A. N., and Eglese, R. W. (2004). A new branch-and-cut algorithm for the capacitated vehicle routing problem. Mathematical Programming, 100(2):423–445.   \n[29] Nazari, M., Oroojlooy, A., Snyder, L., and Takac, M. (2018). Reinforcement learning for solving the vehicle routing problem. In Bengio, S., Wallach, H., Larochelle, H., Grauman, K., Cesa-Bianchi, N., and Garnett, R., editors, Advances in Neural Information Processing Systems, volume 31. Curran Associates, Inc.   \n[30] Perron, L. and Furnon, V. (2019). Or-tools.   \n[31] Poullet, J. (2020). Leveraging machine learning to solve The vehicle Routing Problem with Time Windows. PhD thesis, Massachusetts Institute of Technology.   \n[32] Renaud, J. and Boctor, F. F. (2002). A sweep-based algorithm for the fleet size and mix vehicle routing problem. European Journal of Operational Research, 140(3):618–628.   \n[33] Salhi, S. and Nagy, G. (1999). A cluster insertion heuristic for single and multiple depot vehicle routing problems with backhauling. Journal of the operational Research Society, 50(10):1034– 1042.   \n[34] Santini, A., Schneider, M., Vidal, T., and Vigo, D. (2021). Decomposition strategies for vehicle routing heuristics.   \n[35] Shaw, P. (1998). Using constraint programming and local search methods to solve vehicle routing problems. In International conference on principles and practice of constraint programming, pages 417–431. Springer.   \n[36] Sivanandam, S. and Deepa, S. (2008). Genetic algorithms. In Introduction to genetic algorithms, pages 15–37. Springer.   \n[37] Solomon, M. M. (1987). Algorithms for the vehicle routing and scheduling problems with time window constraints. Operations research, 35(2):254–265.   \n[38] Song, J., Lanka, R., Yue, Y., and Dilkina, B. (2020). A general large neighborhood search framework for solving integer linear programs. In Larochelle, H., Ranzato, M., Hadsell, R., Balcan, M. F., and Lin, H., editors, Advances in Neural Information Processing Systems, volume 33, pages 20012–20023. Curran Associates, Inc.   \n[39] Taillard, É. D. (2003). Heuristic methods for large centroid clustering problems. Journal of heuristics, 9(1):51–73.   \n[40] Taillard, É. D., Gambardella, L. M., Gendreau, M., and Potvin, J.-Y. (2001). Adaptive memory programming: A unified view of metaheuristics. European Journal of Operational Research, 135(1):1–16.   \n[41] Taillard, É. D. and Helsgaun, K. (2019). Popmusic for the travelling salesman problem. European Journal of Operational Research, 272(2):420–429.   \n[42] Taillard, É. D. and Voss, S. (2002). Popmusic—partial optimization metaheuristic under special intensification conditions. In Essays and surveys in metaheuristics, pages 613–629. Springer.   \n[43] Taillard, É. D. and Voß, S. (2018). POPMUSIC, pages 687–701. Springer International Publishing, Cham.   \n[44] Uchoa, E., Pecin, D., Pessoa, A., Poggi, M., Vidal, T., and Subramanian, A. (2017). New benchmark instances for the capacitated vehicle routing problem. European Journal of Operational Research, 257(3):845–858.   \n[45] Vaswani, A., Shazeer, N., Parmar, N., Uszkoreit, J., Jones, L., Gomez, A. N., Kaiser, L. u., and Polosukhin, I. (2017). Attention is all you need. In Guyon, I., Luxburg, U. V., Bengio, S., Wallach, H., Fergus, R., Vishwanathan, S., and Garnett, R., editors, Advances in Neural Information Processing Systems, volume 30. Curran Associates, Inc.   \n[46] Velickovi ˇ c, P., Cucurull, G., Casanova, A., Romero, A., Liò, P., and Bengio, Y. (2018). Graph ´ Attention Networks. International Conference on Learning Representations.   \n[47] Ventresca, M., Ombuki-Berman, B., and Runka, A. (2013). Predicting genetic algorithm performance on the vehicle routing problem using information theoretic landscape measures. In European Conference on Evolutionary Computation in Combinatorial Optimization, pages 214–225. Springer.   \n[48] Vidal, T. (2020). Hybrid genetic search for the cvrp: Open-source implementation and swap\\* neighborhood. arXiv preprint arXiv:2012.10384.   \n[49] Vidal, T., Crainic, T. G., Gendreau, M., Lahrichi, N., and Rei, W. (2012). A hybrid genetic algorithm for multidepot and periodic vehicle routing problems. Operations Research, 60(3):611– 624.   \n[50] Vinyals, O., Fortunato, M., and Jaitly, N. (2015). Pointer networks. In Cortes, C., Lawrence, N., Lee, D., Sugiyama, M., and Garnett, R., editors, Advances in Neural Information Processing Systems, volume 28. Curran Associates, Inc.   \n[51] Voudouris, C. and Tsang, E. P. (2003). Guided local search. In Handbook of metaheuristics, pages 185–218. Springer.   \n[52] Wu, C., Shankari, K., Kamar, E., Katz, R., Culler, D., Papadimitriou, C., Horvitz, E., and Bayen, A. (2016). Optimizing the diamond lane: A more tractable carpool problem and algorithms. In 2016 IEEE 19th International Conference on Intelligent Transportation Systems (ITSC), pages 1389–1396. IEEE.   \n[53] Yolcu, E. and Poczos, B. (2019). Learning local search heuristics for boolean satisfiability. In Wallach, H., Larochelle, H., Beygelzimer, A., d'Alché-Buc, F., Fox, E., and Garnett, R., editors, Advances in Neural Information Processing Systems, volume 32. Curran Associates, Inc. ",
+        "bbox": [
+            169,
+            246,
+            828,
+            916
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            47,
+            828,
+            921
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            30,
+            828,
+            875
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Checklist ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            254,
+            106
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            116,
+            339,
+            130
+        ],
+        "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] See Section 6.5. We discuss our method gets slightly less speedup on CVRPTW than CVRP or VRPMPD; in section 6.2, we also discuss our learned subproblem-selection order at convergence are the same as Random and Min Count order, which can be seen as a potential limitation, but we provide justification in the same Section (6.2) as well.   \n(c) Did you discuss any potential negative societal impacts of your work? [Yes] See the negative social impact paragraph in Section 7 (Conclusion)   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            238,
+            136,
+            825,
+            295
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            299,
+            493,
+            314
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [N/A] (b) Did you include complete proofs of all theoretical results? [N/A] ",
+        "bbox": [
+            238,
+            318,
+            738,
+            349
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            214,
+            353,
+            393,
+            367
+        ],
+        "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] As stated in Section 7 (Conclusion), our code is released at https://github.com/mit-wu-lab/ learning-to-delegate.   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] We briefly mention the training details in Section 6.1 of the main paper, and we put the full details in Appendix A.1.   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes] We plot error bars on all of our experiment figures in Section 6.   \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 6.1. ",
+        "bbox": [
+            238,
+            372,
+            826,
+            545
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            214,
+            550,
+            821,
+            564
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes] We use the LKH-3 and HGS VRP solvers as a part of our component. We cite the creator as [13] (LKH-3) and [49, 48] (HGS) in our paper. We compare with existing learning and heuristic baseline using their code. We cite the creators in our paper, and provide exerpeiment setup (including github links to the repos) in the supplementary material.   \n(b) Did you mention the license of the assets? [N/A] All the assets (code and data) we use are open source.   \n(c) Did you include any new assets either in the supplemental material or as a URL? [No]   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A] We generate synthetic data for most of our experiments. The only real dataset in Section 6.4 is open source.   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] ",
+        "bbox": [
+            236,
+            568,
+            825,
+            758
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            215,
+            762,
+            705,
+            776
+        ],
+        "page_idx": 13
+    },
+    {
+        "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,
+            781,
+            825,
+            871
+        ],
+        "page_idx": 13
+    }
+]

parse/train/yH2VrkpiCK6/yH2VrkpiCK6.md

@@ -0,0 +1,307 @@
+# A Prototype-Oriented Framework for Unsupervised Domain Adaptation
+
+Korawat Tanwisuth∗,1, Xinjie Fan∗,1, Huangjie Zheng∗,1, Shujian Zhang1, Hao Zhang2, Bo Chen3, Mingyuan Zhou1
+
+1The University of Texas at Austin 2 Cornell University 3Xidian University korawat.tanwisuth@utexas.edu, mingyuan.zhou@mccombs.utexas.edu
+
+# Abstract
+
+Existing methods for unsupervised domain adaptation often rely on minimizing some statistical distance between the source and target samples in the latent space. To avoid the sampling variability, class imbalance, and data-privacy concerns that often plague these methods, we instead provide a memory and computationefficient probabilistic framework to extract class prototypes and align the target features with them. We demonstrate the general applicability of our method on a wide range of scenarios, including single-source, multi-source, class-imbalance, and source-private domain adaptation. Requiring no additional model parameters and having a moderate increase in computation over the source model alone, the proposed method achieves competitive performance with state-of-the-art methods.
+
+# 1 Introduction
+
+In many real-world applications, such as healthcare and autonomous driving, data labeling can be expensive and time-consuming. To make predictions on a new unlabeled dataset, one may naively use an existing supervised model trained on a large labeled dataset. However, even subtle changes in the data-collection conditions, such as lighting or background for natural images, can cause a model’s performance to degrade drastically [1]. This shift in the input data distribution is referred to in the literature as covariate shift [2]. By leveraging the labeled samples from the source domain and unlabeled samples from the target domain, unsupervised domain adaptation aims to overcome this issue, making the learned model generalize well in the target domain [3].
+
+Ben-David et al. [4, 5] provide an $\mathcal { H }$ -divergence based theoretical upper bound on the target error. Ganin [6] popularizes learning an invariant representation between the source and target domains to minimize this divergence. Numerous prior methods [7–12] follow this trend, focusing on using the source and target samples for feature alignment in the latent space. While this approach can reduce the discrepancy between domains, directly using the source and target samples for feature alignment has the following problems. First, several commonly used methods that can be used to quantify the difference between two empirical distributions, such as maximum mean discrepancy (MMD) [13] and Wasserstein distance [14, 15], are sensitive to outlier samples in a mini-batch when used to match the source and target marginal distributions [16, 17]. We attribute this problem to the sampling variability of both the source and target samples. Second, while we typically assume that the two domains share the same label space, we cannot guarantee that the samples drawn from the source and target domains will cover the same set of classes in each mini-batch. Especially, if the label proportions shift between domains, learning domain invariant representation might not lead to improvements over using the source data alone to train the model [18]. If we pull the support of the source and target feature representations from different classes closer together, the classifier will be more likely to misclassify those examples. Finally, aligning the target features to source features means that we need access to both the source and target data simultaneously. In applications such as personal healthcare, we may not have access to the source data directly during the adaptation stage; instead, we may only be given access to the target data and the model trained on the source data.
+
+![](images/4647cf2c7e915131ca261d7cf23bfb4e0603f7cc7d7185c4aff950342658c9f6.jpg)  
+Figure 1: This figure exhibits a diagram of Prototype-oriented Conditional Transport (PCT). Unlike existing methods that align the target and source features, our method aligns the target features with class prototypes. The gray arrow indicates that the gradients of the prototypes do not back-propagate through the transport loss.
+
+We propose an algorithm that constructs class prototypes to represent the source domain samples in the latent space. Using the prototypes instead of source features avoids the previously mentioned problems: 1) sampling variability in the source domain, 2) instance class-mismatching in a mini-batch, and 3) source-data privacy concerns. As we expect the classifier to make better predictions on the target data in regions where the source density is sufficiently high [19], it is natural to consider encouraging the feature encoder to map the target data close to these prototypes. Motivated by the cluster assumption [20] (decision boundaries should not cross high-density regions of the data), we provide a method to transport the target features to these class prototypes and vice versa. We further extend our bi-directional transport to address the potential shift in label proportions, a common problem that has been studied [21–25] but that has been often overlooked in prior works [6, 7, 26].
+
+Compared to existing methods, the proposed one has several appealing aspects. First, it does not rely on adversarial training to achieve competitive performance, making the algorithm robust and converge much faster. Moreover, learnable prototypes not only avoid expensive computation but also bypass the need to directly access the source data. This attribute makes our algorithm applicable to the settings where preserving the source data privacy is a major concern. Unlike clustering-based approaches that typically require multiple forward passes before an update, our algorithm processes data in mini-batches for each update and is trained in an end-to-end manner.
+
+We highlight the main contributions of the paper as follows: 1) We utilize the linear classifier’s weights as class prototypes and propose a general probabilistic framework to align the target features to these prototypes. 2) We introduce the minimization of the expected cost of a probabilistic bi-directional transport for feature alignment, and illustrate its superior performance over related methods. 3) We test the proposed method under multiple challenging yet practical settings: single-source, multisource, class-imbalance, and source-private domain adaptation. In comparison to state-of-the-art algorithms, the proposed prototype-oriented method achieves highly competitive performance in domain adaptation, while requiring no additional model parameters and only having a moderate increase in computation over the source model alone.
+
+# 2 Prototype-oriented conditional transport
+
+In this section, we propose Prototype-oriented Conditional Transport (PCT), a holistic method for domain adaption consisting of three parts: learning class prototypes, aligning the target features with learned prototypes using a probabilistic bi-directional transport framework of Zheng and Zhou [27], and estimating the target class proportions. Our method does not introduce additional model parameters for aligning domain features, and the model can be learned in an end-to-end manner. We provide a motivating example of the application of our method on a synthetic dataset in Figure 2.
+
+![](images/6f38e79e69bb61e4ba8f17b9e1406d3acc0bc26431cde4539bcf4a18b6ecdcf3.jpg)  
+Figure 2: Visualization of different methods on a synthetic dataset, where darker points marked with “·” and lighter points marked with “ $\times \overrightarrow { \mathbf { \Omega } }$ ” denote the source and target samples, respectively, and the red and green colors denote two different classes. For each method, the left plot shows the data space whereas the right plot exhibits the output of the feature encoder in the latent space. Letters A and B correspond to the two class prototypes in the latent space. When there is clear class imbalance, DANN, a representative algorithm whose strategy is to match the marginal feature distributions between the source and target, fails to adapt to the target domain.
+
+and an unlabeled dataset from the target domain, In domain adaptation, we are given a labeled dataset from the source domain, $\{ \pmb { x } _ { j } ^ { t } \} _ { j = 1 } ^ { n _ { t } } \sim \mathcal { D } _ { t } ^ { \pmb { x } }$ i i i=1 . We focus on the closed-category $\{ ( \pmb { x } _ { i } ^ { s } , \pmb { y } _ { i } ^ { s } ) \} _ { i = 1 } ^ { n _ { s } } \sim \mathcal { D } _ { s }$ , domain adaptation and assume that the source and target domains share the same label space, i.e., $y _ { i } ^ { s } , y _ { j } ^ { t } \in \{ 1 , 2 , . . . , K \}$ , where $K$ denotes the number of classes. The goal of domain adaptation is to learn a model with low risk on the target samples. The model typically consists of a feature encoder, $F _ { \pmb \theta } : \mathcal { X }  \mathbb { R } ^ { d _ { f } }$ , parameterized by $\pmb { \theta }$ , and a linear classification layer $\dot { C _ { \mu } } : \mathbb { R } ^ { d _ { f } } \to \mathbb { R } ^ { K }$ , parameterized by $\pmb { \mu }$ . In prior works [6, 7, 26], the feature encoder is a pre-trained neural network, and the classifier is a randomly initialized linear layer. To simplify the following notation, we denote $\pmb { f } _ { i } ^ { s } = F _ { \pmb { \theta } } ( \pmb { x } _ { i } ^ { s } )$ and $f _ { j } ^ { t } = F _ { \theta } ( \pmb { x } _ { j } ^ { t } )$ as the feature representations of the source data $\mathbf { \boldsymbol { x } } _ { i } ^ { s }$ and target data $\boldsymbol { x } _ { j } ^ { t }$ , respectively.
+
+# 2.1 Learning class prototypes
+
+Most existing works [6, 7, 26] focus on aligning the source and target features in a latent space. By contrast, we propose to characterize the features of each class with a class prototype and align the target features with these class prototypes instead of the source features. This approach has several advantages. First, the feature alignment between two domains would be more robust to outliers in the source domain as we avoid using the source samples directly. Second, we do not need to worry about the missing classes in the sampled mini-batch in the source domain like we do when we align the features of source and target samples. Prototypes ensure that every class is represented for each training update. Last but not least, using the inferred prototypes instead of source features allows adapting to the target domain even without accessing the source data during the adaptation stage, which is an appealing trait when preserving the source data privacy is a concern (see Table 6).
+
+Previous methods [28–31, 12, 32] construct each class prototype as the average latent feature for that class extracted by the feature encoder, which is computationally expensive due to the forward passing of a large number of training samples. We propose to construct class prototypes in the same latent space but with learnable parameters: $[ \pmb { \mu } _ { 1 } , \pmb { \dot { \mu } } _ { 2 } , \dots , \pmb { \mu } _ { K } ] \in \mathbb { R } ^ { d _ { f } \times K }$ , where the dimension of each prototype, $d _ { f }$ , is the same as the hidden dimension after the feature encoder $F _ { \theta }$ . This strategy has been successfully applied by Saito et al. [33] in a semi-supervised learning setting. We learn each class prototype in a way that encourages the prototype to be close to the source samples associated with that class in the feature space. In particular, given the prototypes and source samples $\mathbf { \boldsymbol { x } } _ { i } ^ { s }$ with features $\pmb { f } _ { i } ^ { s }$ and labels $y _ { i } ^ { s }$ , we use the cross-entropy loss to learn the prototypes:
+
+$$
+\begin{array} { r } { \mathcal { L } _ { \mathrm { c l s } } = \mathbb { E } _ { ( \pmb { x } _ { i } ^ { s } , \pmb { y } _ { i } ^ { s } ) \sim \mathcal { D } _ { s } } \left[ \sum _ { k = 1 } ^ { K } - \log p _ { i k } ^ { s } \mathbf { 1 } _ { \{ \pmb { y } _ { i } ^ { s } = k \} } \right] , \quad p _ { i k } ^ { s } : = \frac { \exp ( \mu _ { k } ^ { T } f _ { i } ^ { s } + b _ { k } ) } { \sum _ { k ^ { \prime } = 1 } ^ { K } \exp ( \mu _ { k ^ { \prime } } ^ { T } f _ { i } ^ { s } + b _ { k ^ { \prime } } ) } , } \end{array}
+$$
+
+where $b _ { k }$ is a bias term and $p _ { i k } ^ { s }$ is the predictive probability for $\mathbf { \boldsymbol { x } } _ { i } ^ { s }$ to be classified to class $k$ . We note that this way of learning the class prototypes is closely connected to learning the standard linear classification layer $C _ { \mu }$ on source-only data with the cross-entropy loss. The neural network weights in the classification layer can be interpreted as the class prototypes. Therefore, compared with sourceonly approaches, constructing prototypes in this way introduce no additional parameters. As we show in Figure $4 \mathrm { a }$ , our method requires much fewer parameters than other domain-adaptation methods. Moreover, it requires much less computation than other prototype-based methods by avoiding the need to average the latent features for each class.
+
+# 2.2 Bi-directional prototype-oriented conditional transport
+
+In this section, we will discuss how we encourage the feature encoder to align the target data with class prototypes. Our approach is motivated by the cluster assumption, which has been widely adopted in both semi-supervised learning [20, 34, 35] and domain-adaptation literature [36, 37, 31, 38]. The cluster assumption states that the input data distribution consists of separated clusters and that instances belonging to the same cluster tend to have the same class labels. This means that the decision boundaries should not cross data high-density regions. To achieve this goal, we minimize the expected pairwise cost between the target features and prototypes with respect to two differently constructed joint distributions. By minimizing the expected costs under these two different joint distributions, the target feature will be close to the prototypes, far from the decision boundaries.
+
+# 2.2.1 Moving from target domain to class prototypes
+
+To define the expected cost of moving from the target domain to the class prototypes, we first use the chain rule to factorize the joint distribution of the class prototype $\pmb { \mu } _ { k }$ and target feature $\boldsymbol { f } _ { j } ^ { t }$ as $p ( f _ { j } ^ { t } ) \pi _ { \pmb { \theta } } ( \mu _ { k } \vert f _ { j } ^ { t } )$ , where drawing from the target feature distribution $p ( f _ { j } ^ { t } )$ can be realized by selecting a random target sample $\mathbf { \boldsymbol { x } } _ { j } ^ { t } \sim \mathcal { D } _ { t } ^ { x }$ to obtain $f _ { j } ^ { t } = F _ { \theta } ( \pmb { x } _ { j } ^ { t } )$ . The conditional distribution, representing the probability of moving from target feature $f _ { j } ^ { t }$ to class prototype $\pmb { \mu } _ { k }$ , is defined as
+
+$$
+\begin{array} { r } { \pi _ { \pmb { \theta } } ( \pmb { \mu } _ { k } \mid \pmb { f } _ { j } ^ { t } ) = \frac { p ( \pmb { \mu } _ { k } ) \exp ( \pmb { \mu } _ { k } ^ { T } \pmb { f } _ { j } ^ { t } ) } { \sum _ { k ^ { \prime } = 1 } ^ { K } p ( \pmb { \mu } _ { k ^ { \prime } } ) \exp ( \pmb { \mu } _ { k ^ { \prime } } ^ { T } \pmb { f } _ { j } ^ { t } ) } , k \in \{ 1 , \ldots , K \} , } \end{array}
+$$
+
+where, through the lens of Bayes’ rule, $p ( \pmb { \mu } _ { k } )$ is the discrete prior distribution over the $K$ classes for the target domain, and $\exp ( \mu _ { k } ^ { T } f _ { j } ^ { t } )$ plays the role of an unnormalized likelihood term, measuring the similarity between class prototypes and target features. Intuitively, the target features are more likely to be moved to the prototypes which correspond to dominant classes in the target domain or which are closer to the target features (or both). Note that in practice we often do not have access to the target class distribution $p ( \pmb { \mu } _ { k } )$ . We can use a uniform prior distribution for $p ( \boldsymbol { \mu _ { k } } )$ . However, this could be sub-optimal, especially when classes are seriously imbalanced in the target domain. To address this issue, we propose a way to estimate $\{ p ( \mu _ { k } ) \} _ { k = 1 } ^ { K }$ in Section 2.3.
+
+We now define the expected cost of moving the target features to class prototypes as:
+
+$$
+\begin{array} { r l } & { \mathcal { L } _ { t  \mu } = \mathbb { E } _ { \boldsymbol { x } _ { j } ^ { t } \sim \mathcal { D } _ { t } ^ { \mathrm { o r } } } \mathbb { E } _ { \mu _ { k } \sim \pi \boldsymbol { \theta } ( \mu _ { k } \mid f _ { j } ^ { t } ) } [ c ( \mu _ { k } , f _ { j } ^ { t } ) ] = \mathbb { E } _ { \boldsymbol { x } _ { j } ^ { t } \sim \mathcal { D } _ { t } ^ { \mathrm { o r } } } [ \sum _ { k = 1 } ^ { K } c ( \mu _ { k } , f _ { j } ^ { t } ) \frac { p ( \mu _ { k } ) \exp ( \mu _ { k } ^ { T } f _ { j } ^ { t } ) } { \sum _ { k ^ { \prime } = 1 } ^ { K } p ( \mu _ { k ^ { \prime } } ) \exp ( \mu _ { k ^ { \prime } } ^ { T } f _ { j } ^ { t } ) } ] , } \end{array}
+$$
+
+where $c ( \cdot , \cdot )$ , a point-to-point moving cost, is defined with the cosine dissimilarity as
+
+$$
+\begin{array} { r } { c ( { \pmb { \mu } } _ { k } , { \pmb f } _ { j } ^ { t } ) = 1 - \frac { { \pmb { \mu } } _ { k } ^ { T } { \pmb f } _ { j } ^ { t } } { | | { \pmb { \mu } } _ { k } | | _ { 2 } | | { \pmb f } _ { j } ^ { t } | | _ { 2 } } . } \end{array}
+$$
+
+We also consider other point-to-point costs and present the results in Section 4.2. With Eq. (3), it is straightforward to obtain an unbiased estimation of $\mathcal { L } _ { t  \mu }$ with a mini-batch from target domain $\mathcal { D } _ { t } ^ { x }$ .
+
+In this target-to-prototype direction, we are assigning each target sample to the prototypes according to their similarities and the class distribution. Intuitively, minimizing this expected moving cost encourages each target feature to get closer to neighboring class prototypes, reducing the violation of the cluster assumption. If we think of each prototype as the mode of the distribution of source features for a class, this loss encourages a mode-seeking behavior [27]. Still, this loss alone might lead to sub-optimal alignment. The feature encoder can map most of the target data to only a few prototypes. We connect this loss to entropy minimization to elucidate this point.
+
+Connection with entropy minimization. The expected cost of moving from the target domain to prototypes can be viewed as a generalization of entropy minimization [20], an effective regularization in many prior domain-adaptation works [39, 33, 40, 17]. If the point-to-point moving cost is defined as $\begin{array} { r } { c ( \pmb { \mu } _ { k } , \pmb { f } _ { j } ^ { t } ) = - \log p _ { j k } ^ { t } = - \log \frac { \exp ( \pmb { \mu } _ { k } ^ { T } \pmb { f } _ { j } ^ { t } ) } { \sum _ { k ^ { \prime } = 1 } ^ { K } \exp ( \pmb { \mu } _ { k ^ { \prime } } ^ { T } \pmb { f } _ { j } ^ { t } ) } } \end{array}$ and the conditional probability is $\begin{array} { r } { \pi _ { \boldsymbol { \theta } } ( \mu _ { k } \vert f _ { j } ^ { t } ) = p _ { j k } ^ { t } = \frac { \exp ( \mu _ { k } ^ { T } f _ { j } ^ { t } ) } { \sum _ { k ^ { \prime } = 1 } ^ { K } \exp ( \mu _ { k ^ { \prime } } ^ { T } f _ { j } ^ { t } ) } } \end{array}$ (with a uniform prior), then the expected moving cost becomes: $\begin{array} { r } { \mathcal { L } _ { t  \mu } = - \mathbb { E } _ { \pmb { x } _ { j } ^ { t } \sim \mathcal { D } _ { t } ^ { \pmb { x } } } \big [ \sum _ { k = 1 } ^ { K } p _ { j k } ^ { t } \log p _ { j k } ^ { t } \big ] } \end{array}$ , which is equivalent to minimizing the entropy on the target samples. Entropy minimization alone also has a mode-seeking behavior and has the same tendency to drop some modes (class prototypes). In other words, one trivial solution is to assign the same one-hot encoding to all the target samples [41, 42].
+
+# 2.2.2 Moving from class prototypes to target domain
+
+To ensure that each prototype has some target features located close by and avoid dropping class prototypes, we propose to add a cost of tto target features. Given a mini-batch, $\{ \pmb { x } _ { j } ^ { t } \} _ { j = 1 } ^ { M }$ ite direction [27], i.e., mov, of target samples of size $M$ from the p, denoting $\hat { p } ( f ^ { \varepsilon } ) ^ { \ast } =$ PMj=1 1M δftj as the empirical distribution of the target features in this mini-batch, the probabilities of moving from a prototype $\pmb { \mu } _ { k }$ to the $M$ target features is defined as a conditional distribution:
+
+$$
+\begin{array} { r } { \pi _ { \theta } ( f _ { j } ^ { t } \mid \mu _ { k } ) = \frac { \hat { p } ( f _ { j } ^ { t } ) \exp ( \mu _ { k } ^ { T } f _ { j } ^ { t } ) } { \sum _ { j ^ { \prime } = 1 } ^ { M } \hat { p } ( f _ { j ^ { \prime } } ^ { t } ) \exp ( \mu _ { k } ^ { T } f _ { j ^ { \prime } } ^ { t } ) } = \frac { \exp ( \mu _ { k } ^ { T } f _ { j } ^ { t } ) } { \sum _ { j ^ { \prime } = 1 } ^ { M } \exp ( \mu _ { k } ^ { T } f _ { j ^ { \prime } } ^ { t } ) } , \quad f _ { j } ^ { t } \in \{ f _ { 1 } ^ { t } , \ldots , f _ { M } ^ { t } \} . } \end{array}
+$$
+
+As opposed to the probabilities of moving a target feature to different class prototypes $\pi _ { \boldsymbol { \theta } } ( \mu _ { k } \vert \boldsymbol { f } _ { j } ^ { t } )$ $\pi _ { \pmb { \theta } } ( f _ { j } ^ { t } | \mu _ { k } )$ normalizes the probabilities across the $M$ target samples for each prototype, which ensures that each prototype will be assigned to some target features. Then, the expected cost of moving along this prototype-to-target direction is defined as:
+
+$$
+\begin{array} { r l } & { \mathcal { L } _ { \mu \to t } = \mathbb { E } _ { \{ \mathbf { x } _ { j } ^ { t } \} _ { j = 1 } ^ { M } \sim \mathcal { D } _ { t } ^ { \infty } } \mathbb { E } _ { \mu _ { k } \sim p ( \mu _ { k } ) } \mathbb { E } _ { f _ { j } ^ { t } \sim \pi _ { \theta } ( f _ { j } ^ { t } \mid \mu _ { k } ) } \left[ c ( \mu _ { k } , f _ { j } ^ { t } ) \right] } \\ & { \qquad = \mathbb { E } _ { \{ \mathbf { x } _ { j } ^ { t } \} _ { j = 1 } ^ { M } \sim \mathcal { D } _ { t } ^ { \infty } } \left[ \sum _ { k = 1 } ^ { K } p ( \mu _ { k } ) \sum _ { j = 1 } ^ { M } c ( \mu _ { k } , f _ { j } ^ { t } ) \frac { \exp ( \mu _ { k } ^ { T } f _ { j } ^ { t } ) } { \sum _ { j ^ { \prime } = 1 } ^ { M } \exp ( \mu _ { k } ^ { T } f _ { j ^ { \prime } } ^ { t } ) } \right] , } \end{array}
+$$
+
+which can be estimated by drawing a mini-batch of $M$ target samples.
+
+Finally, combining the classification loss in Eq. (1), target-to-prototype moving cost in Eq. (3), and prototype-to-target moving cost in Eq. (6), our loss is expressed as
+
+$$
+{ \mathcal { L } } _ { \mathrm { c l s } } + { \mathcal { L } } _ { t  \mu } + { \mathcal { L } } _ { \mu  t } .
+$$
+
+Note that we treat $\pmb { \mu }$ as fixed in both $\mathcal { L } _ { t  \mu }$ and $\mathcal { L } _ { \mu \to t }$ . This strategy allows us to apply our method in the source-data-private setting where we only have access to the source model. We also find empirically that this leads to more stable training.
+
+# 2.3 Learning class proportions in the target domain
+
+We propose to infer the class proportions $\{ p ( \mu _ { k } ) \} _ { k = 1 } ^ { K }$ in the target domain by maximizing the loglikelihood of the unlabeled target data while fixing the class prototypes $\pmb { \mu }$ . Directly optimizing the marginal likelihood is intractable, so we use the EM algorithm [43–45] to derive the following iterative updates (see the derivation in Appendix B). We first initialize with a uniform prior: $\begin{array} { r } { p ( \mu _ { k } ) ^ { 0 } = \frac { 1 } { K } } \end{array}$ , and obtain new estimates at each update step (starting from 0):
+
+$$
+\begin{array} { r } { p ( \pmb { \mu } _ { k } ) ^ { l + 1 } = \frac { 1 } { M } \sum _ { j = 1 } ^ { M } \pi _ { \pmb { \theta } } ^ { l } ( \pmb { \mu } _ { k } \mid \pmb { f } _ { j } ^ { t } ) , \mathrm { w h e r e } \pi _ { \pmb { \theta } } ^ { l } ( \pmb { \mu } _ { k } \mid \pmb { f } _ { j } ^ { t } ) = \frac { p ( \pmb { \mu } _ { k } ) ^ { l } \exp ( \pmb { \mu } _ { k } ^ { T } \pmb { f } _ { j } ^ { t } ) } { \sum _ { k ^ { \prime } = 1 } ^ { K } p ( \pmb { \mu } _ { k ^ { \prime } } ) ^ { l } \exp ( \pmb { \mu } _ { k ^ { \prime } } ^ { T } \pmb { f } _ { j } ^ { t } ) } . } \end{array}
+$$
+
+Intuitively, the average predicted probabilities over the target examples for each class are used to estimate the target proportions, with $p ( \pmb { \mu } _ { k } ) ^ { l + 1 }$ shown above providing an estimate based on a single mini-batch of $M$ target samples. To estimate it based on the full dataset, we iteratively update it with $p ( \pmb { \mu } _ { k } ) ^ { l + 1 }  ( 1 - \beta ^ { \overline { { l } } } ) p ( \pmb { \mu } _ { k } ) ^ { \overline { { l } } } + \beta ^ { l } p ( \pmb { \mu } _ { k } ) ^ { l + 1 }$ , where we follow the decaying schedule of the learning rate of the other parameters to set $\beta ^ { l } = \beta _ { 0 } ( 1 + \gamma l ) ^ { - \alpha }$ , in which $\gamma = 0 . 0 0 0 2$ , $\alpha = 0 . 7 5$ . The inintial value $\beta _ { 0 }$ is a hyper-parameter that can be set as either 0 to indicate a uniform prior, or a small value, such as 0.001, to allow the class proportions to be inferred from the data.
+
+# 3 Related work
+
+Feature distribution alignment. Most works on domain adaptation with deep learning focus on feature alignment to align either the marginal distributions [46, 6, 8, 47, 48] or the joint distributions [7, 26] of the deep features of neural networks. Early works use adversarial-based objectives, which are equivalent to minimizing the Jensen–Shannon (JS) divergence [49]. When the source and target domains have non-overlapping supports, the JS divergence fails to supply useful gradients [50, 51]. To remedy this issue, researchers propose using the Wasserstein distance, which arises from the optimal transport problem [52]. Courty et al. [9] develop Joint Distribution Optimal Transport (JDOT), defining the transport cost to be the joint cost in the data and prediction spaces. Several works [10, 12] extend this framework for deep neural networks. However, solving for the optimal couplings without any relaxation is a linear programming problem, which has a complexity of $\mathcal { O } ( M ^ { 3 } \log M )$ [53]. Computing the transport probabilities in our algorithm has a complexity of $\mathcal { O } ( d _ { f } M K )$ , which is the same complexity as computing the predictive probabilities that need to be computed by most algorithms. In this category, all the works focus on aligning the target features with source features, whereas we align the target features with prototypes.
+
+Prototype-based alignment. We make two distinctions to existing works in this area. First, prior domain-adaptation works for classification [29–31] and segmentation [54, 55] utilize prototypes for pseudo-label assignments. By contrast, we use prototypes to behave as representative samples of the source features to define the loss. Second, all of these works use some form of average latent features to construct class prototypes, which is computationally expensive. We instead adopt a parametric approach to learn the prototypes, avoiding that costly computation.
+
+Learning under shifted class proportions. Although a shift in class proportions between two domains is a common problem in many applications, it is still largely under-explored. Over the years, researchers have viewed the question through different lenses: applying kernel distribution embedding [56, 57, 21], using an EM update [43, 58], placing a meta-prior over the target proportions [59], and casting the problem under causal and anti-causal learning [21–25]. Recently, Tachet des Combes et al. [18] propose aligning the target feature distribution with a re-weighted version of the source feature distribution. While this method achieves consistent improvements over feature-alignment algorithms, it still relies on learning domain-invariant representations. As we have discussed, this approach suffers from the problems of sampling variability and class-mismatching in a mini-batch, whereas the proposed method uses class prototypes and proportion estimation to avoid these issues.
+
+Source-private adaptation. Finally, the proposed method can also be applied to a source-private setting where without seeing the raw source data, we only have access to the source model and target data while adapting to the target domain [31, 47, 60–63]. Liang et al. [31] introduce a clustering-based approach to generate pseudo-labels for the target data. That approach requires constructing class centers using a weighted average of the latent features. Different from that work, our prototypes behave as class centers and are more amenable to mini-batch stochastic gradient based training.
+
+# 4 Experiments
+
+In this section, we evaluate our method under four practical settings: single-source, multi-source, class-imbalance, and source-private domain adaptation. We present the setup, the results, and the analysis of the results in the upcoming sections.
+
+Datasets. We use the following three datasets of varying sizes in our experiment: 1) Office-31 [3] consists of 4652 images coming from three domains: Amazon (A), Webcam (W), and DSLR (D). The total number of categories is 31. 2) Office-Home [64], a more challenging dataset than Office-31, consists of 15,500 images over 65 classes and four domains: Artistic images (Ar), Clip art (Cl), Product images $( \mathrm { P r } )$ , and Real-world (Rw). 3) DomainNet [65] is a large-scale dataset for domain adaptation. It consists of about 569,010 images with 345 categories from six domains: Clipart, Infograph, Painting, Quickdraw, Real, and Sketch. We further perform experiments on Cross-Digits, ImageClef, Office-Caltech, and VisDA datasets and provide the details in Appendix E.2.
+
+Implementation details. We implement our method on top of the open-source transfer learning library (MIT license) [66], adopting the default neural network architectures for both the feature encoder and linear classifier. For the feature encoder network, we utilize a pre-trained ResNet-50 in all experiments except for multi-source domain adaptation, where we use a pre-trained ResNet-101. We fine-tune the feature encoder and train the linear layers from random initialization. The linear layers have the learning rate of 0.01, 10 times that of the feature encoder. The learning rate follows the following schedule as $\eta _ { \mathrm { i t e r } } = \eta _ { 0 } ( 1 + \gamma \mathrm { i t e r } ) ^ { - \alpha }$ , where $\eta _ { 0 }$ is the initial learning rate. We set $\eta _ { 0 }$ to 0.01, $\gamma$ to 0.0002, and $\alpha$ to 0.75. We utilize a mini-batch SGD with a momentum of 0.9. We set the batch size for the source data as $N = 3 2$ and that for the target data as $M = 9 6$ . We use all the labeled source samples and unlabeled target samples [6, 7, 26]. We set $\beta _ { 0 }$ to 0 (a uniform prior) in all settings except for the sub-sampled target datasets. We perform a sensitivity analysis (see Appendix E) and set $\beta _ { 0 }$ empirically to 0.001 for the sub-sampled target version of Office-31 and 0.0001 for that of Office-Home. We report the average accuracy from three independent runs. All experiments are conducted using a single Nvidia Tesla V100 GPU except for the DomainNet experiment, where we use four V100 GPUs. More implementation details can be found in Appendix D.
+
+# 4.1 Main results
+
+Single-source setting. We perform single-source domain adaptation on the Office-31 and OfficeHome datasets. In each experiment, one domain serves as the source domain and another as the target domain. We consider all permutations, leading to 6 tasks for the Office-31 dataset and 12 tasks for the Office-Home dataset. We compare our algorithm with state-of-the-art algorithms for domain adaptations from three different categories: adversarial-based, divergence-based, and optimal transport-based. We report the results on Office-31 in Table 1. PCT significantly outperforms the baselines, especially on the more difficult transfer tasks $\mathrm { ( D { \to } A }$ and $\mathbf { W } \to \mathbf { A }$ ). Although MDD [67], the best baseline domain-adaptation method, uses a bigger classifier, PCT still has $1 . 1 \%$ higher average accuracy. In Figure 4a, we visualize the number of parameters versus the average accuracy on the Office-31 dataset. While PCT uses fewer parameters than most methods, it still achieves the highest average accuracy. We report the average accuracies on the Office-Home dataset in Table 2. PCT outperforms baseline methods on 10 of the 12 transfer tasks, yielding $3 . 7 \%$ improvement on the average accuracy over MDD. The results in this setting demonstrate that aligning the target features with prototypes is more effective than directly aligning them with the source features.
+
+Table 1: Accuracy $( \% )$ on Office-31 for unsupervised domain adaptation (ResNet-50).   
+
+<table><tr><td>Category</td><td>Method</td><td>A→W</td><td>D→W</td><td>W→D</td><td>A→D</td><td>D→A</td><td>W→A</td><td>Avg</td></tr><tr><td></td><td>ResNet-50 [68]</td><td>68.4±0.2</td><td>96.7±0.1</td><td>99.3±0.1</td><td>68.9±0.2</td><td>62.5± 0.3</td><td>60.7±0.3</td><td>76.1</td></tr><tr><td rowspan="4">Adversarial</td><td>DANN [6]</td><td>82.0±0.4</td><td>96.9±0.2</td><td>99.1±0.1</td><td>79.7±0.4</td><td>68.2±0.4</td><td>67.4±0.5</td><td>82.2</td></tr><tr><td>ADDA [47]</td><td>86.2±0.5</td><td>96.2±0.3</td><td>98.4±0.3</td><td>77.8± 0.3</td><td>69.5 ± 0.4</td><td>68.9±0.5</td><td>82.9</td></tr><tr><td>CDAN [26]</td><td>94.1± 0.1</td><td>98.6±0.1</td><td>100.0±0.0</td><td>92.9±0.2</td><td>71.0±0.3</td><td>69.3±0.3</td><td>87.7</td></tr><tr><td>MDD[67]</td><td>94.5 ±0.3</td><td>98.4±0.1</td><td>100.0±0.0</td><td>93.5±0.2</td><td>74.6±0.3</td><td>72.2±0.1</td><td>88.9</td></tr><tr><td rowspan="2">Divergence</td><td>JAN [7]</td><td>85.4± 0.3</td><td>97.4±0.2</td><td>99.8±0.2</td><td>84.7±0.3</td><td>68.6±0.3</td><td>70.0±0.4</td><td>84.3</td></tr><tr><td>TPN [29]</td><td>91.2 ±0.3</td><td>97.7±0.2</td><td>99.5 ±0.1</td><td>89.9±0.2</td><td>70.5±0.2</td><td>73.5± 0.1</td><td>87.1</td></tr><tr><td rowspan="2">OT</td><td>DeepJDOT[10]</td><td>88.9±0.3</td><td>98.5 ±0.1</td><td>99.6±0.2</td><td>88.2±0.1</td><td>72.1±0.4</td><td>70.1± 0.4</td><td>86.2</td></tr><tr><td>ETD [69]</td><td>92.1</td><td>100.0</td><td>100.0</td><td>88.0</td><td>71.0</td><td>67.8</td><td>86.2</td></tr><tr><td></td><td>PCT (Ours)</td><td>94.6± 0.5</td><td>98.7±0.4</td><td>99.9±0.1</td><td>93.8±1.8</td><td>77.2 ± 0.5</td><td>76.0±0.9</td><td>90.0</td></tr></table>
+
+Table 2: Accuracy $( \% )$ on Office-Home for unsupervised domain adaptation (ResNet-50).   
+
+<table><tr><td>Method</td><td colspan="10">Ar→Cl Ar→Pr Ar→RwCl→Ar Cl→Pr Cl→Rw Pr→Ar Pr→ClPr→Rw Rw→ArRw→ClRw→Pr Avg</td></tr><tr><td>ResNet-50 [68]</td><td>34.9</td><td>50.0 58.0</td><td>37.4</td><td>41.9</td><td>46.2</td><td>38.5</td><td>31.2</td><td></td><td>60.4</td><td>53.9</td><td>41.2</td><td>59.9 46.1</td></tr><tr><td>DANN [6]</td><td>45.6</td><td>59.3 70.1</td><td>47.0</td><td>58.5</td><td>60.9</td><td>46.1</td><td>43.7</td><td>68.5</td><td>63.2</td><td>51.8</td><td>76.8</td><td>57.6</td></tr><tr><td>CDAN [26]</td><td>50.7</td><td>70.6 76.0</td><td>57.6</td><td>70.0</td><td>70.0</td><td>57.4</td><td>50.9</td><td>77.3</td><td>70.9</td><td>56.7</td><td>81.6</td><td>65.8</td></tr><tr><td>MDD[67]</td><td>54.9</td><td>73.7 77.8</td><td>60.0</td><td>71.4</td><td>71.8</td><td>61.2</td><td>53.6</td><td>78.1</td><td>72.5</td><td>60.2</td><td>82.3</td><td>68.1</td></tr><tr><td>JAN[7]</td><td>45.9 61.2</td><td>68.9</td><td>50.4</td><td>59.7</td><td>61.0</td><td>45.8</td><td>43.4</td><td>70.3</td><td>63.9</td><td>52.4</td><td>76.8</td><td>58.3</td></tr><tr><td>TPN [29]</td><td>51.2 71.2</td><td>76.0</td><td>65.1</td><td>72.9</td><td>72.8</td><td>55.4</td><td>48.9</td><td>76.5</td><td>70.9</td><td>53.4</td><td>80.4</td><td>66.2</td></tr><tr><td>DeepJDOT[10]</td><td>48.2</td><td>69.2 74.5</td><td>58.5</td><td>69.1</td><td>71.1</td><td>56.3</td><td>46.0</td><td>76.5</td><td>68.0</td><td>52.7</td><td>80.9</td><td>64.3</td></tr><tr><td>ETD [69]</td><td>51.3</td><td>71.9 85.7</td><td>57.6</td><td>69.2</td><td>73.7</td><td>57.8</td><td>51.2</td><td>79.3</td><td>70.2</td><td>57.5</td><td>82.1</td><td>67.3</td></tr><tr><td>PCT(Ours)</td><td>57.1±0.378.3±.281.4±0.467.6±0.377.0±.2765±0.568.±.5550±0.61.3±.274.7±0.560.0±.55.71.</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr></table>
+
+Multi-source setting. In this setting, we evaluate our method using Office-Home and DomainNet datasets [65]. For each task, we select one domain as the target domain and use the remaining five domains as the source. We use the same data splitting scheme as the original paper [65]. We compare against source-combined and multi-source algorithms introduced in Venkat et al. [70] for Office-Home and in Peng et al. [65] for DomainNet. Multi-source algorithms use domain labels and a classifier for each source domain, whereas source-combined algorithms combine all the source domains into a single source domain and perform single-source adaptation. We adopt a single classifier and do not use domain labels. Thus, PCT falls under the source-combined category. We report the results in Tables 3 and 4. While PCT is not designed specifically for multi-source domain adaptation, our method still outperforms those multi-source algorithms in both datasets. Since there are more variations of the data in the source domain in this setting, the increase in performance gain verifies our intuition that prototypes help mitigate the problem of sampling variability.
+
+Table 3: Accuracy $( \% )$ on Office-Home for ResNet50-based MSDA method   
+
+<table><tr><td>Category</td><td>Models</td><td>R→Ar</td><td>R→Cl</td><td>R→Pr</td><td>R→Rw</td><td>Avg</td></tr><tr><td rowspan="3">Source- combined</td><td>DAN [8]</td><td>68.5</td><td>59.4</td><td>79.0</td><td>82.5</td><td>72.4</td></tr><tr><td>D-CORAL[71]</td><td>68.1</td><td>58.6</td><td>79.5</td><td>82.7</td><td>72.2</td></tr><tr><td>RevGrad [6]</td><td>68.4</td><td>59.1</td><td>79.5</td><td>82.7</td><td>72.4</td></tr><tr><td rowspan="2">Multi-source</td><td>MFSAN[72]</td><td>72.1</td><td>62.0</td><td>80.3</td><td>81.8</td><td>74.1</td></tr><tr><td>SImpAl[70]</td><td>70.8</td><td>56.3</td><td>80.2</td><td>81.5</td><td>72.2</td></tr><tr><td></td><td>PCT(Ours)</td><td>76.3±0.5</td><td>64.1± 0.4</td><td>84.9±0.8</td><td>84.3±0.5</td><td>77.4</td></tr></table>
+
+Table 4: Accuracy $( \% )$ on DomainNet for ResNet101-based MSDA methods.   
+
+<table><tr><td>Category</td><td>Models</td><td>R→Clipart</td><td>R→Infograph</td><td>R→Painting</td><td>R→Quickdraw</td><td>R→Real</td><td>R→Sketch</td><td>Avg</td></tr><tr><td rowspan="4">Multi-source</td><td>DCTN [73]</td><td>48.6±0.7</td><td>23.5±0.6</td><td>48.8±0.6</td><td>7.2 ± 0.4</td><td>53.5±0.6</td><td>47.3±0.5</td><td>38.2±0.6</td></tr><tr><td>MSDA [65]</td><td>57.2 ± 1.0</td><td>24.2 ± 1.2</td><td>51.6 ± 0.4</td><td>5.2±0.5</td><td>61.6±0.9</td><td>49.6± 0.6</td><td>41.5± 0.7</td></tr><tr><td>M SDA-β[65]</td><td>58.6± 0.5</td><td>26.0±0.9</td><td>52.3 ±0.6</td><td>6.3±0.6</td><td>62.7± 0.5</td><td>49.5 ± 0.8</td><td>42.6±0.6</td></tr><tr><td>ML-MSDA [74]</td><td>61.4 ± 0.8</td><td>26.2 ± 0.4</td><td>51.9 ±0.2</td><td>19.1 ± 0.3</td><td>57.0 ± 1.0</td><td>50.3±0.7</td><td>44.3± 0.6</td></tr><tr><td rowspan="10">Source- combined</td><td>ResNet-101 [24]</td><td>47.6±0.5</td><td>13.0 ± 0.4</td><td>38.1±0.5</td><td>13.3 ± 0.4</td><td>51.9 ± 0.9</td><td>33.7±0.5</td><td>32.9±0.5</td></tr><tr><td>DAN[8]</td><td>45.4± 0.5</td><td>12.8 ± 0.9</td><td>36.2 ±0.6</td><td>15.3 ± 0.4</td><td>48.6±0.7</td><td>34.0 ±0.5</td><td>32.1±0.6</td></tr><tr><td>RTN[75]</td><td>44.2 ± 0.6</td><td>12.6 ±0.7</td><td>35.3±0.6</td><td>14.6 ±0.8</td><td>48.4±0.7</td><td>31.7±0.7</td><td>31.1± 0.7</td></tr><tr><td>JAN[7]</td><td>40.9 ± 0.4</td><td>11.1 ± 0.6</td><td>35.4± 0.5</td><td>12.1 ± 0.7</td><td>45.8 ± 0.6</td><td>32.3±0.6</td><td>29.6±0.6</td></tr><tr><td>DANN [6]</td><td>45.5 ± 0.6</td><td>13.1 ± 0.7</td><td>37.0±0.7</td><td>13.2 ± 0.8</td><td>48.9 ± 0.7</td><td>31.8±0.6</td><td>32.6±0.7</td></tr><tr><td>ADDA [47]</td><td>47.5± 0.8</td><td>11.4 ± 0.7</td><td>36.7±0.5</td><td>14.7 ± 0.5</td><td>49.1 ± 0.8</td><td>33.5 ±0.5</td><td>32.2±0.6</td></tr><tr><td>SE[38]</td><td>24.7± 0.3</td><td>3.9±0.5</td><td>12.7 ± 0.4</td><td>7.1 ± 0.5</td><td>22.8±0.5</td><td>9.1± 0.5</td><td>16.1 ± 0.4</td></tr><tr><td>MCD[76]</td><td>54.3 ±0.6</td><td>22.1±0.7</td><td>45.7± 0.6</td><td>7.6± 0.5</td><td>58.4±0.7</td><td>43.5 ±0.6</td><td>38.5±0.6</td></tr><tr><td>PCT(Ours)</td><td>67.2±0.5</td><td>26.1±0.2</td><td>55.0±0.2</td><td>16.2 ± 0.2</td><td>67.1±0.2</td><td>53.7± 0.6</td><td>47.6 ± 0.1</td></tr></table>
+
+Sub-sampled setting. In many cases, the label proportions could significantly change from one dataset to another, resulting in a decrease in a model’s performance. To test our algorithm under this setting, we follow the experimental protocol in Tachet des Combes et al. [18]. We keep only thirty percent of the first $\lfloor K / 2 \rfloor$ classes to simulate class imbalance. We directly take their results for the sub-sampled source data and perform additional experiments using the same sub-sampling scheme on the target data. The baselines in this setting are standard domain adaptation methods (DAN, JAN, and CDAN) and their importance weighted versions introduced in Tachet des Combes et al. [18]. We present the results in Table 5. On the sub-sampled source data, PCT with uniform prior outperforms the second-best method (IWCDAN) by $4 \%$ on Office-31 and $6 . 6 \%$ on Office-Home. Learning the prior distribution on the target domain does not improve the result, as this setting does not have a serious imbalance issue in the target domain. On the sub-sampled target data, PCT with a uniform prior already outperforms the baselines, $1 . 9 \%$ and $5 . 2 \%$ higher average accuracy than IWCDAN’s on Office-31 and Office-Home, respectively. Using a learnable prior further improves upon using a uniform prior by $1 . 0 \%$ on Office-31 and by $0 . 4 \%$ on Office-Home. The improvements confirm our intuition that prototypes help with the class imbalance in both the source and target domain while estimating the target proportion further boosts the performance in the target domain sub-sampled setting. We visualize the estimated proportions on the target data in Figure 3, verifying that the proportions are inferred correctly.
+
+Table 5: Average accuracy $( \% )$ on sub-sampled version of Office-31 and Office-Home (ResNet-50).   
+
+<table><tr><td>Method</td><td>sub-S O-31</td><td>sub-T O-31</td><td>sub-S O-H</td><td>sub-T O-H</td></tr><tr><td>ResNet-50 [68]</td><td>75.7</td><td>76.1</td><td>51.4</td><td>58.2</td></tr><tr><td>DANN [8]</td><td>76.2</td><td>75.9</td><td>51.8</td><td>58.3</td></tr><tr><td>JAN [7]</td><td>78.2</td><td>78.1</td><td>53.9</td><td>61.4</td></tr><tr><td>CDAN [26]</td><td>81.6</td><td>83.0</td><td>56.3</td><td>63.1</td></tr><tr><td>IWDAN[18]</td><td>82.6</td><td>79.2</td><td>57.6</td><td>58.6</td></tr><tr><td>IWJAN [18]</td><td>82.6</td><td>82.8</td><td>55.9</td><td>62.0</td></tr><tr><td>IWCDAN[18]</td><td>83.9</td><td>83.5</td><td>61.2</td><td>64.6</td></tr><tr><td>PCT-Uniform (Ours)</td><td>87.9 ± 0.4</td><td>85.4± 0.3</td><td>67.8 ± 0.3</td><td>69.8 ±0.2</td></tr><tr><td>PCT-Learnable (Ours)</td><td>87.9 ± 0.4</td><td>86.4±0.2</td><td>67.8± 0.3</td><td>70.2±0.2</td></tr></table>
+
+Source-data-private setting. In many practical applications, practitioners might not directly have access to the source data in the adaptation stage. Instead, a trained model on the source data is provided. In this setting, the goal is to adapt to the target domain while only operating on the given model. We compare our method with Source Hypothesis Transfer (SHOT) [31], a state-ofthe-art method proposed specifically for this setting. SHOT contains two losses: an information maximization (IM) loss and a pseudo-labeling loss. We follow their experimental protocol by first training the model on the source data alone. During the adaptation stage, we only use the target data to perform model adaptation. We use the transport losses to update the feature encoder while fixing the prototypes. We report the results in Table 6. From the standard setting where we have access to source data in Table 1, the average accuracy drops by $1 . 6 \%$ for Office-31 and by $0 . 8 \%$ for Office-Home. On the Office-31 dataset, our bi-directional loss outperforms the IM loss by $1 . 1 \%$ and the pseudo label loss by $0 . 8 \%$ . While the average accuracy for our method is $0 . 2 \%$ lower than both of their losses combined, the $p$ -value for the independent two-sample $t$ -test on the accuracies of different runs is 0.32, which is not statistically significant. On the Office-Home dataset, our approach performs $1 . 9 \%$ and $0 . 5 \%$ better than the pseudo label and IM losses, respectively. While their combined loss achieves $0 . 8 \%$ accuracy higher than that of our method, the pseudo-labeling loss in SHOT requires constructing class centers, which does not scale well with large datasets. Our approach uses the classifier’s weights as class prototypes to avoid this issue.
+
+![](images/0c57924c6548f08669103181256f43a1cc612dedc967154b928bff9d5ab61cb9.jpg)  
+Figure 3: Visualization of the estimated target proportions versus true class proportions for the task $\mathbf { A }  \mathbf { s D }$ on the Office-31 dataset. The dotted line represents a uniform proportion. It is clear that each orange bar (the learned proportions) is close to its adjacent blue bar (the true proportion). To quantify this observation, we measure the L1 loss between the true and learned proportions. The estimated proportions achieve lower L1 loss than the uniform distribution (0.16 vs 0.58), illustrating the effectiveness of our estimation strategy.
+
+Table 6: Average Accuracy $( \% )$ on the source-private Office-31 and Office-Home (ResNet-50).   
+
+<table><tr><td></td><td>Source Model Only</td><td>SHOT-Pseudo Label [31]</td><td>SHOT-IM[31]</td><td>SHOT [31]</td><td>PCT (Ours)</td></tr><tr><td>Office-31</td><td>79.3</td><td>87.6±0.5</td><td>87.3 ±0.5</td><td>88.6± 0.4</td><td>88.4 ±0.6</td></tr><tr><td>Office-Home</td><td>60.2</td><td>69.1 ±0.6</td><td>70.5±0.3</td><td>71.8 ± 0.4</td><td>71.0 ±0.6</td></tr></table>
+
+# 4.2 Analysis of results
+
+Ablation study. To examine the effect of each component in our framework, we perform ablation studies and present the results in Table 7. 1) Alignment strategy. Next, we present the result using optimal transport as the alignment strategy. We consider two variants of Prototype-oriented Optimal Transport (POT): exact linear program (POT) and Sinkhorn relaxation (POT-Sinkhorn). In each variant, we solve for the optimal couplings using the optimal transport formulation. After obtaining the transport probabilities, we update the feature encoder using the obtained probabilities as the weights for the transport cost. We can see that POT performs $1 . 7 \%$ better than DeepJDOT in Table 1, showing the effectiveness of using prototypes to define the transport costs with the target features. Still, both versions of POT underperforms PCT by $2 . 1 \%$ and $1 . { \bar { 7 } } \%$ , respectively. 2) Effect of each loss in PCT. We examine the effect of each loss on the average test accuracy on the Office-31 dataset. We remove each transport loss while keeping the cross-entropy loss. The bi-directional loss leads to the best accuracy, while the drop in accuracy is more significant if we remove $\mathcal { L } _ { \mu \to t }$ . This result is not surprising because, without $\mathcal { L } _ { \mu \to t }$ , the model can map target data to only a few prototypes, leading to a degenerate solution. 3) Gradient stopping. We also show the algorithm’s performance without stopping the gradient of $\pmb { \mu }$ in the transport loss. PCT gains an additional $1 . 0 \%$ in accuracy with the gradient stopping strategy. The performance gain is consistent with the finding in recent work by Chen and He [77], where the authors apply the gradient stopping strategy to avoid degenerate solutions in contrastive learning. 4) Cost function. Finally, we explore the cost function inspired by the radial basis kernel. We can see that the cosine distance in PCT gives $3 . 1 \%$ higher average accuracy. In short, the choice of the probabilistic bi-directional transport framework, gradient-stopping strategy, and point-to-point cost function all contribute to the success of the proposed PCT method.
+
+Table 7: Average accuracy $( \% )$ of PCT on Office-31 under different variants (ResNet-50).   
+
+<table><tr><td>POT</td><td>POT-Sinkhorn</td><td>PCT w/o (Lt→μ)</td><td>PCT w/o (Lμ→t)</td><td>）w/o stop-grad</td><td>c(μk,fj）=exp(-μTf)</td><td>PCT (Ours)</td></tr><tr><td>87.9 ±0.8</td><td>88.3±0.9</td><td>88.6±0.2</td><td>84.3± 0.9</td><td>89.0 ±0.3</td><td>86.9 ±0.4</td><td>90.0±0.5</td></tr></table>
+
+![](images/81dc488a69bc5d1f0b5726e1cae2aafe2e6e623c7c3585f3e997453145926eae.jpg)  
+Figure 4: (a) Analysis of parameter efficiency, (b) comparison of convergence, and (c) a t-SNE visualization of the output of the feature encoder trained with PCT on the task $\mathbf A \to \mathbf W$ . In plot (c), prototypes $( { \star } )$ , source features $( \cdot )$ , and target features $( \times )$ are tightly clustered together for each class.
+
+Convergence comparison. We plot test accuracy versus iteration number on the task $( \mathbf { A } \to \mathbf { W } )$ ) in Figure 4b to compare the convergence rate of different algorithms. We also visualize test accuracy versus convergence time in minutes in Appendix E. In both plots, PCT quickly converges within the first one thousand iterations, and the test accuracy does not fluctuate much thereafter. This phenomenon is not surprising since we use prototypes instead of the source features to align with the target features. We expect the prototypes to behave as representative samples of the source features, making the model converge quickly and stably.
+
+Visualization. We visualize in Figure 4c the t-SNE plot of the source and target features as well as the prototypes for the task $\mathbf A \to \mathbf W$ . Figure 4c shows that both the source (dots ·) and target (crosses $\times )$ features are close to the prototypes (black stars $\star$ ), indicating that our algorithm is learning meaningful prototypes and successfully align the target features with the prototypes.
+
+# 5 Conclusion
+
+We offer a holistic framework for unsupervised domain adaptation through the lens of a probabilistic bi-directional transport between the target features and class prototypes. With extensive experiments under various application scenarios of unsupervised domain adaptation, we show that the proposed prototype-oriented alignment method works well on multiple datasets, is robust against class imbalance, and can perform domain adaptation with no direct access to the source data. Without adding additional model parameters, our memory and computation-efficient algorithm achieves competitive performance with state-of-the-art methods on several widely used benchmarks.
+
+# Acknowledgments
+
+We thank Camillia Smith Barnes and Georgii Riabov for helpful discussions and feedback on the paper. K. Tanwisuth, X. Fan, H. Zheng, S. Zhang, and M. Zhou acknowledge the support of Grant IIS-1812699 from the U.S. National Science Foundation, the APX 2019 project sponsored by the Office of the Vice President for Research at The University of Texas at Austin, the support of a gift fund from ByteDance Inc., and the Texas Advanced Computing Center (TACC) for providing HPC resources that have contributed to the research results reported within this paper.
+
+References   
+[1] Ali Farhadi and Mostafa Kamali Tabrizi. Learning to recognize activities from the wrong view point. In European conference on computer vision, pages 154–166. Springer, 2008.   
+[2] Hidetoshi Shimodaira. Improving predictive inference under covariate shift by weighting the log-likelihood function. Journal of statistical planning and inference, 90(2):227–244, 2000.   
+[3] Kate Saenko, Brian Kulis, Mario Fritz, and Trevor Darrell. Adapting visual category models to new domains. In European conference on computer vision, pages 213–226. Springer, 2010.   
+[4] Shai Ben-David, John Blitzer, Koby Crammer, and Fernando Pereira. Analysis of representations for domain adaptation. In B. Schölkopf, J. Platt, and T. Hoffman, editors, Advances in Neural Information Processing Systems, volume 19. MIT Press, 2007.   
+[5] Shai Ben-David, John Blitzer, Koby Crammer, Alex Kulesza, Fernando Pereira, and Jennifer Vaughan. A theory of learning from different domains. Machine Learning, 79:151–175, 2010.   
+[6] Yaroslav Ganin and Victor S. Lempitsky. Unsupervised domain adaptation by backpropagation. In Francis R. Bach and David M. Blei, editors, ICML, volume 37 of JMLR Workshop and Conference Proceedings, pages 1180–1189. JMLR.org, 2015.   
+[7] Mingsheng Long, Han Zhu, Jianmin Wang, and Michael I. Jordan. Deep transfer learning with joint adaptation networks. In Doina Precup and Yee Whye Teh, editors, Proceedings of the 34th International Conference on Machine Learning, volume 70 of Proceedings of Machine Learning Research, pages 2208–2217. PMLR, 06–11 Aug 2017.   
+[8] Mingsheng Long, Yue Cao, Jianmin Wang, and Michael I. Jordan. Learning transferable features with deep adaptation networks. In Proceedings of the 32nd International Conference on Machine Learning, ICML 2015, Lille, France, 6-11 July 2015, pages 97–105, 2015.   
+[9] Nicolas Courty, Rémi Flamary, Amaury Habrard, and Alain Rakotomamonjy. Joint distribution optimal transportation for domain adaptation. 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.   
+[10] Bharath Bhushan Damodaran, Benjamin Kellenberger, Rémi Flamary, Devis Tuia, and Nicolas Courty. DeepJDOT: Deep joint distribution optimal transport for unsupervised domain adaptation. CoRR, abs/1803.10081, 2018.   
+[11] Chen-Yu Lee, Tanmay Batra, Mohammad Haris Baig, and Daniel Ulbricht. Sliced Wasserstein discrepancy for unsupervised domain adaptation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 10285–10295, 2019.   
+[12] Renjun Xu, Pelen Liu, Liyan Wang, Chao Chen, and Jindong Wang. Reliable weighted optimal transport for unsupervised domain adaptation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), June 2020.   
+[13] Arthur Gretton, Karsten M Borgwardt, Malte J Rasch, Bernhard Schölkopf, and Alexander Smola. A kernel two-sample test. The Journal of Machine Learning Research, 13(1):723–773, 2012.   
+[14] Leonid V Kantorovich. On the translocation of masses. Journal of Mathematical Sciences, 133 (4):1381–1382, 2006.   
+[15] Gabriel Peyré and Marco Cuturi. Computational optimal transport. Foundations and Trends in Machine Learning, 11(5-6):355–607, 2019.   
+[16] Matthieu Lerasle, Zoltán Szabó, Timothée Mathieu, and Guillaume Lecué. Monk outlier-robust mean embedding estimation by median-of-means. In International Conference on Machine Learning, pages 3782–3793. PMLR, 2019.   
+[17] Yogesh Balaji, Rama Chellappa, and Soheil Feizi. Robust optimal transport with applications in generative modeling and domain adaptation. In Advances in Neural Information Processing Systems, 2020.
+
+[18] Remi Tachet des Combes, Han Zhao, Yu-Xiang Wang, and Geoff Gordon. Domain adaptation with conditional distribution matching and generalized label shift. In Advances in Neural Information Processing Systems, 2020.
+
+[19] Fredrik D. Johansson, David Sontag, and Rajesh Ranganath. Support and invertibility in domaininvariant representations. In Kamalika Chaudhuri and Masashi Sugiyama, editors, Proceedings of Machine Learning Research, volume 89 of Proceedings of Machine Learning Research, pages 527–536, 16–18 Apr 2019.
+
+[20] Yves Grandvalet, Yoshua Bengio, et al. Semi-supervised learning by entropy minimization. In CAP, pages 281–296, 2005.
+
+[21] Kun Zhang, Bernhard Schölkopf, Krikamol Muandet, and Zhikun Wang. Domain adaptation under target and conditional shift. In International Conference on Machine Learning, pages 819–827. PMLR, 2013.
+
+[22] Bernhard Schölkopf, Dominik Janzing, Jonas Peters, Eleni Sgouritsa, Kun Zhang, and Joris Mooij. On causal and anticausal learning. arXiv preprint arXiv:1206.6471, 2012.
+
+[23] Mingming Gong, Kun Zhang, Tongliang Liu, Dacheng Tao, Clark Glymour, and Bernhard Schölkopf. Domain adaptation with conditional transferable components. In International conference on machine learning, pages 2839–2848. PMLR, 2016.
+
+[24] Zachary Lipton, Yu-Xiang Wang, and Alexander Smola. Detecting and correcting for label shift with black box predictors. In International conference on machine learning, pages 3122–3130. PMLR, 2018.
+
+[25] Kamyar Azizzadenesheli, Anqi Liu, Fanny Yang, and Animashree Anandkumar. Regularized learning for domain adaptation under label shifts. arXiv preprint arXiv:1903.09734, 2019.
+
+[26] Mingsheng Long, Zhangjie Cao, Jianmin Wang, and Michael I Jordan. Conditional adversarial domain adaptation. In S. Bengio, H. Wallach, H. Larochelle, K. Grauman, N. Cesa-Bianchi, and R. Garnett, editors, Advances in Neural Information Processing Systems, volume 31. Curran Associates, Inc., 2018.
+
+[27] Huangjie Zheng and Mingyuan Zhou. Comparing probability distributions with conditional transport. arXiv preprint arXiv:2012.14100, 2020.
+
+[28] Jake Snell, Kevin Swersky, and Richard Zemel. Prototypical networks for few-shot learning. In Proceedings of the 31st International Conference on Neural Information Processing Systems, pages 4080–4090, 2017.
+
+[29] Yingwei Pan, Ting Yao, Yehao Li, Yu Wang, Chong-Wah Ngo, and Tao Mei. Transferrable prototypical networks for unsupervised domain adaptation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), 2019.
+
+[30] Guoliang Kang, Lu Jiang, Yi Yang, and Alexander G Hauptmann. Contrastive adaptation network for unsupervised domain adaptation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 4893–4902, 2019.
+
+[31] Jian Liang, Dapeng Hu, and Jiashi Feng. Do we really need to access the source data? source hypothesis transfer for unsupervised domain adaptation. In International Conference on Machine Learning, pages 6028–6039. PMLR, 2020.
+
+[32] Xiangyu Yue, Zangwei Zheng, Shanghang Zhang, Yang Gao, Trevor Darrell, Kurt Keutzer, and Alberto Sangiovanni Vincentelli. Prototypical cross-domain self-supervised learning for few-shot unsupervised domain adaptation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 13834–13844, 2021.
+
+[33] Kuniaki Saito, Donghyun Kim, Stan Sclaroff, Trevor Darrell, and Kate Saenko. Semi-supervised domain adaptation via minimax entropy. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 8050–8058, 2019.
+
+[34] Takeru Miyato, Shin-ichi Maeda, Masanori Koyama, and Shin Ishii. Virtual adversarial training: a regularization method for supervised and semi-supervised learning. IEEE transactions on pattern analysis and machine intelligence, 41(8):1979–1993, 2018.   
+[35] Samuli Laine and Timo Aila. Temporal ensembling for semi-supervised learning. arXiv preprint arXiv:1610.02242, 2016.   
+[36] Yuan Shi and Fei Sha. Information-theoretical learning of discriminative clusters for unsupervised domain adaptation. arXiv preprint arXiv:1206.6438, 2012.   
+[37] Rui Shu, Hung H Bui, Hirokazu Narui, and Stefano Ermon. A dirt-t approach to unsupervised domain adaptation. arXiv preprint arXiv:1802.08735, 2018.   
+[38] Geoffrey French, Michal Mackiewicz, and Mark Fisher. Self-ensembling for visual domain adaptation. arXiv preprint arXiv:1706.05208, 2017.   
+[39] Tuan-Hung Vu, Himalaya Jain, Maxime Bucher, Matthieu Cord, and Patrick Pérez. Advent: Adversarial entropy minimization for domain adaptation in semantic segmentation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 2517–2526, 2019.   
+[40] Kuniaki Saito, Donghyun Kim, Stan Sclaroff, and Kate Saenko. Universal domain adaptation through self supervision. arXiv preprint arXiv:2002.07953, 2020.   
+[41] Pietro Morerio, Jacopo Cavazza, and Vittorio Murino. Minimal-entropy correlation alignment for unsupervised deep domain adaptation. arXiv preprint arXiv:1711.10288, 2017.   
+[42] Xiaofu Wu, Quan Zhou, Zhen Yang, Chunming Zhao, Longin Jan Latecki, et al. Entropy minimization vs. diversity maximization for domain adaptation. arXiv preprint arXiv:2002.01690, 2020.   
+[43] Marco Saerens, Patrice Latinne, and Christine Decaestecker. Adjusting the outputs of a classifier to new a priori probabilities: a simple procedure. Neural computation, 14(1):21–41, 2002.   
+[44] Guoliang Kang, Liang Zheng, Yan Yan, and Yi Yang. Deep adversarial attention alignment for unsupervised domain adaptation: the benefit of target expectation maximization. In Proceedings of the European Conference on Computer Vision (ECCV), pages 401–416, 2018.   
+[45] Amr Alexandari, Anshul Kundaje, and Avanti Shrikumar. Maximum likelihood with biascorrected calibration is hard-to-beat at label shift adaptation. In International Conference on Machine Learning, pages 222–232. PMLR, 2020.   
+[46] Eric Tzeng, Judy Hoffman, Ning Zhang, Kate Saenko, and Trevor Darrell. Deep domain confusion: Maximizing for domain invariance. arXiv preprint arXiv:1412.3474, 2014.   
+[47] Eric Tzeng, Judy Hoffman, Kate Saenko, and Trevor Darrell. Adversarial discriminative domain adaptation. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 7167–7176, 2017.   
+[48] Shujian Zhang, Xinjie Fan, Huangjie Zheng, Korawat Tanwisuth, and Mingyuan Zhou. Alignment attention by matching key and query distributions. In NeurIPS 2021: Neural Information Processing Systems, Dec. 2021. (the first two authors contributed equally).   
+[49] Ian J Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial networks. arXiv preprint arXiv:1406.2661, 2014.   
+[50] Martin Arjovsky, Soumith Chintala, and Léon Bottou. Wasserstein generative adversarial networks. In International conference on machine learning, pages 214–223. PMLR, 2017.   
+[51] Soheil Kolouri, Phillip E Pope, Charles E Martin, and Gustavo K Rohde. Sliced Wasserstein auto-encoders. In International Conference on Learning Representations, 2018.   
+[52] Cédric Villani. Optimal transport: old and new, volume 338. Springer Science & Business Media, 2008.
+
+[53] Quentin Mérigot and Edouard Oudet. Discrete optimal transport: complexity, geometry and applications. Discrete & Computational Geometry, 55(2):263–283, 2016.
+
+[54] Qiming Zhang, Jing Zhang, Wei Liu, and Dacheng Tao. Category anchor-guided unsupervised domain adaptation for semantic segmentation. arXiv preprint arXiv:1910.13049, 2019.
+
+[55] Shaoan Xie, Zibin Zheng, Liang Chen, and Chuan Chen. Learning semantic representations for unsupervised domain adaptation. In International conference on machine learning, pages 5423–5432. PMLR, 2018.
+
+[56] Marthinus Christoffel Du Plessis and Masashi Sugiyama. Semi-supervised learning of class balance under class-prior change by distribution matching. Neural Networks, 50:110–119, 2014.
+
+[57] Tuan Duong Nguyen, Marthinus Christoffel, and Masashi Sugiyama. Continuous target shift adaptation in supervised learning. In Asian Conference on Machine Learning, pages 285–300. PMLR, 2016.
+
+[58] Yee Seng Chan and Hwee Tou Ng. Word sense disambiguation with distribution estimation. In IJCAI, volume 5, pages 1010–5. Citeseer, 2005.
+
+[59] Amos Storkey. When training and test sets are different: Characterizing learning transfer. Dataset shift in machine learning, 30:3–28, 2009.
+
+[60] Rui Li, Qianfen Jiao, Wenming Cao, Hau-San Wong, and Si Wu. Model adaptation: Unsupervised domain adaptation without source data. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 9641–9650, 2020.
+
+[61] Vinod K Kurmi, Venkatesh K Subramanian, and Vinay P Namboodiri. Domain impression: A source data free domain adaptation method. In Proceedings of the IEEE/CVF Winter Conference on Applications of Computer Vision, pages 615–625, 2021.
+
+[62] Jogendra Nath Kundu, Rahul Mysore Venkatesh, Naveen Venkat, Ambareesh Revanur, and R Venkatesh Babu. Class-incremental domain adaptation. In Computer Vision–ECCV 2020: 16th European Conference, Glasgow, UK, August 23–28, 2020, Proceedings, Part XIII 16, pages 53–69. Springer, 2020.
+
+[63] Jogendra Nath Kundu, Naveen Venkat, R Venkatesh Babu, et al. Universal source-free domain adaptation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 4544–4553, 2020.
+
+[64] Hemanth Venkateswara, Jose Eusebio, Shayok Chakraborty, and Sethuraman Panchanathan. Deep hashing network for unsupervised domain adaptation. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 5018–5027, 2017.
+
+[65] Xingchao Peng, Qinxun Bai, Xide Xia, Zijun Huang, Kate Saenko, and Bo Wang. Moment matching for multi-source domain adaptation. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 1406–1415, 2019.
+
+[66] Mingsheng Long Junguang Jiang, Bo Fu. Transfer-learning-library. https://github.com/ thuml/Transfer-Learning-Library, 2020.
+
+[67] Yuchen Zhang, Tianle Liu, Mingsheng Long, and Michael Jordan. Bridging theory and algorithm for domain adaptation. In International Conference on Machine Learning, pages 7404–7413. PMLR, 2019.
+
+[68] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 770–778, 2016.
+
+[69] Mengxue Li, Yi-Ming Zhai, You-Wei Luo, Peng-Fei Ge, and Chuan-Xian Ren. Enhanced transport distance for unsupervised domain adaptation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 13936–13944, 2020.
+
+[70] Naveen Venkat, Jogendra Nath Kundu, Durgesh Kumar Singh, Ambareesh Revanur, and R Venkatesh Babu. Your classifier can secretly suffice multi-source domain adaptation. arXiv preprint arXiv:2103.11169, 2021.   
+[71] Baochen Sun and Kate Saenko. Deep coral: Correlation alignment for deep domain adaptation. In European conference on computer vision, pages 443–450. Springer, 2016.   
+[72] Yongchun Zhu, Fuzhen Zhuang, and Deqing Wang. Aligning domain-specific distribution and classifier for cross-domain classification from multiple sources. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, pages 5989–5996, 2019.   
+[73] Ruijia Xu, Ziliang Chen, Wangmeng Zuo, Junjie Yan, and Liang Lin. Deep cocktail network: Multi-source unsupervised domain adaptation with category shift. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 3964–3973, 2018.   
+[74] Zhenpeng Li, Zhen Zhao, Yuhong Guo, Haifeng Shen, and Jieping Ye. Mutual learning network for multi-source domain adaptation. arXiv preprint arXiv:2003.12944, 2020.   
+[75] Mingsheng Long, Han Zhu, Jianmin Wang, and Michael I Jordan. Unsupervised domain adaptation with residual transfer networks. arXiv preprint arXiv:1602.04433, 2016.   
+[76] Kuniaki Saito, Kohei Watanabe, Yoshitaka Ushiku, and Tatsuya Harada. Maximum classifier discrepancy for unsupervised domain adaptation. CoRR, abs/1712.02560, 2017.   
+[77] Xinlei Chen and Kaiming He. Exploring simple siamese representation learning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 15750–15758, 2021.   
+[78] Tatiana Tommasi, Novi Patricia, Barbara Caputo, and Tinne Tuytelaars. A deeper look at dataset bias. In Domain adaptation in computer vision applications, pages 37–55. Springer, 2017.   
+[79] Boqing Gong, Fei Sha, and Kristen Grauman. Overcoming dataset bias: An unsupervised domain adaptation approach. In NIPS Workshop on Large Scale Visual Recognition and Retrieval, volume 3. Citeseer, 2012.   
+[80] Paul S Bradley, Kristin P Bennett, and Ayhan Demiriz. Constrained K-means clustering. Microsoft Research, Redmond, 20(0):0, 2000.   
+[81] Yuki Markus Asano, Christian Rupprecht, and Andrea Vedaldi. Self-labelling via simultaneous clustering and representation learning. arXiv preprint arXiv:1911.05371, 2019.

parse/train/yH2VrkpiCK6/yH2VrkpiCK6_content_list.json

@@ -0,0 +1,1382 @@
+[
+    {
+        "type": "text",
+        "text": "A Prototype-Oriented Framework for Unsupervised Domain Adaptation ",
+        "text_level": 1,
+        "bbox": [
+            269,
+            122,
+            727,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Korawat Tanwisuth∗,1, Xinjie Fan∗,1, Huangjie Zheng∗,1, Shujian Zhang1, Hao Zhang2, Bo Chen3, Mingyuan Zhou1 ",
+        "bbox": [
+            236,
+            224,
+            759,
+            255
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1The University of Texas at Austin 2 Cornell University 3Xidian University korawat.tanwisuth@utexas.edu, mingyuan.zhou@mccombs.utexas.edu ",
+        "bbox": [
+            233,
+            255,
+            761,
+            284
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            318,
+            535,
+            335
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Existing methods for unsupervised domain adaptation often rely on minimizing some statistical distance between the source and target samples in the latent space. To avoid the sampling variability, class imbalance, and data-privacy concerns that often plague these methods, we instead provide a memory and computationefficient probabilistic framework to extract class prototypes and align the target features with them. We demonstrate the general applicability of our method on a wide range of scenarios, including single-source, multi-source, class-imbalance, and source-private domain adaptation. Requiring no additional model parameters and having a moderate increase in computation over the source model alone, the proposed method achieves competitive performance with state-of-the-art methods. ",
+        "bbox": [
+            233,
+            349,
+            766,
+            487
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            525,
+            310,
+            542
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In many real-world applications, such as healthcare and autonomous driving, data labeling can be expensive and time-consuming. To make predictions on a new unlabeled dataset, one may naively use an existing supervised model trained on a large labeled dataset. However, even subtle changes in the data-collection conditions, such as lighting or background for natural images, can cause a model’s performance to degrade drastically [1]. This shift in the input data distribution is referred to in the literature as covariate shift [2]. By leveraging the labeled samples from the source domain and unlabeled samples from the target domain, unsupervised domain adaptation aims to overcome this issue, making the learned model generalize well in the target domain [3]. ",
+        "bbox": [
+            174,
+            556,
+            825,
+            667
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Ben-David et al. [4, 5] provide an $\\mathcal { H }$ -divergence based theoretical upper bound on the target error. Ganin [6] popularizes learning an invariant representation between the source and target domains to minimize this divergence. Numerous prior methods [7–12] follow this trend, focusing on using the source and target samples for feature alignment in the latent space. While this approach can reduce the discrepancy between domains, directly using the source and target samples for feature alignment has the following problems. First, several commonly used methods that can be used to quantify the difference between two empirical distributions, such as maximum mean discrepancy (MMD) [13] and Wasserstein distance [14, 15], are sensitive to outlier samples in a mini-batch when used to match the source and target marginal distributions [16, 17]. We attribute this problem to the sampling variability of both the source and target samples. Second, while we typically assume that the two domains share the same label space, we cannot guarantee that the samples drawn from the source and target domains will cover the same set of classes in each mini-batch. Especially, if the label proportions shift between domains, learning domain invariant representation might not lead to improvements over using the source data alone to train the model [18]. If we pull the support of the source and target feature representations from different classes closer together, the classifier will be more likely to misclassify those examples. Finally, aligning the target features to source features means that we need access to both the source and target data simultaneously. In applications such as personal healthcare, we may not have access to the source data directly during the adaptation stage; instead, we may only be given access to the target data and the model trained on the source data. ",
+        "bbox": [
+            174,
+            674,
+            825,
+            867
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/4647cf2c7e915131ca261d7cf23bfb4e0603f7cc7d7185c4aff950342658c9f6.jpg",
+        "image_caption": [
+            "Figure 1: This figure exhibits a diagram of Prototype-oriented Conditional Transport (PCT). Unlike existing methods that align the target and source features, our method aligns the target features with class prototypes. The gray arrow indicates that the gradients of the prototypes do not back-propagate through the transport loss. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            215,
+            93,
+            789,
+            296
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            364,
+            825,
+            434
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We propose an algorithm that constructs class prototypes to represent the source domain samples in the latent space. Using the prototypes instead of source features avoids the previously mentioned problems: 1) sampling variability in the source domain, 2) instance class-mismatching in a mini-batch, and 3) source-data privacy concerns. As we expect the classifier to make better predictions on the target data in regions where the source density is sufficiently high [19], it is natural to consider encouraging the feature encoder to map the target data close to these prototypes. Motivated by the cluster assumption [20] (decision boundaries should not cross high-density regions of the data), we provide a method to transport the target features to these class prototypes and vice versa. We further extend our bi-directional transport to address the potential shift in label proportions, a common problem that has been studied [21–25] but that has been often overlooked in prior works [6, 7, 26]. ",
+        "bbox": [
+            174,
+            440,
+            825,
+            579
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Compared to existing methods, the proposed one has several appealing aspects. First, it does not rely on adversarial training to achieve competitive performance, making the algorithm robust and converge much faster. Moreover, learnable prototypes not only avoid expensive computation but also bypass the need to directly access the source data. This attribute makes our algorithm applicable to the settings where preserving the source data privacy is a major concern. Unlike clustering-based approaches that typically require multiple forward passes before an update, our algorithm processes data in mini-batches for each update and is trained in an end-to-end manner. ",
+        "bbox": [
+            174,
+            585,
+            825,
+            683
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We highlight the main contributions of the paper as follows: 1) We utilize the linear classifier’s weights as class prototypes and propose a general probabilistic framework to align the target features to these prototypes. 2) We introduce the minimization of the expected cost of a probabilistic bi-directional transport for feature alignment, and illustrate its superior performance over related methods. 3) We test the proposed method under multiple challenging yet practical settings: single-source, multisource, class-imbalance, and source-private domain adaptation. In comparison to state-of-the-art algorithms, the proposed prototype-oriented method achieves highly competitive performance in domain adaptation, while requiring no additional model parameters and only having a moderate increase in computation over the source model alone. ",
+        "bbox": [
+            174,
+            688,
+            825,
+            813
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Prototype-oriented conditional transport ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            835,
+            545,
+            853
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this section, we propose Prototype-oriented Conditional Transport (PCT), a holistic method for domain adaption consisting of three parts: learning class prototypes, aligning the target features with learned prototypes using a probabilistic bi-directional transport framework of Zheng and Zhou [27], and estimating the target class proportions. Our method does not introduce additional model parameters for aligning domain features, and the model can be learned in an end-to-end manner. We provide a motivating example of the application of our method on a synthetic dataset in Figure 2. ",
+        "bbox": [
+            174,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/6f38e79e69bb61e4ba8f17b9e1406d3acc0bc26431cde4539bcf4a18b6ecdcf3.jpg",
+        "image_caption": [
+            "Figure 2: Visualization of different methods on a synthetic dataset, where darker points marked with “·” and lighter points marked with “ $\\times \\overrightarrow { \\mathbf { \\Omega } }$ ” denote the source and target samples, respectively, and the red and green colors denote two different classes. For each method, the left plot shows the data space whereas the right plot exhibits the output of the feature encoder in the latent space. Letters A and B correspond to the two class prototypes in the latent space. When there is clear class imbalance, DANN, a representative algorithm whose strategy is to match the marginal feature distributions between the source and target, fails to adapt to the target domain. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            87,
+            823,
+            162
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            266,
+            823,
+            309
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "and an unlabeled dataset from the target domain, In domain adaptation, we are given a labeled dataset from the source domain, $\\{ \\pmb { x } _ { j } ^ { t } \\} _ { j = 1 } ^ { n _ { t } } \\sim \\mathcal { D } _ { t } ^ { \\pmb { x } }$ i i i=1 . We focus on the closed-category $\\{ ( \\pmb { x } _ { i } ^ { s } , \\pmb { y } _ { i } ^ { s } ) \\} _ { i = 1 } ^ { n _ { s } } \\sim \\mathcal { D } _ { s }$ , domain adaptation and assume that the source and target domains share the same label space, i.e., $y _ { i } ^ { s } , y _ { j } ^ { t } \\in \\{ 1 , 2 , . . . , K \\}$ , where $K$ denotes the number of classes. The goal of domain adaptation is to learn a model with low risk on the target samples. The model typically consists of a feature encoder, $F _ { \\pmb \\theta } : \\mathcal { X }  \\mathbb { R } ^ { d _ { f } }$ , parameterized by $\\pmb { \\theta }$ , and a linear classification layer $\\dot { C _ { \\mu } } : \\mathbb { R } ^ { d _ { f } } \\to \\mathbb { R } ^ { K }$ , parameterized by $\\pmb { \\mu }$ . In prior works [6, 7, 26], the feature encoder is a pre-trained neural network, and the classifier is a randomly initialized linear layer. To simplify the following notation, we denote $\\pmb { f } _ { i } ^ { s } = F _ { \\pmb { \\theta } } ( \\pmb { x } _ { i } ^ { s } )$ and $f _ { j } ^ { t } = F _ { \\theta } ( \\pmb { x } _ { j } ^ { t } )$ as the feature representations of the source data $\\mathbf { \\boldsymbol { x } } _ { i } ^ { s }$ and target data $\\boldsymbol { x } _ { j } ^ { t }$ , respectively. ",
+        "bbox": [
+            173,
+            314,
+            826,
+            443
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 Learning class prototypes ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            459,
+            392,
+            474
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Most existing works [6, 7, 26] focus on aligning the source and target features in a latent space. By contrast, we propose to characterize the features of each class with a class prototype and align the target features with these class prototypes instead of the source features. This approach has several advantages. First, the feature alignment between two domains would be more robust to outliers in the source domain as we avoid using the source samples directly. Second, we do not need to worry about the missing classes in the sampled mini-batch in the source domain like we do when we align the features of source and target samples. Prototypes ensure that every class is represented for each training update. Last but not least, using the inferred prototypes instead of source features allows adapting to the target domain even without accessing the source data during the adaptation stage, which is an appealing trait when preserving the source data privacy is a concern (see Table 6). ",
+        "bbox": [
+            173,
+            484,
+            825,
+            625
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Previous methods [28–31, 12, 32] construct each class prototype as the average latent feature for that class extracted by the feature encoder, which is computationally expensive due to the forward passing of a large number of training samples. We propose to construct class prototypes in the same latent space but with learnable parameters: $[ \\pmb { \\mu } _ { 1 } , \\pmb { \\dot { \\mu } } _ { 2 } , \\dots , \\pmb { \\mu } _ { K } ] \\in \\mathbb { R } ^ { d _ { f } \\times K }$ , where the dimension of each prototype, $d _ { f }$ , is the same as the hidden dimension after the feature encoder $F _ { \\theta }$ . This strategy has been successfully applied by Saito et al. [33] in a semi-supervised learning setting. We learn each class prototype in a way that encourages the prototype to be close to the source samples associated with that class in the feature space. In particular, given the prototypes and source samples $\\mathbf { \\boldsymbol { x } } _ { i } ^ { s }$ with features $\\pmb { f } _ { i } ^ { s }$ and labels $y _ { i } ^ { s }$ , we use the cross-entropy loss to learn the prototypes: ",
+        "bbox": [
+            173,
+            630,
+            825,
+            756
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b88a264353a411e1e4008d1981b328ea45409eca64d5283a81041f499f2576eb.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathcal { L } _ { \\mathrm { c l s } } = \\mathbb { E } _ { ( \\pmb { x } _ { i } ^ { s } , \\pmb { y } _ { i } ^ { s } ) \\sim \\mathcal { D } _ { s } } \\left[ \\sum _ { k = 1 } ^ { K } - \\log p _ { i k } ^ { s } \\mathbf { 1 } _ { \\{ \\pmb { y } _ { i } ^ { s } = k \\} } \\right] , \\quad p _ { i k } ^ { s } : = \\frac { \\exp ( \\mu _ { k } ^ { T } f _ { i } ^ { s } + b _ { k } ) } { \\sum _ { k ^ { \\prime } = 1 } ^ { K } \\exp ( \\mu _ { k ^ { \\prime } } ^ { T } f _ { i } ^ { s } + b _ { k ^ { \\prime } } ) } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            235,
+            763,
+            763,
+            792
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $b _ { k }$ is a bias term and $p _ { i k } ^ { s }$ is the predictive probability for $\\mathbf { \\boldsymbol { x } } _ { i } ^ { s }$ to be classified to class $k$ . We note that this way of learning the class prototypes is closely connected to learning the standard linear classification layer $C _ { \\mu }$ on source-only data with the cross-entropy loss. The neural network weights in the classification layer can be interpreted as the class prototypes. Therefore, compared with sourceonly approaches, constructing prototypes in this way introduce no additional parameters. As we show in Figure $4 \\mathrm { a }$ , our method requires much fewer parameters than other domain-adaptation methods. Moreover, it requires much less computation than other prototype-based methods by avoiding the need to average the latent features for each class. ",
+        "bbox": [
+            173,
+            799,
+            826,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 Bi-directional prototype-oriented conditional transport ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            90,
+            596,
+            106
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this section, we will discuss how we encourage the feature encoder to align the target data with class prototypes. Our approach is motivated by the cluster assumption, which has been widely adopted in both semi-supervised learning [20, 34, 35] and domain-adaptation literature [36, 37, 31, 38]. The cluster assumption states that the input data distribution consists of separated clusters and that instances belonging to the same cluster tend to have the same class labels. This means that the decision boundaries should not cross data high-density regions. To achieve this goal, we minimize the expected pairwise cost between the target features and prototypes with respect to two differently constructed joint distributions. By minimizing the expected costs under these two different joint distributions, the target feature will be close to the prototypes, far from the decision boundaries. ",
+        "bbox": [
+            173,
+            116,
+            826,
+            242
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.2.1 Moving from target domain to class prototypes ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            255,
+            552,
+            270
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To define the expected cost of moving from the target domain to the class prototypes, we first use the chain rule to factorize the joint distribution of the class prototype $\\pmb { \\mu } _ { k }$ and target feature $\\boldsymbol { f } _ { j } ^ { t }$ as $p ( f _ { j } ^ { t } ) \\pi _ { \\pmb { \\theta } } ( \\mu _ { k } \\vert f _ { j } ^ { t } )$ , where drawing from the target feature distribution $p ( f _ { j } ^ { t } )$ can be realized by selecting a random target sample $\\mathbf { \\boldsymbol { x } } _ { j } ^ { t } \\sim \\mathcal { D } _ { t } ^ { x }$ to obtain $f _ { j } ^ { t } = F _ { \\theta } ( \\pmb { x } _ { j } ^ { t } )$ . The conditional distribution, representing the probability of moving from target feature $f _ { j } ^ { t }$ to class prototype $\\pmb { \\mu } _ { k }$ , is defined as ",
+        "bbox": [
+            173,
+            277,
+            825,
+            359
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9ec38484de64cab4dd9ef53096e3f7134f939ae4df15b6b89f51ecb4f4398aaa.jpg",
+        "text": "$$\n\\begin{array} { r } { \\pi _ { \\pmb { \\theta } } ( \\pmb { \\mu } _ { k } \\mid \\pmb { f } _ { j } ^ { t } ) = \\frac { p ( \\pmb { \\mu } _ { k } ) \\exp ( \\pmb { \\mu } _ { k } ^ { T } \\pmb { f } _ { j } ^ { t } ) } { \\sum _ { k ^ { \\prime } = 1 } ^ { K } p ( \\pmb { \\mu } _ { k ^ { \\prime } } ) \\exp ( \\pmb { \\mu } _ { k ^ { \\prime } } ^ { T } \\pmb { f } _ { j } ^ { t } ) } , k \\in \\{ 1 , \\ldots , K \\} , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            310,
+            364,
+            687,
+            393
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where, through the lens of Bayes’ rule, $p ( \\pmb { \\mu } _ { k } )$ is the discrete prior distribution over the $K$ classes for the target domain, and $\\exp ( \\mu _ { k } ^ { T } f _ { j } ^ { t } )$ plays the role of an unnormalized likelihood term, measuring the similarity between class prototypes and target features. Intuitively, the target features are more likely to be moved to the prototypes which correspond to dominant classes in the target domain or which are closer to the target features (or both). Note that in practice we often do not have access to the target class distribution $p ( \\pmb { \\mu } _ { k } )$ . We can use a uniform prior distribution for $p ( \\boldsymbol { \\mu _ { k } } )$ . However, this could be sub-optimal, especially when classes are seriously imbalanced in the target domain. To address this issue, we propose a way to estimate $\\{ p ( \\mu _ { k } ) \\} _ { k = 1 } ^ { K }$ in Section 2.3. ",
+        "bbox": [
+            173,
+            396,
+            826,
+            511
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We now define the expected cost of moving the target features to class prototypes as: ",
+        "bbox": [
+            178,
+            515,
+            728,
+            531
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/35bcd5ad47f93d6fa9a502b6a72c232a6ea42ad5226d115f2f06ddcc10b1046b.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathcal { L } _ { t  \\mu } = \\mathbb { E } _ { \\boldsymbol { x } _ { j } ^ { t } \\sim \\mathcal { D } _ { t } ^ { \\mathrm { o r } } } \\mathbb { E } _ { \\mu _ { k } \\sim \\pi \\boldsymbol { \\theta } ( \\mu _ { k } \\mid f _ { j } ^ { t } ) } [ c ( \\mu _ { k } , f _ { j } ^ { t } ) ] = \\mathbb { E } _ { \\boldsymbol { x } _ { j } ^ { t } \\sim \\mathcal { D } _ { t } ^ { \\mathrm { o r } } } [ \\sum _ { k = 1 } ^ { K } c ( \\mu _ { k } , f _ { j } ^ { t } ) \\frac { p ( \\mu _ { k } ) \\exp ( \\mu _ { k } ^ { T } f _ { j } ^ { t } ) } { \\sum _ { k ^ { \\prime } = 1 } ^ { K } p ( \\mu _ { k ^ { \\prime } } ) \\exp ( \\mu _ { k ^ { \\prime } } ^ { T } f _ { j } ^ { t } ) } ] , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            192,
+            534,
+            784,
+            565
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $c ( \\cdot , \\cdot )$ , a point-to-point moving cost, is defined with the cosine dissimilarity as ",
+        "bbox": [
+            176,
+            568,
+            728,
+            583
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4bb0deca7b04e9ef221cadcd1f525c8f74c1e3786a8ea12264cd4ec6210a3cba.jpg",
+        "text": "$$\n\\begin{array} { r } { c ( { \\pmb { \\mu } } _ { k } , { \\pmb f } _ { j } ^ { t } ) = 1 - \\frac { { \\pmb { \\mu } } _ { k } ^ { T } { \\pmb f } _ { j } ^ { t } } { | | { \\pmb { \\mu } } _ { k } | | _ { 2 } | | { \\pmb f } _ { j } ^ { t } | | _ { 2 } } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            398,
+            587,
+            599,
+            616
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We also consider other point-to-point costs and present the results in Section 4.2. With Eq. (3), it is straightforward to obtain an unbiased estimation of $\\mathcal { L } _ { t  \\mu }$ with a mini-batch from target domain $\\mathcal { D } _ { t } ^ { x }$ . ",
+        "bbox": [
+            176,
+            618,
+            825,
+            647
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this target-to-prototype direction, we are assigning each target sample to the prototypes according to their similarities and the class distribution. Intuitively, minimizing this expected moving cost encourages each target feature to get closer to neighboring class prototypes, reducing the violation of the cluster assumption. If we think of each prototype as the mode of the distribution of source features for a class, this loss encourages a mode-seeking behavior [27]. Still, this loss alone might lead to sub-optimal alignment. The feature encoder can map most of the target data to only a few prototypes. We connect this loss to entropy minimization to elucidate this point. ",
+        "bbox": [
+            173,
+            652,
+            825,
+            751
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Connection with entropy minimization. The expected cost of moving from the target domain to prototypes can be viewed as a generalization of entropy minimization [20], an effective regularization in many prior domain-adaptation works [39, 33, 40, 17]. If the point-to-point moving cost is defined as $\\begin{array} { r } { c ( \\pmb { \\mu } _ { k } , \\pmb { f } _ { j } ^ { t } ) = - \\log p _ { j k } ^ { t } = - \\log \\frac { \\exp ( \\pmb { \\mu } _ { k } ^ { T } \\pmb { f } _ { j } ^ { t } ) } { \\sum _ { k ^ { \\prime } = 1 } ^ { K } \\exp ( \\pmb { \\mu } _ { k ^ { \\prime } } ^ { T } \\pmb { f } _ { j } ^ { t } ) } } \\end{array}$ and the conditional probability is $\\begin{array} { r } { \\pi _ { \\boldsymbol { \\theta } } ( \\mu _ { k } \\vert f _ { j } ^ { t } ) = p _ { j k } ^ { t } = \\frac { \\exp ( \\mu _ { k } ^ { T } f _ { j } ^ { t } ) } { \\sum _ { k ^ { \\prime } = 1 } ^ { K } \\exp ( \\mu _ { k ^ { \\prime } } ^ { T } f _ { j } ^ { t } ) } } \\end{array}$ (with a uniform prior), then the expected moving cost becomes: $\\begin{array} { r } { \\mathcal { L } _ { t  \\mu } = - \\mathbb { E } _ { \\pmb { x } _ { j } ^ { t } \\sim \\mathcal { D } _ { t } ^ { \\pmb { x } } } \\big [ \\sum _ { k = 1 } ^ { K } p _ { j k } ^ { t } \\log p _ { j k } ^ { t } \\big ] } \\end{array}$ , which is equivalent to minimizing the entropy on the target samples. Entropy minimization alone also has a mode-seeking behavior and has the same tendency to drop some modes (class prototypes). In other words, one trivial solution is to assign the same one-hot encoding to all the target samples [41, 42]. ",
+        "bbox": [
+            173,
+            756,
+            825,
+            912
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.2.2 Moving from class prototypes to target domain ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            92,
+            550,
+            106
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To ensure that each prototype has some target features located close by and avoid dropping class prototypes, we propose to add a cost of tto target features. Given a mini-batch, $\\{ \\pmb { x } _ { j } ^ { t } \\} _ { j = 1 } ^ { M }$ ite direction [27], i.e., mov, of target samples of size $M$ from the p, denoting $\\hat { p } ( f ^ { \\varepsilon } ) ^ { \\ast } =$ PMj=1 1M δftj as the empirical distribution of the target features in this mini-batch, the probabilities of moving from a prototype $\\pmb { \\mu } _ { k }$ to the $M$ target features is defined as a conditional distribution: ",
+        "bbox": [
+            173,
+            114,
+            826,
+            193
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f2040e7994c3e42f836295e5cad8fdc22222a183bce7855f228630db369c75c3.jpg",
+        "text": "$$\n\\begin{array} { r } { \\pi _ { \\theta } ( f _ { j } ^ { t } \\mid \\mu _ { k } ) = \\frac { \\hat { p } ( f _ { j } ^ { t } ) \\exp ( \\mu _ { k } ^ { T } f _ { j } ^ { t } ) } { \\sum _ { j ^ { \\prime } = 1 } ^ { M } \\hat { p } ( f _ { j ^ { \\prime } } ^ { t } ) \\exp ( \\mu _ { k } ^ { T } f _ { j ^ { \\prime } } ^ { t } ) } = \\frac { \\exp ( \\mu _ { k } ^ { T } f _ { j } ^ { t } ) } { \\sum _ { j ^ { \\prime } = 1 } ^ { M } \\exp ( \\mu _ { k } ^ { T } f _ { j ^ { \\prime } } ^ { t } ) } , \\quad f _ { j } ^ { t } \\in \\{ f _ { 1 } ^ { t } , \\ldots , f _ { M } ^ { t } \\} . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            225,
+            199,
+            771,
+            229
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "As opposed to the probabilities of moving a target feature to different class prototypes $\\pi _ { \\boldsymbol { \\theta } } ( \\mu _ { k } \\vert \\boldsymbol { f } _ { j } ^ { t } )$ $\\pi _ { \\pmb { \\theta } } ( f _ { j } ^ { t } | \\mu _ { k } )$ normalizes the probabilities across the $M$ target samples for each prototype, which ensures that each prototype will be assigned to some target features. Then, the expected cost of moving along this prototype-to-target direction is defined as: ",
+        "bbox": [
+            174,
+            236,
+            823,
+            296
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e05fbb5994388af7cb34224f5546e1236d485536e840b63a2153d764a20c4cba.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathcal { L } _ { \\mu \\to t } = \\mathbb { E } _ { \\{ \\mathbf { x } _ { j } ^ { t } \\} _ { j = 1 } ^ { M } \\sim \\mathcal { D } _ { t } ^ { \\infty } } \\mathbb { E } _ { \\mu _ { k } \\sim p ( \\mu _ { k } ) } \\mathbb { E } _ { f _ { j } ^ { t } \\sim \\pi _ { \\theta } ( f _ { j } ^ { t } \\mid \\mu _ { k } ) } \\left[ c ( \\mu _ { k } , f _ { j } ^ { t } ) \\right] } \\\\ & { \\qquad = \\mathbb { E } _ { \\{ \\mathbf { x } _ { j } ^ { t } \\} _ { j = 1 } ^ { M } \\sim \\mathcal { D } _ { t } ^ { \\infty } } \\left[ \\sum _ { k = 1 } ^ { K } p ( \\mu _ { k } ) \\sum _ { j = 1 } ^ { M } c ( \\mu _ { k } , f _ { j } ^ { t } ) \\frac { \\exp ( \\mu _ { k } ^ { T } f _ { j } ^ { t } ) } { \\sum _ { j ^ { \\prime } = 1 } ^ { M } \\exp ( \\mu _ { k } ^ { T } f _ { j ^ { \\prime } } ^ { t } ) } \\right] , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            254,
+            301,
+            741,
+            359
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "which can be estimated by drawing a mini-batch of $M$ target samples. ",
+        "bbox": [
+            173,
+            364,
+            632,
+            380
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Finally, combining the classification loss in Eq. (1), target-to-prototype moving cost in Eq. (3), and prototype-to-target moving cost in Eq. (6), our loss is expressed as ",
+        "bbox": [
+            176,
+            385,
+            825,
+            414
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a6d3783327e02db65213bf87a68dc2d9f2cd55fd9edfc30b172d84496ca2fa6e.jpg",
+        "text": "$$\n{ \\mathcal { L } } _ { \\mathrm { c l s } } + { \\mathcal { L } } _ { t  \\mu } + { \\mathcal { L } } _ { \\mu  t } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            423,
+            420,
+            573,
+            438
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Note that we treat $\\pmb { \\mu }$ as fixed in both $\\mathcal { L } _ { t  \\mu }$ and $\\mathcal { L } _ { \\mu \\to t }$ . This strategy allows us to apply our method in the source-data-private setting where we only have access to the source model. We also find empirically that this leads to more stable training. ",
+        "bbox": [
+            174,
+            443,
+            825,
+            486
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2.3 Learning class proportions in the target domain ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            501,
+            545,
+            517
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We propose to infer the class proportions $\\{ p ( \\mu _ { k } ) \\} _ { k = 1 } ^ { K }$ in the target domain by maximizing the loglikelihood of the unlabeled target data while fixing the class prototypes $\\pmb { \\mu }$ . Directly optimizing the marginal likelihood is intractable, so we use the EM algorithm [43–45] to derive the following iterative updates (see the derivation in Appendix B). We first initialize with a uniform prior: $\\begin{array} { r } { p ( \\mu _ { k } ) ^ { 0 } = \\frac { 1 } { K } } \\end{array}$ , and obtain new estimates at each update step (starting from 0): ",
+        "bbox": [
+            173,
+            525,
+            826,
+            597
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b9f38b367cb97bda08f3861deeb3e30b71b98c821ab3dcdd75f4acdb26ddb9c7.jpg",
+        "text": "$$\n\\begin{array} { r } { p ( \\pmb { \\mu } _ { k } ) ^ { l + 1 } = \\frac { 1 } { M } \\sum _ { j = 1 } ^ { M } \\pi _ { \\pmb { \\theta } } ^ { l } ( \\pmb { \\mu } _ { k } \\mid \\pmb { f } _ { j } ^ { t } ) , \\mathrm { w h e r e } \\pi _ { \\pmb { \\theta } } ^ { l } ( \\pmb { \\mu } _ { k } \\mid \\pmb { f } _ { j } ^ { t } ) = \\frac { p ( \\pmb { \\mu } _ { k } ) ^ { l } \\exp ( \\pmb { \\mu } _ { k } ^ { T } \\pmb { f } _ { j } ^ { t } ) } { \\sum _ { k ^ { \\prime } = 1 } ^ { K } p ( \\pmb { \\mu } _ { k ^ { \\prime } } ) ^ { l } \\exp ( \\pmb { \\mu } _ { k ^ { \\prime } } ^ { T } \\pmb { f } _ { j } ^ { t } ) } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            220,
+            602,
+            776,
+            632
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Intuitively, the average predicted probabilities over the target examples for each class are used to estimate the target proportions, with $p ( \\pmb { \\mu } _ { k } ) ^ { l + 1 }$ shown above providing an estimate based on a single mini-batch of $M$ target samples. To estimate it based on the full dataset, we iteratively update it with $p ( \\pmb { \\mu } _ { k } ) ^ { l + 1 }  ( 1 - \\beta ^ { \\overline { { l } } } ) p ( \\pmb { \\mu } _ { k } ) ^ { \\overline { { l } } } + \\beta ^ { l } p ( \\pmb { \\mu } _ { k } ) ^ { l + 1 }$ , where we follow the decaying schedule of the learning rate of the other parameters to set $\\beta ^ { l } = \\beta _ { 0 } ( 1 + \\gamma l ) ^ { - \\alpha }$ , in which $\\gamma = 0 . 0 0 0 2$ , $\\alpha = 0 . 7 5$ . The inintial value $\\beta _ { 0 }$ is a hyper-parameter that can be set as either 0 to indicate a uniform prior, or a small value, such as 0.001, to allow the class proportions to be inferred from the data. ",
+        "bbox": [
+            173,
+            637,
+            825,
+            737
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3 Related work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            756,
+            316,
+            772
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Feature distribution alignment. Most works on domain adaptation with deep learning focus on feature alignment to align either the marginal distributions [46, 6, 8, 47, 48] or the joint distributions [7, 26] of the deep features of neural networks. Early works use adversarial-based objectives, which are equivalent to minimizing the Jensen–Shannon (JS) divergence [49]. When the source and target domains have non-overlapping supports, the JS divergence fails to supply useful gradients [50, 51]. To remedy this issue, researchers propose using the Wasserstein distance, which arises from the optimal transport problem [52]. Courty et al. [9] develop Joint Distribution Optimal Transport (JDOT), defining the transport cost to be the joint cost in the data and prediction spaces. Several works [10, 12] extend this framework for deep neural networks. However, solving for the optimal couplings without any relaxation is a linear programming problem, which has a complexity of $\\mathcal { O } ( M ^ { 3 } \\log M )$ [53]. Computing the transport probabilities in our algorithm has a complexity of $\\mathcal { O } ( d _ { f } M K )$ , which is the same complexity as computing the predictive probabilities that need to be computed by most algorithms. In this category, all the works focus on aligning the target features with source features, whereas we align the target features with prototypes. ",
+        "bbox": [
+            173,
+            786,
+            825,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            92,
+            825,
+            161
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Prototype-based alignment. We make two distinctions to existing works in this area. First, prior domain-adaptation works for classification [29–31] and segmentation [54, 55] utilize prototypes for pseudo-label assignments. By contrast, we use prototypes to behave as representative samples of the source features to define the loss. Second, all of these works use some form of average latent features to construct class prototypes, which is computationally expensive. We instead adopt a parametric approach to learn the prototypes, avoiding that costly computation. ",
+        "bbox": [
+            174,
+            166,
+            825,
+            251
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Learning under shifted class proportions. Although a shift in class proportions between two domains is a common problem in many applications, it is still largely under-explored. Over the years, researchers have viewed the question through different lenses: applying kernel distribution embedding [56, 57, 21], using an EM update [43, 58], placing a meta-prior over the target proportions [59], and casting the problem under causal and anti-causal learning [21–25]. Recently, Tachet des Combes et al. [18] propose aligning the target feature distribution with a re-weighted version of the source feature distribution. While this method achieves consistent improvements over feature-alignment algorithms, it still relies on learning domain-invariant representations. As we have discussed, this approach suffers from the problems of sampling variability and class-mismatching in a mini-batch, whereas the proposed method uses class prototypes and proportion estimation to avoid these issues. ",
+        "bbox": [
+            173,
+            256,
+            825,
+            395
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Source-private adaptation. Finally, the proposed method can also be applied to a source-private setting where without seeing the raw source data, we only have access to the source model and target data while adapting to the target domain [31, 47, 60–63]. Liang et al. [31] introduce a clustering-based approach to generate pseudo-labels for the target data. That approach requires constructing class centers using a weighted average of the latent features. Different from that work, our prototypes behave as class centers and are more amenable to mini-batch stochastic gradient based training. ",
+        "bbox": [
+            174,
+            401,
+            825,
+            484
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            506,
+            312,
+            523
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we evaluate our method under four practical settings: single-source, multi-source, class-imbalance, and source-private domain adaptation. We present the setup, the results, and the analysis of the results in the upcoming sections. ",
+        "bbox": [
+            174,
+            539,
+            825,
+            580
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Datasets. We use the following three datasets of varying sizes in our experiment: 1) Office-31 [3] consists of 4652 images coming from three domains: Amazon (A), Webcam (W), and DSLR (D). The total number of categories is 31. 2) Office-Home [64], a more challenging dataset than Office-31, consists of 15,500 images over 65 classes and four domains: Artistic images (Ar), Clip art (Cl), Product images $( \\mathrm { P r } )$ , and Real-world (Rw). 3) DomainNet [65] is a large-scale dataset for domain adaptation. It consists of about 569,010 images with 345 categories from six domains: Clipart, Infograph, Painting, Quickdraw, Real, and Sketch. We further perform experiments on Cross-Digits, ImageClef, Office-Caltech, and VisDA datasets and provide the details in Appendix E.2. ",
+        "bbox": [
+            174,
+            587,
+            825,
+            698
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Implementation details. We implement our method on top of the open-source transfer learning library (MIT license) [66], adopting the default neural network architectures for both the feature encoder and linear classifier. For the feature encoder network, we utilize a pre-trained ResNet-50 in all experiments except for multi-source domain adaptation, where we use a pre-trained ResNet-101. We fine-tune the feature encoder and train the linear layers from random initialization. The linear layers have the learning rate of 0.01, 10 times that of the feature encoder. The learning rate follows the following schedule as $\\eta _ { \\mathrm { i t e r } } = \\eta _ { 0 } ( 1 + \\gamma \\mathrm { i t e r } ) ^ { - \\alpha }$ , where $\\eta _ { 0 }$ is the initial learning rate. We set $\\eta _ { 0 }$ to 0.01, $\\gamma$ to 0.0002, and $\\alpha$ to 0.75. We utilize a mini-batch SGD with a momentum of 0.9. We set the batch size for the source data as $N = 3 2$ and that for the target data as $M = 9 6$ . We use all the labeled source samples and unlabeled target samples [6, 7, 26]. We set $\\beta _ { 0 }$ to 0 (a uniform prior) in all settings except for the sub-sampled target datasets. We perform a sensitivity analysis (see Appendix E) and set $\\beta _ { 0 }$ empirically to 0.001 for the sub-sampled target version of Office-31 and 0.0001 for that of Office-Home. We report the average accuracy from three independent runs. All experiments are conducted using a single Nvidia Tesla V100 GPU except for the DomainNet experiment, where we use four V100 GPUs. More implementation details can be found in Appendix D. ",
+        "bbox": [
+            173,
+            704,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 Main results ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            90,
+            300,
+            106
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Single-source setting. We perform single-source domain adaptation on the Office-31 and OfficeHome datasets. In each experiment, one domain serves as the source domain and another as the target domain. We consider all permutations, leading to 6 tasks for the Office-31 dataset and 12 tasks for the Office-Home dataset. We compare our algorithm with state-of-the-art algorithms for domain adaptations from three different categories: adversarial-based, divergence-based, and optimal transport-based. We report the results on Office-31 in Table 1. PCT significantly outperforms the baselines, especially on the more difficult transfer tasks $\\mathrm { ( D { \\to } A }$ and $\\mathbf { W } \\to \\mathbf { A }$ ). Although MDD [67], the best baseline domain-adaptation method, uses a bigger classifier, PCT still has $1 . 1 \\%$ higher average accuracy. In Figure 4a, we visualize the number of parameters versus the average accuracy on the Office-31 dataset. While PCT uses fewer parameters than most methods, it still achieves the highest average accuracy. We report the average accuracies on the Office-Home dataset in Table 2. PCT outperforms baseline methods on 10 of the 12 transfer tasks, yielding $3 . 7 \\%$ improvement on the average accuracy over MDD. The results in this setting demonstrate that aligning the target features with prototypes is more effective than directly aligning them with the source features. ",
+        "bbox": [
+            173,
+            116,
+            826,
+            310
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/4fc7e2e1df4d1eab9c2ac1039d5b0d834af6183d3068e9ca060c08264018a457.jpg",
+        "table_caption": [
+            "Table 1: Accuracy $( \\% )$ on Office-31 for unsupervised domain adaptation (ResNet-50). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Category</td><td>Method</td><td>A→W</td><td>D→W</td><td>W→D</td><td>A→D</td><td>D→A</td><td>W→A</td><td>Avg</td></tr><tr><td></td><td>ResNet-50 [68]</td><td>68.4±0.2</td><td>96.7±0.1</td><td>99.3±0.1</td><td>68.9±0.2</td><td>62.5± 0.3</td><td>60.7±0.3</td><td>76.1</td></tr><tr><td rowspan=\"4\">Adversarial</td><td>DANN [6]</td><td>82.0±0.4</td><td>96.9±0.2</td><td>99.1±0.1</td><td>79.7±0.4</td><td>68.2±0.4</td><td>67.4±0.5</td><td>82.2</td></tr><tr><td>ADDA [47]</td><td>86.2±0.5</td><td>96.2±0.3</td><td>98.4±0.3</td><td>77.8± 0.3</td><td>69.5 ± 0.4</td><td>68.9±0.5</td><td>82.9</td></tr><tr><td>CDAN [26]</td><td>94.1± 0.1</td><td>98.6±0.1</td><td>100.0±0.0</td><td>92.9±0.2</td><td>71.0±0.3</td><td>69.3±0.3</td><td>87.7</td></tr><tr><td>MDD[67]</td><td>94.5 ±0.3</td><td>98.4±0.1</td><td>100.0±0.0</td><td>93.5±0.2</td><td>74.6±0.3</td><td>72.2±0.1</td><td>88.9</td></tr><tr><td rowspan=\"2\">Divergence</td><td>JAN [7]</td><td>85.4± 0.3</td><td>97.4±0.2</td><td>99.8±0.2</td><td>84.7±0.3</td><td>68.6±0.3</td><td>70.0±0.4</td><td>84.3</td></tr><tr><td>TPN [29]</td><td>91.2 ±0.3</td><td>97.7±0.2</td><td>99.5 ±0.1</td><td>89.9±0.2</td><td>70.5±0.2</td><td>73.5± 0.1</td><td>87.1</td></tr><tr><td rowspan=\"2\">OT</td><td>DeepJDOT[10]</td><td>88.9±0.3</td><td>98.5 ±0.1</td><td>99.6±0.2</td><td>88.2±0.1</td><td>72.1±0.4</td><td>70.1± 0.4</td><td>86.2</td></tr><tr><td>ETD [69]</td><td>92.1</td><td>100.0</td><td>100.0</td><td>88.0</td><td>71.0</td><td>67.8</td><td>86.2</td></tr><tr><td></td><td>PCT (Ours)</td><td>94.6± 0.5</td><td>98.7±0.4</td><td>99.9±0.1</td><td>93.8±1.8</td><td>77.2 ± 0.5</td><td>76.0±0.9</td><td>90.0</td></tr></table>",
+        "bbox": [
+            173,
+            332,
+            825,
+            482
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/98e75aedf827be1fcd0c4cc7b124b933652ffe63315ec61672b2de4311313b3e.jpg",
+        "table_caption": [
+            "Table 2: Accuracy $( \\% )$ on Office-Home for unsupervised domain adaptation (ResNet-50). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td colspan=\"10\">Ar→Cl Ar→Pr Ar→RwCl→Ar Cl→Pr Cl→Rw Pr→Ar Pr→ClPr→Rw Rw→ArRw→ClRw→Pr Avg</td></tr><tr><td>ResNet-50 [68]</td><td>34.9</td><td>50.0 58.0</td><td>37.4</td><td>41.9</td><td>46.2</td><td>38.5</td><td>31.2</td><td></td><td>60.4</td><td>53.9</td><td>41.2</td><td>59.9 46.1</td></tr><tr><td>DANN [6]</td><td>45.6</td><td>59.3 70.1</td><td>47.0</td><td>58.5</td><td>60.9</td><td>46.1</td><td>43.7</td><td>68.5</td><td>63.2</td><td>51.8</td><td>76.8</td><td>57.6</td></tr><tr><td>CDAN [26]</td><td>50.7</td><td>70.6 76.0</td><td>57.6</td><td>70.0</td><td>70.0</td><td>57.4</td><td>50.9</td><td>77.3</td><td>70.9</td><td>56.7</td><td>81.6</td><td>65.8</td></tr><tr><td>MDD[67]</td><td>54.9</td><td>73.7 77.8</td><td>60.0</td><td>71.4</td><td>71.8</td><td>61.2</td><td>53.6</td><td>78.1</td><td>72.5</td><td>60.2</td><td>82.3</td><td>68.1</td></tr><tr><td>JAN[7]</td><td>45.9 61.2</td><td>68.9</td><td>50.4</td><td>59.7</td><td>61.0</td><td>45.8</td><td>43.4</td><td>70.3</td><td>63.9</td><td>52.4</td><td>76.8</td><td>58.3</td></tr><tr><td>TPN [29]</td><td>51.2 71.2</td><td>76.0</td><td>65.1</td><td>72.9</td><td>72.8</td><td>55.4</td><td>48.9</td><td>76.5</td><td>70.9</td><td>53.4</td><td>80.4</td><td>66.2</td></tr><tr><td>DeepJDOT[10]</td><td>48.2</td><td>69.2 74.5</td><td>58.5</td><td>69.1</td><td>71.1</td><td>56.3</td><td>46.0</td><td>76.5</td><td>68.0</td><td>52.7</td><td>80.9</td><td>64.3</td></tr><tr><td>ETD [69]</td><td>51.3</td><td>71.9 85.7</td><td>57.6</td><td>69.2</td><td>73.7</td><td>57.8</td><td>51.2</td><td>79.3</td><td>70.2</td><td>57.5</td><td>82.1</td><td>67.3</td></tr><tr><td>PCT(Ours)</td><td>57.1±0.378.3±.281.4±0.467.6±0.377.0±.2765±0.568.±.5550±0.61.3±.274.7±0.560.0±.55.71.</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr></table>",
+        "bbox": [
+            174,
+            510,
+            825,
+            614
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Multi-source setting. In this setting, we evaluate our method using Office-Home and DomainNet datasets [65]. For each task, we select one domain as the target domain and use the remaining five domains as the source. We use the same data splitting scheme as the original paper [65]. We compare against source-combined and multi-source algorithms introduced in Venkat et al. [70] for Office-Home and in Peng et al. [65] for DomainNet. Multi-source algorithms use domain labels and a classifier for each source domain, whereas source-combined algorithms combine all the source domains into a single source domain and perform single-source adaptation. We adopt a single classifier and do not use domain labels. Thus, PCT falls under the source-combined category. We report the results in Tables 3 and 4. While PCT is not designed specifically for multi-source domain adaptation, our method still outperforms those multi-source algorithms in both datasets. Since there are more variations of the data in the source domain in this setting, the increase in performance gain verifies our intuition that prototypes help mitigate the problem of sampling variability. ",
+        "bbox": [
+            173,
+            631,
+            825,
+            797
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/29e7f7b53e00f3148859fe23b527e615ce05a2fc0092a6216aef4cbad95284a2.jpg",
+        "table_caption": [
+            "Table 3: Accuracy $( \\% )$ on Office-Home for ResNet50-based MSDA method "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Category</td><td>Models</td><td>R→Ar</td><td>R→Cl</td><td>R→Pr</td><td>R→Rw</td><td>Avg</td></tr><tr><td rowspan=\"3\">Source- combined</td><td>DAN [8]</td><td>68.5</td><td>59.4</td><td>79.0</td><td>82.5</td><td>72.4</td></tr><tr><td>D-CORAL[71]</td><td>68.1</td><td>58.6</td><td>79.5</td><td>82.7</td><td>72.2</td></tr><tr><td>RevGrad [6]</td><td>68.4</td><td>59.1</td><td>79.5</td><td>82.7</td><td>72.4</td></tr><tr><td rowspan=\"2\">Multi-source</td><td>MFSAN[72]</td><td>72.1</td><td>62.0</td><td>80.3</td><td>81.8</td><td>74.1</td></tr><tr><td>SImpAl[70]</td><td>70.8</td><td>56.3</td><td>80.2</td><td>81.5</td><td>72.2</td></tr><tr><td></td><td>PCT(Ours)</td><td>76.3±0.5</td><td>64.1± 0.4</td><td>84.9±0.8</td><td>84.3±0.5</td><td>77.4</td></tr></table>",
+        "bbox": [
+            284,
+            819,
+            709,
+            901
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/e099107cfc5411544b4faca1e2dafd32ad3eec8314027d785ff8d948ee4f3c7b.jpg",
+        "table_caption": [
+            "Table 4: Accuracy $( \\% )$ on DomainNet for ResNet101-based MSDA methods. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Category</td><td>Models</td><td>R→Clipart</td><td>R→Infograph</td><td>R→Painting</td><td>R→Quickdraw</td><td>R→Real</td><td>R→Sketch</td><td>Avg</td></tr><tr><td rowspan=\"4\">Multi-source</td><td>DCTN [73]</td><td>48.6±0.7</td><td>23.5±0.6</td><td>48.8±0.6</td><td>7.2 ± 0.4</td><td>53.5±0.6</td><td>47.3±0.5</td><td>38.2±0.6</td></tr><tr><td>MSDA [65]</td><td>57.2 ± 1.0</td><td>24.2 ± 1.2</td><td>51.6 ± 0.4</td><td>5.2±0.5</td><td>61.6±0.9</td><td>49.6± 0.6</td><td>41.5± 0.7</td></tr><tr><td>M SDA-β[65]</td><td>58.6± 0.5</td><td>26.0±0.9</td><td>52.3 ±0.6</td><td>6.3±0.6</td><td>62.7± 0.5</td><td>49.5 ± 0.8</td><td>42.6±0.6</td></tr><tr><td>ML-MSDA [74]</td><td>61.4 ± 0.8</td><td>26.2 ± 0.4</td><td>51.9 ±0.2</td><td>19.1 ± 0.3</td><td>57.0 ± 1.0</td><td>50.3±0.7</td><td>44.3± 0.6</td></tr><tr><td rowspan=\"10\">Source- combined</td><td>ResNet-101 [24]</td><td>47.6±0.5</td><td>13.0 ± 0.4</td><td>38.1±0.5</td><td>13.3 ± 0.4</td><td>51.9 ± 0.9</td><td>33.7±0.5</td><td>32.9±0.5</td></tr><tr><td>DAN[8]</td><td>45.4± 0.5</td><td>12.8 ± 0.9</td><td>36.2 ±0.6</td><td>15.3 ± 0.4</td><td>48.6±0.7</td><td>34.0 ±0.5</td><td>32.1±0.6</td></tr><tr><td>RTN[75]</td><td>44.2 ± 0.6</td><td>12.6 ±0.7</td><td>35.3±0.6</td><td>14.6 ±0.8</td><td>48.4±0.7</td><td>31.7±0.7</td><td>31.1± 0.7</td></tr><tr><td>JAN[7]</td><td>40.9 ± 0.4</td><td>11.1 ± 0.6</td><td>35.4± 0.5</td><td>12.1 ± 0.7</td><td>45.8 ± 0.6</td><td>32.3±0.6</td><td>29.6±0.6</td></tr><tr><td>DANN [6]</td><td>45.5 ± 0.6</td><td>13.1 ± 0.7</td><td>37.0±0.7</td><td>13.2 ± 0.8</td><td>48.9 ± 0.7</td><td>31.8±0.6</td><td>32.6±0.7</td></tr><tr><td>ADDA [47]</td><td>47.5± 0.8</td><td>11.4 ± 0.7</td><td>36.7±0.5</td><td>14.7 ± 0.5</td><td>49.1 ± 0.8</td><td>33.5 ±0.5</td><td>32.2±0.6</td></tr><tr><td>SE[38]</td><td>24.7± 0.3</td><td>3.9±0.5</td><td>12.7 ± 0.4</td><td>7.1 ± 0.5</td><td>22.8±0.5</td><td>9.1± 0.5</td><td>16.1 ± 0.4</td></tr><tr><td>MCD[76]</td><td>54.3 ±0.6</td><td>22.1±0.7</td><td>45.7± 0.6</td><td>7.6± 0.5</td><td>58.4±0.7</td><td>43.5 ±0.6</td><td>38.5±0.6</td></tr><tr><td>PCT(Ours)</td><td>67.2±0.5</td><td>26.1±0.2</td><td>55.0±0.2</td><td>16.2 ± 0.2</td><td>67.1±0.2</td><td>53.7± 0.6</td><td>47.6 ± 0.1</td></tr></table>",
+        "bbox": [
+            173,
+            98,
+            825,
+            243
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Sub-sampled setting. In many cases, the label proportions could significantly change from one dataset to another, resulting in a decrease in a model’s performance. To test our algorithm under this setting, we follow the experimental protocol in Tachet des Combes et al. [18]. We keep only thirty percent of the first $\\lfloor K / 2 \\rfloor$ classes to simulate class imbalance. We directly take their results for the sub-sampled source data and perform additional experiments using the same sub-sampling scheme on the target data. The baselines in this setting are standard domain adaptation methods (DAN, JAN, and CDAN) and their importance weighted versions introduced in Tachet des Combes et al. [18]. We present the results in Table 5. On the sub-sampled source data, PCT with uniform prior outperforms the second-best method (IWCDAN) by $4 \\%$ on Office-31 and $6 . 6 \\%$ on Office-Home. Learning the prior distribution on the target domain does not improve the result, as this setting does not have a serious imbalance issue in the target domain. On the sub-sampled target data, PCT with a uniform prior already outperforms the baselines, $1 . 9 \\%$ and $5 . 2 \\%$ higher average accuracy than IWCDAN’s on Office-31 and Office-Home, respectively. Using a learnable prior further improves upon using a uniform prior by $1 . 0 \\%$ on Office-31 and by $0 . 4 \\%$ on Office-Home. The improvements confirm our intuition that prototypes help with the class imbalance in both the source and target domain while estimating the target proportion further boosts the performance in the target domain sub-sampled setting. We visualize the estimated proportions on the target data in Figure 3, verifying that the proportions are inferred correctly. ",
+        "bbox": [
+            173,
+            270,
+            825,
+            518
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/ae2ecdef18155fbcd64aa3e14c718e5366d6fef80ce957864593f3cd02e546d7.jpg",
+        "table_caption": [
+            "Table 5: Average accuracy $( \\% )$ on sub-sampled version of Office-31 and Office-Home (ResNet-50). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>sub-S O-31</td><td>sub-T O-31</td><td>sub-S O-H</td><td>sub-T O-H</td></tr><tr><td>ResNet-50 [68]</td><td>75.7</td><td>76.1</td><td>51.4</td><td>58.2</td></tr><tr><td>DANN [8]</td><td>76.2</td><td>75.9</td><td>51.8</td><td>58.3</td></tr><tr><td>JAN [7]</td><td>78.2</td><td>78.1</td><td>53.9</td><td>61.4</td></tr><tr><td>CDAN [26]</td><td>81.6</td><td>83.0</td><td>56.3</td><td>63.1</td></tr><tr><td>IWDAN[18]</td><td>82.6</td><td>79.2</td><td>57.6</td><td>58.6</td></tr><tr><td>IWJAN [18]</td><td>82.6</td><td>82.8</td><td>55.9</td><td>62.0</td></tr><tr><td>IWCDAN[18]</td><td>83.9</td><td>83.5</td><td>61.2</td><td>64.6</td></tr><tr><td>PCT-Uniform (Ours)</td><td>87.9 ± 0.4</td><td>85.4± 0.3</td><td>67.8 ± 0.3</td><td>69.8 ±0.2</td></tr><tr><td>PCT-Learnable (Ours)</td><td>87.9 ± 0.4</td><td>86.4±0.2</td><td>67.8± 0.3</td><td>70.2±0.2</td></tr></table>",
+        "bbox": [
+            267,
+            542,
+            725,
+            676
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Source-data-private setting. In many practical applications, practitioners might not directly have access to the source data in the adaptation stage. Instead, a trained model on the source data is provided. In this setting, the goal is to adapt to the target domain while only operating on the given model. We compare our method with Source Hypothesis Transfer (SHOT) [31], a state-ofthe-art method proposed specifically for this setting. SHOT contains two losses: an information maximization (IM) loss and a pseudo-labeling loss. We follow their experimental protocol by first training the model on the source data alone. During the adaptation stage, we only use the target data to perform model adaptation. We use the transport losses to update the feature encoder while fixing the prototypes. We report the results in Table 6. From the standard setting where we have access to source data in Table 1, the average accuracy drops by $1 . 6 \\%$ for Office-31 and by $0 . 8 \\%$ for Office-Home. On the Office-31 dataset, our bi-directional loss outperforms the IM loss by $1 . 1 \\%$ and the pseudo label loss by $0 . 8 \\%$ . While the average accuracy for our method is $0 . 2 \\%$ lower than both of their losses combined, the $p$ -value for the independent two-sample $t$ -test on the accuracies of different runs is 0.32, which is not statistically significant. On the Office-Home dataset, our approach performs $1 . 9 \\%$ and $0 . 5 \\%$ better than the pseudo label and IM losses, respectively. While their combined loss achieves $0 . 8 \\%$ accuracy higher than that of our method, the pseudo-labeling loss in SHOT requires constructing class centers, which does not scale well with large datasets. Our approach uses the classifier’s weights as class prototypes to avoid this issue. ",
+        "bbox": [
+            173,
+            690,
+            826,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/0c57924c6548f08669103181256f43a1cc612dedc967154b928bff9d5ab61cb9.jpg",
+        "image_caption": [
+            "Figure 3: Visualization of the estimated target proportions versus true class proportions for the task $\\mathbf { A }  \\mathbf { s D }$ on the Office-31 dataset. The dotted line represents a uniform proportion. It is clear that each orange bar (the learned proportions) is close to its adjacent blue bar (the true proportion). To quantify this observation, we measure the L1 loss between the true and learned proportions. The estimated proportions achieve lower L1 loss than the uniform distribution (0.16 vs 0.58), illustrating the effectiveness of our estimation strategy. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            90,
+            818,
+            329
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/29ec275b9c8fe962128f3d7972365d9894c5b7f882b83baa6412ef01183950bd.jpg",
+        "table_caption": [
+            "Table 6: Average Accuracy $( \\% )$ on the source-private Office-31 and Office-Home (ResNet-50). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Source Model Only</td><td>SHOT-Pseudo Label [31]</td><td>SHOT-IM[31]</td><td>SHOT [31]</td><td>PCT (Ours)</td></tr><tr><td>Office-31</td><td>79.3</td><td>87.6±0.5</td><td>87.3 ±0.5</td><td>88.6± 0.4</td><td>88.4 ±0.6</td></tr><tr><td>Office-Home</td><td>60.2</td><td>69.1 ±0.6</td><td>70.5±0.3</td><td>71.8 ± 0.4</td><td>71.0 ±0.6</td></tr></table>",
+        "bbox": [
+            174,
+            454,
+            823,
+            505
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            539,
+            823,
+            568
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.2 Analysis of results ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            593,
+            339,
+            607
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ablation study. To examine the effect of each component in our framework, we perform ablation studies and present the results in Table 7. 1) Alignment strategy. Next, we present the result using optimal transport as the alignment strategy. We consider two variants of Prototype-oriented Optimal Transport (POT): exact linear program (POT) and Sinkhorn relaxation (POT-Sinkhorn). In each variant, we solve for the optimal couplings using the optimal transport formulation. After obtaining the transport probabilities, we update the feature encoder using the obtained probabilities as the weights for the transport cost. We can see that POT performs $1 . 7 \\%$ better than DeepJDOT in Table 1, showing the effectiveness of using prototypes to define the transport costs with the target features. Still, both versions of POT underperforms PCT by $2 . 1 \\%$ and $1 . { \\bar { 7 } } \\%$ , respectively. 2) Effect of each loss in PCT. We examine the effect of each loss on the average test accuracy on the Office-31 dataset. We remove each transport loss while keeping the cross-entropy loss. The bi-directional loss leads to the best accuracy, while the drop in accuracy is more significant if we remove $\\mathcal { L } _ { \\mu \\to t }$ . This result is not surprising because, without $\\mathcal { L } _ { \\mu \\to t }$ , the model can map target data to only a few prototypes, leading to a degenerate solution. 3) Gradient stopping. We also show the algorithm’s performance without stopping the gradient of $\\pmb { \\mu }$ in the transport loss. PCT gains an additional $1 . 0 \\%$ in accuracy with the gradient stopping strategy. The performance gain is consistent with the finding in recent work by Chen and He [77], where the authors apply the gradient stopping strategy to avoid degenerate solutions in contrastive learning. 4) Cost function. Finally, we explore the cost function inspired by the radial basis kernel. We can see that the cosine distance in PCT gives $3 . 1 \\%$ higher average accuracy. In short, the choice of the probabilistic bi-directional transport framework, gradient-stopping strategy, and point-to-point cost function all contribute to the success of the proposed PCT method. ",
+        "bbox": [
+            173,
+            621,
+            826,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/2e86f3a6d1233db9c522114094fc9ef8c4a60929b6db2f80fc934057b331f7f5.jpg",
+        "table_caption": [
+            "Table 7: Average accuracy $( \\% )$ of PCT on Office-31 under different variants (ResNet-50). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>POT</td><td>POT-Sinkhorn</td><td>PCT w/o (Lt→μ)</td><td>PCT w/o (Lμ→t)</td><td>）w/o stop-grad</td><td>c(μk,fj）=exp(-μTf)</td><td>PCT (Ours)</td></tr><tr><td>87.9 ±0.8</td><td>88.3±0.9</td><td>88.6±0.2</td><td>84.3± 0.9</td><td>89.0 ±0.3</td><td>86.9 ±0.4</td><td>90.0±0.5</td></tr></table>",
+        "bbox": [
+            179,
+            113,
+            821,
+            146
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/81dc488a69bc5d1f0b5726e1cae2aafe2e6e623c7c3585f3e997453145926eae.jpg",
+        "image_caption": [
+            "Figure 4: (a) Analysis of parameter efficiency, (b) comparison of convergence, and (c) a t-SNE visualization of the output of the feature encoder trained with PCT on the task $\\mathbf A \\to \\mathbf W$ . In plot (c), prototypes $( { \\star } )$ , source features $( \\cdot )$ , and target features $( \\times )$ are tightly clustered together for each class. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            200,
+            802,
+            364
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Convergence comparison. We plot test accuracy versus iteration number on the task $( \\mathbf { A } \\to \\mathbf { W } )$ ) in Figure 4b to compare the convergence rate of different algorithms. We also visualize test accuracy versus convergence time in minutes in Appendix E. In both plots, PCT quickly converges within the first one thousand iterations, and the test accuracy does not fluctuate much thereafter. This phenomenon is not surprising since we use prototypes instead of the source features to align with the target features. We expect the prototypes to behave as representative samples of the source features, making the model converge quickly and stably. ",
+        "bbox": [
+            174,
+            435,
+            825,
+            532
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Visualization. We visualize in Figure 4c the t-SNE plot of the source and target features as well as the prototypes for the task $\\mathbf A \\to \\mathbf W$ . Figure 4c shows that both the source (dots ·) and target (crosses $\\times )$ features are close to the prototypes (black stars $\\star$ ), indicating that our algorithm is learning meaningful prototypes and successfully align the target features with the prototypes. ",
+        "bbox": [
+            176,
+            539,
+            825,
+            594
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            625,
+            299,
+            641
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We offer a holistic framework for unsupervised domain adaptation through the lens of a probabilistic bi-directional transport between the target features and class prototypes. With extensive experiments under various application scenarios of unsupervised domain adaptation, we show that the proposed prototype-oriented alignment method works well on multiple datasets, is robust against class imbalance, and can perform domain adaptation with no direct access to the source data. Without adding additional model parameters, our memory and computation-efficient algorithm achieves competitive performance with state-of-the-art methods on several widely used benchmarks. ",
+        "bbox": [
+            174,
+            662,
+            825,
+            760
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            790,
+            328,
+            808
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We thank Camillia Smith Barnes and Georgii Riabov for helpful discussions and feedback on the paper. K. Tanwisuth, X. Fan, H. Zheng, S. Zhang, and M. Zhou acknowledge the support of Grant IIS-1812699 from the U.S. National Science Foundation, the APX 2019 project sponsored by the Office of the Vice President for Research at The University of Texas at Austin, the support of a gift fund from ByteDance Inc., and the Texas Advanced Computing Center (TACC) for providing HPC resources that have contributed to the research results reported within this paper. ",
+        "bbox": [
+            174,
+            827,
+            823,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References   \n[1] Ali Farhadi and Mostafa Kamali Tabrizi. Learning to recognize activities from the wrong view point. In European conference on computer vision, pages 154–166. Springer, 2008.   \n[2] Hidetoshi Shimodaira. Improving predictive inference under covariate shift by weighting the log-likelihood function. Journal of statistical planning and inference, 90(2):227–244, 2000.   \n[3] Kate Saenko, Brian Kulis, Mario Fritz, and Trevor Darrell. Adapting visual category models to new domains. In European conference on computer vision, pages 213–226. Springer, 2010.   \n[4] Shai Ben-David, John Blitzer, Koby Crammer, and Fernando Pereira. Analysis of representations for domain adaptation. In B. Schölkopf, J. Platt, and T. Hoffman, editors, Advances in Neural Information Processing Systems, volume 19. MIT Press, 2007.   \n[5] Shai Ben-David, John Blitzer, Koby Crammer, Alex Kulesza, Fernando Pereira, and Jennifer Vaughan. A theory of learning from different domains. Machine Learning, 79:151–175, 2010.   \n[6] Yaroslav Ganin and Victor S. Lempitsky. Unsupervised domain adaptation by backpropagation. In Francis R. Bach and David M. Blei, editors, ICML, volume 37 of JMLR Workshop and Conference Proceedings, pages 1180–1189. JMLR.org, 2015.   \n[7] Mingsheng Long, Han Zhu, Jianmin Wang, and Michael I. Jordan. Deep transfer learning with joint adaptation networks. In Doina Precup and Yee Whye Teh, editors, Proceedings of the 34th International Conference on Machine Learning, volume 70 of Proceedings of Machine Learning Research, pages 2208–2217. PMLR, 06–11 Aug 2017.   \n[8] Mingsheng Long, Yue Cao, Jianmin Wang, and Michael I. Jordan. Learning transferable features with deep adaptation networks. In Proceedings of the 32nd International Conference on Machine Learning, ICML 2015, Lille, France, 6-11 July 2015, pages 97–105, 2015.   \n[9] Nicolas Courty, Rémi Flamary, Amaury Habrard, and Alain Rakotomamonjy. Joint distribution optimal transportation for domain adaptation. 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[10] Bharath Bhushan Damodaran, Benjamin Kellenberger, Rémi Flamary, Devis Tuia, and Nicolas Courty. DeepJDOT: Deep joint distribution optimal transport for unsupervised domain adaptation. CoRR, abs/1803.10081, 2018.   \n[11] Chen-Yu Lee, Tanmay Batra, Mohammad Haris Baig, and Daniel Ulbricht. Sliced Wasserstein discrepancy for unsupervised domain adaptation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 10285–10295, 2019.   \n[12] Renjun Xu, Pelen Liu, Liyan Wang, Chao Chen, and Jindong Wang. Reliable weighted optimal transport for unsupervised domain adaptation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), June 2020.   \n[13] Arthur Gretton, Karsten M Borgwardt, Malte J Rasch, Bernhard Schölkopf, and Alexander Smola. A kernel two-sample test. The Journal of Machine Learning Research, 13(1):723–773, 2012.   \n[14] Leonid V Kantorovich. On the translocation of masses. Journal of Mathematical Sciences, 133 (4):1381–1382, 2006.   \n[15] Gabriel Peyré and Marco Cuturi. Computational optimal transport. Foundations and Trends in Machine Learning, 11(5-6):355–607, 2019.   \n[16] Matthieu Lerasle, Zoltán Szabó, Timothée Mathieu, and Guillaume Lecué. Monk outlier-robust mean embedding estimation by median-of-means. In International Conference on Machine Learning, pages 3782–3793. PMLR, 2019.   \n[17] Yogesh Balaji, Rama Chellappa, and Soheil Feizi. Robust optimal transport with applications in generative modeling and domain adaptation. In Advances in Neural Information Processing Systems, 2020. ",
+        "bbox": [
+            173,
+            71,
+            828,
+            915
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[18] Remi Tachet des Combes, Han Zhao, Yu-Xiang Wang, and Geoff Gordon. Domain adaptation with conditional distribution matching and generalized label shift. In Advances in Neural Information Processing Systems, 2020. ",
+        "bbox": [
+            173,
+            90,
+            823,
+            133
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[19] Fredrik D. Johansson, David Sontag, and Rajesh Ranganath. Support and invertibility in domaininvariant representations. In Kamalika Chaudhuri and Masashi Sugiyama, editors, Proceedings of Machine Learning Research, volume 89 of Proceedings of Machine Learning Research, pages 527–536, 16–18 Apr 2019. ",
+        "bbox": [
+            174,
+            143,
+            826,
+            200
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[20] Yves Grandvalet, Yoshua Bengio, et al. Semi-supervised learning by entropy minimization. In CAP, pages 281–296, 2005. ",
+        "bbox": [
+            173,
+            209,
+            821,
+            239
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[21] Kun Zhang, Bernhard Schölkopf, Krikamol Muandet, and Zhikun Wang. Domain adaptation under target and conditional shift. In International Conference on Machine Learning, pages 819–827. PMLR, 2013. ",
+        "bbox": [
+            173,
+            250,
+            821,
+            292
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[22] Bernhard Schölkopf, Dominik Janzing, Jonas Peters, Eleni Sgouritsa, Kun Zhang, and Joris Mooij. On causal and anticausal learning. arXiv preprint arXiv:1206.6471, 2012. ",
+        "bbox": [
+            169,
+            301,
+            823,
+            332
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[23] Mingming Gong, Kun Zhang, Tongliang Liu, Dacheng Tao, Clark Glymour, and Bernhard Schölkopf. Domain adaptation with conditional transferable components. In International conference on machine learning, pages 2839–2848. PMLR, 2016. ",
+        "bbox": [
+            173,
+            340,
+            823,
+            385
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[24] Zachary Lipton, Yu-Xiang Wang, and Alexander Smola. Detecting and correcting for label shift with black box predictors. In International conference on machine learning, pages 3122–3130. PMLR, 2018. ",
+        "bbox": [
+            174,
+            393,
+            825,
+            436
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[25] Kamyar Azizzadenesheli, Anqi Liu, Fanny Yang, and Animashree Anandkumar. Regularized learning for domain adaptation under label shifts. arXiv preprint arXiv:1903.09734, 2019. ",
+        "bbox": [
+            173,
+            445,
+            823,
+            476
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[26] Mingsheng Long, Zhangjie Cao, Jianmin Wang, and Michael I Jordan. Conditional adversarial domain adaptation. In S. Bengio, H. Wallach, H. Larochelle, K. Grauman, N. Cesa-Bianchi, and R. Garnett, editors, Advances in Neural Information Processing Systems, volume 31. Curran Associates, Inc., 2018. ",
+        "bbox": [
+            173,
+            484,
+            825,
+            541
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[27] Huangjie Zheng and Mingyuan Zhou. Comparing probability distributions with conditional transport. arXiv preprint arXiv:2012.14100, 2020. ",
+        "bbox": [
+            169,
+            551,
+            823,
+            582
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[28] Jake Snell, Kevin Swersky, and Richard Zemel. Prototypical networks for few-shot learning. In Proceedings of the 31st International Conference on Neural Information Processing Systems, pages 4080–4090, 2017. ",
+        "bbox": [
+            174,
+            590,
+            825,
+            633
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[29] Yingwei Pan, Ting Yao, Yehao Li, Yu Wang, Chong-Wah Ngo, and Tao Mei. Transferrable prototypical networks for unsupervised domain adaptation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), 2019. ",
+        "bbox": [
+            173,
+            643,
+            823,
+            688
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[30] Guoliang Kang, Lu Jiang, Yi Yang, and Alexander G Hauptmann. Contrastive adaptation network for unsupervised domain adaptation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 4893–4902, 2019. ",
+        "bbox": [
+            173,
+            696,
+            823,
+            739
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[31] Jian Liang, Dapeng Hu, and Jiashi Feng. Do we really need to access the source data? source hypothesis transfer for unsupervised domain adaptation. In International Conference on Machine Learning, pages 6028–6039. PMLR, 2020. ",
+        "bbox": [
+            173,
+            750,
+            823,
+            792
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[32] Xiangyu Yue, Zangwei Zheng, Shanghang Zhang, Yang Gao, Trevor Darrell, Kurt Keutzer, and Alberto Sangiovanni Vincentelli. Prototypical cross-domain self-supervised learning for few-shot unsupervised domain adaptation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 13834–13844, 2021. ",
+        "bbox": [
+            173,
+            803,
+            823,
+            859
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[33] Kuniaki Saito, Donghyun Kim, Stan Sclaroff, Trevor Darrell, and Kate Saenko. Semi-supervised domain adaptation via minimax entropy. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 8050–8058, 2019. ",
+        "bbox": [
+            174,
+            868,
+            826,
+            911
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[34] Takeru Miyato, Shin-ichi Maeda, Masanori Koyama, and Shin Ishii. Virtual adversarial training: a regularization method for supervised and semi-supervised learning. IEEE transactions on pattern analysis and machine intelligence, 41(8):1979–1993, 2018.   \n[35] Samuli Laine and Timo Aila. Temporal ensembling for semi-supervised learning. arXiv preprint arXiv:1610.02242, 2016.   \n[36] Yuan Shi and Fei Sha. Information-theoretical learning of discriminative clusters for unsupervised domain adaptation. arXiv preprint arXiv:1206.6438, 2012.   \n[37] Rui Shu, Hung H Bui, Hirokazu Narui, and Stefano Ermon. A dirt-t approach to unsupervised domain adaptation. arXiv preprint arXiv:1802.08735, 2018.   \n[38] Geoffrey French, Michal Mackiewicz, and Mark Fisher. Self-ensembling for visual domain adaptation. arXiv preprint arXiv:1706.05208, 2017.   \n[39] Tuan-Hung Vu, Himalaya Jain, Maxime Bucher, Matthieu Cord, and Patrick Pérez. Advent: Adversarial entropy minimization for domain adaptation in semantic segmentation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 2517–2526, 2019.   \n[40] Kuniaki Saito, Donghyun Kim, Stan Sclaroff, and Kate Saenko. Universal domain adaptation through self supervision. arXiv preprint arXiv:2002.07953, 2020.   \n[41] Pietro Morerio, Jacopo Cavazza, and Vittorio Murino. Minimal-entropy correlation alignment for unsupervised deep domain adaptation. arXiv preprint arXiv:1711.10288, 2017.   \n[42] Xiaofu Wu, Quan Zhou, Zhen Yang, Chunming Zhao, Longin Jan Latecki, et al. Entropy minimization vs. diversity maximization for domain adaptation. arXiv preprint arXiv:2002.01690, 2020.   \n[43] Marco Saerens, Patrice Latinne, and Christine Decaestecker. Adjusting the outputs of a classifier to new a priori probabilities: a simple procedure. Neural computation, 14(1):21–41, 2002.   \n[44] Guoliang Kang, Liang Zheng, Yan Yan, and Yi Yang. Deep adversarial attention alignment for unsupervised domain adaptation: the benefit of target expectation maximization. In Proceedings of the European Conference on Computer Vision (ECCV), pages 401–416, 2018.   \n[45] Amr Alexandari, Anshul Kundaje, and Avanti Shrikumar. Maximum likelihood with biascorrected calibration is hard-to-beat at label shift adaptation. In International Conference on Machine Learning, pages 222–232. PMLR, 2020.   \n[46] Eric Tzeng, Judy Hoffman, Ning Zhang, Kate Saenko, and Trevor Darrell. Deep domain confusion: Maximizing for domain invariance. arXiv preprint arXiv:1412.3474, 2014.   \n[47] Eric Tzeng, Judy Hoffman, Kate Saenko, and Trevor Darrell. Adversarial discriminative domain adaptation. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 7167–7176, 2017.   \n[48] Shujian Zhang, Xinjie Fan, Huangjie Zheng, Korawat Tanwisuth, and Mingyuan Zhou. Alignment attention by matching key and query distributions. In NeurIPS 2021: Neural Information Processing Systems, Dec. 2021. (the first two authors contributed equally).   \n[49] Ian J Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial networks. arXiv preprint arXiv:1406.2661, 2014.   \n[50] Martin Arjovsky, Soumith Chintala, and Léon Bottou. Wasserstein generative adversarial networks. In International conference on machine learning, pages 214–223. PMLR, 2017.   \n[51] Soheil Kolouri, Phillip E Pope, Charles E Martin, and Gustavo K Rohde. Sliced Wasserstein auto-encoders. In International Conference on Learning Representations, 2018.   \n[52] Cédric Villani. Optimal transport: old and new, volume 338. Springer Science & Business Media, 2008. ",
+        "bbox": [
+            171,
+            45,
+            828,
+            922
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[53] Quentin Mérigot and Edouard Oudet. Discrete optimal transport: complexity, geometry and applications. Discrete & Computational Geometry, 55(2):263–283, 2016. ",
+        "bbox": [
+            169,
+            90,
+            825,
+            121
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "[54] Qiming Zhang, Jing Zhang, Wei Liu, and Dacheng Tao. Category anchor-guided unsupervised domain adaptation for semantic segmentation. arXiv preprint arXiv:1910.13049, 2019. ",
+        "bbox": [
+            173,
+            130,
+            823,
+            160
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "[55] Shaoan Xie, Zibin Zheng, Liang Chen, and Chuan Chen. Learning semantic representations for unsupervised domain adaptation. In International conference on machine learning, pages 5423–5432. PMLR, 2018. ",
+        "bbox": [
+            174,
+            169,
+            823,
+            212
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "[56] Marthinus Christoffel Du Plessis and Masashi Sugiyama. Semi-supervised learning of class balance under class-prior change by distribution matching. Neural Networks, 50:110–119, 2014. ",
+        "bbox": [
+            171,
+            222,
+            825,
+            252
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "[57] Tuan Duong Nguyen, Marthinus Christoffel, and Masashi Sugiyama. Continuous target shift adaptation in supervised learning. In Asian Conference on Machine Learning, pages 285–300. PMLR, 2016. ",
+        "bbox": [
+            173,
+            261,
+            825,
+            304
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "[58] Yee Seng Chan and Hwee Tou Ng. Word sense disambiguation with distribution estimation. In IJCAI, volume 5, pages 1010–5. Citeseer, 2005. ",
+        "bbox": [
+            171,
+            314,
+            825,
+            343
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "[59] Amos Storkey. When training and test sets are different: Characterizing learning transfer. Dataset shift in machine learning, 30:3–28, 2009. ",
+        "bbox": [
+            171,
+            353,
+            825,
+            382
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "[60] Rui Li, Qianfen Jiao, Wenming Cao, Hau-San Wong, and Si Wu. Model adaptation: Unsupervised domain adaptation without source data. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 9641–9650, 2020. ",
+        "bbox": [
+            173,
+            392,
+            823,
+            435
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "[61] Vinod K Kurmi, Venkatesh K Subramanian, and Vinay P Namboodiri. Domain impression: A source data free domain adaptation method. In Proceedings of the IEEE/CVF Winter Conference on Applications of Computer Vision, pages 615–625, 2021. ",
+        "bbox": [
+            173,
+            445,
+            825,
+            488
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "[62] Jogendra Nath Kundu, Rahul Mysore Venkatesh, Naveen Venkat, Ambareesh Revanur, and R Venkatesh Babu. Class-incremental domain adaptation. In Computer Vision–ECCV 2020: 16th European Conference, Glasgow, UK, August 23–28, 2020, Proceedings, Part XIII 16, pages 53–69. Springer, 2020. ",
+        "bbox": [
+            173,
+            497,
+            825,
+            555
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "[63] Jogendra Nath Kundu, Naveen Venkat, R Venkatesh Babu, et al. Universal source-free domain adaptation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 4544–4553, 2020. ",
+        "bbox": [
+            173,
+            564,
+            823,
+            608
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "[64] Hemanth Venkateswara, Jose Eusebio, Shayok Chakraborty, and Sethuraman Panchanathan. Deep hashing network for unsupervised domain adaptation. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 5018–5027, 2017. ",
+        "bbox": [
+            173,
+            617,
+            823,
+            661
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "[65] Xingchao Peng, Qinxun Bai, Xide Xia, Zijun Huang, Kate Saenko, and Bo Wang. Moment matching for multi-source domain adaptation. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 1406–1415, 2019. ",
+        "bbox": [
+            171,
+            670,
+            823,
+            714
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "[66] Mingsheng Long Junguang Jiang, Bo Fu. Transfer-learning-library. https://github.com/ thuml/Transfer-Learning-Library, 2020. ",
+        "bbox": [
+            171,
+            723,
+            823,
+            753
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "[67] Yuchen Zhang, Tianle Liu, Mingsheng Long, and Michael Jordan. Bridging theory and algorithm for domain adaptation. In International Conference on Machine Learning, pages 7404–7413. PMLR, 2019. ",
+        "bbox": [
+            173,
+            762,
+            825,
+            805
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "[68] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 770–778, 2016. ",
+        "bbox": [
+            173,
+            815,
+            825,
+            858
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "[69] Mengxue Li, Yi-Ming Zhai, You-Wei Luo, Peng-Fei Ge, and Chuan-Xian Ren. Enhanced transport distance for unsupervised domain adaptation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 13936–13944, 2020. ",
+        "bbox": [
+            174,
+            868,
+            826,
+            911
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "[70] Naveen Venkat, Jogendra Nath Kundu, Durgesh Kumar Singh, Ambareesh Revanur, and R Venkatesh Babu. Your classifier can secretly suffice multi-source domain adaptation. arXiv preprint arXiv:2103.11169, 2021.   \n[71] Baochen Sun and Kate Saenko. Deep coral: Correlation alignment for deep domain adaptation. In European conference on computer vision, pages 443–450. Springer, 2016.   \n[72] Yongchun Zhu, Fuzhen Zhuang, and Deqing Wang. Aligning domain-specific distribution and classifier for cross-domain classification from multiple sources. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, pages 5989–5996, 2019.   \n[73] Ruijia Xu, Ziliang Chen, Wangmeng Zuo, Junjie Yan, and Liang Lin. Deep cocktail network: Multi-source unsupervised domain adaptation with category shift. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 3964–3973, 2018.   \n[74] Zhenpeng Li, Zhen Zhao, Yuhong Guo, Haifeng Shen, and Jieping Ye. Mutual learning network for multi-source domain adaptation. arXiv preprint arXiv:2003.12944, 2020.   \n[75] Mingsheng Long, Han Zhu, Jianmin Wang, and Michael I Jordan. Unsupervised domain adaptation with residual transfer networks. arXiv preprint arXiv:1602.04433, 2016.   \n[76] Kuniaki Saito, Kohei Watanabe, Yoshitaka Ushiku, and Tatsuya Harada. Maximum classifier discrepancy for unsupervised domain adaptation. CoRR, abs/1712.02560, 2017.   \n[77] Xinlei Chen and Kaiming He. Exploring simple siamese representation learning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 15750–15758, 2021.   \n[78] Tatiana Tommasi, Novi Patricia, Barbara Caputo, and Tinne Tuytelaars. A deeper look at dataset bias. In Domain adaptation in computer vision applications, pages 37–55. Springer, 2017.   \n[79] Boqing Gong, Fei Sha, and Kristen Grauman. Overcoming dataset bias: An unsupervised domain adaptation approach. In NIPS Workshop on Large Scale Visual Recognition and Retrieval, volume 3. Citeseer, 2012.   \n[80] Paul S Bradley, Kristin P Bennett, and Ayhan Demiriz. Constrained K-means clustering. Microsoft Research, Redmond, 20(0):0, 2000.   \n[81] Yuki Markus Asano, Christian Rupprecht, and Andrea Vedaldi. Self-labelling via simultaneous clustering and representation learning. arXiv preprint arXiv:1911.05371, 2019. ",
+        "bbox": [
+            171,
+            90,
+            828,
+            603
+        ],
+        "page_idx": 14
+    }
+]