Add files using upload-large-folder tool

parse/train/Bk9nkMa4G/Bk9nkMa4G.md

@@ -0,0 +1,250 @@
+# BAYESIAN EMBEDDINGS FOR LONG-TAILED DATASETS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+The statistics of the real visual world presents a long-tailed distribution: a few classes have significantly more training instances than the remaining classes in a dataset. This is because the real visual world has a few classes that are common while others are rare. Unfortunately, the performance of a convolutional neural network is typically unsatisfactory when trained using a long-tailed dataset. To alleviate this issue, we propose a method that discriminatively learns an embedding in which a simple Bayesian classifier can balance the class-priors to generalize well for rare classes. To this end, the proposed approach uses a Gaussian mixture model to factor out class-likelihoods and class-priors in a long-tailed dataset. The proposed method is simple and easy-to-implement in existing deep learning frameworks. Experiments on publicly available datasets show that the proposed approach improves the performance on classes with few training instances, while maintaining a comparable performance to the state-of-the-art on classes with abundant training examples.
+
+# 1 INTRODUCTION
+
+Deep convolutional neural networks (CNN) have achieved impressive results in large-scale visual recognition tasks (Krizhevsky et al., 2012; Simonyan & Zisserman, 2015; Szegedy et al., 2015; Mnih et al., 2015; 2013; He et al., 2016; Huang et al., 2017). However, despite the significant impact in visual perception, the vast majority of these advancements learn from artificially balanced largescale datasets that are not representative of the real visual world (Nene et al., 1996; Griffin et al., 2007; Deng et al., 2009; Quattoni & Torralba, 2009; Lin et al., 2014; Russakovsky et al., 2015). The statistics of the real visual world follow a long-tailed distribution (Zhu et al., 2014; 2016; Van Horn & Perona, 2017; Salakhutdinov et al., 2011; Wang & Hebert, 2016; Wang et al., 2017). This means that a few classes are predominant in the world while others are rare. Consequently, representative real-world datasets have a few classes with significantly more training instances than the remaining classes in the set; see Fig. 1(a) for an illustration of a long-tailed dataset. We refer to classes with abundant training instances as classes in the head, and unrepresented classes as classes in the tail.
+
+As Van Horn & Perona (2017) note, the main motivation for visual recognition is to understand and learn from the real visual world. Thus, while the state-of-the-art can challenge humans in visual recognition tasks, it misses a mechanism that effectively learns from long-tailed datasets. As Van Horn & Perona (2017) found, training models using long-tailed datasets often leads to unsatisfying performance. This is because classifiers tend to generalize well for classes in the head, but lack generalization for classes in the tail.
+
+To alleviate this issue, learned classifiers need to generalize for classes in the tail while maintaining a good performance for all the classes. Recent efforts that aim to learn from long-tailed datasets consider penalities in the optimization-learning problem (Huang et al., 2016), sampling-based methods (He & Garcia, 2009), and transfer-learning algorithms (Wang & Hebert, 2016; Wang et al., 2017). In contrast with these solutions, the proposed method aims to learn an embedding in which the distribution of the real visual world allows a simple Bayesian classifier to predict robustly given a long-tailed dataset.
+
+Long-tailed datasets have class-prior statistics that heavily skew towards classes in the head. This skew can bias classifiers towards classes in the head, and consequently can reduce generalization for classes in the tail. To remove this skew, we appeal to Bayesian classifiers that can explicitly factor out the likelihood and prior when computing posteriors over class labels. Thus, the main goal of this work is to learn a feature embedding in which class prior statistics do not affect/skew class likelihoods. The proposed approach uses a simple Gaussian mixture model (GMM) to describe the statistics of a long-tailed dataset. This is because it enables a clean factorization of the class-likelihoods and class-priors. Moreover, it easily fits within an empirical Bayesian classification framework, because a GMM enables the computation of closed-form maximum likelihood estimation (MLE) of class-specific means, covariance matrices, and priors. We show that such closed-form estimates can be integrated into existing deep learning optimizers without much effort. By fixing the covariance matrices of all the classes to be the identity and the priors over each class to be uniform, we can explicitly enforce that both rare classes in the tail and dominant classes in the head have equal weight for Bayesian classification. In simple terms: we learn a discriminative embedding of training data such that Bayesian classifiers with balanced priors produce accurate class posteriors. As a point of clarity, the proposed approach does not learn an embedding in the traditional Bayesian sense, which might define a prior distribution over embeddings that is then combined with training data to produce a posterior embedding. Rather, it learns a single embedding that is discriminatively trained to produce accurate features for Bayesian classifiers. See Fig. 1 for an illustration about the proposed approach.
+
+![](images/1d2129a3dbac2fa15d2af3f0eb09c915cc1c4fc9698fffe6985a1f92708b292b.jpg)  
+Figure 1: (a) The real visual world yields long-tailed datasets. Classes in the head are common (e.g., cats) while classes in the tail are rare (e.g., white reindeers). (b) The proposed approach builds a generative (Bayesian) classifier over a learned embedding to compute class-posterior probabilities. In an empirical Bayesian framework, posteriors are computed through class likelihoods and priors fit to the data (e.g., sample means, variances, and counts assuming Gaussian Mixture Models). We introduce an end-to-end pipeline for jointly learning embeddings and Bayesian models built upon them. (c) Bayesian models are particularly well-suited for long-tailed datasets because class priors and likelihoods can be fixed to be uniform and isotropic, ensuring that the learned representation is balanced across the head and tail.
+
+A GMM not only is useful for learning an embedding using a long-tailed dataset, but also provides flexibility at the evaluation stage. This is because it enables the measurement of generalization for classes in the tail by simply setting equal class-prior probabilities. In addition, it enables the possibility of giving more importance to the most frequent classes by adjusting their respective class-prior probabilities.
+
+In sum, the proposed approach aims to learn an embedding in which a GMM enables a Bayesian classifier to generalize well for classes in the tail by balancing out class-priors. The proposed method is simple, easy-to-train using deep learning frameworks, and increases classification performance for classes in the tail. The experiments on publicly available datasets show that this approach tends to perform better on classes in the tail than the competing methods, while performing comparable to the state-of-the-art on classes with abundant training instances.
+
+# 2 RELATED WORK
+
+The main challenges for learning models using long-tailed datasets comprise learning parameters that generalize from a few-shots and avoiding classifier bias. While the proposed approach aims to tackle these two problems simultaneously, methods that tackle each of these problems independently are still relevant. As such, this section not only covers prior work on learning using imbalanced datasets, but also covers relevant solutions for few-shot learning. Given that the proposed approach is based on a GMM model, this section also covers recent approaches that use class-centroid representations for incremental learning and for improving discriminative properties.
+
+# 2.1 LEARNING FROM LONG-TAILED DATASETS
+
+Simple techniques that deal with imbalanced datasets use random sampling to artificially create a more balanced training set (He & Garcia, 2009). For instance, random oversampling effectively “repeats” training instances from the classes in the tail, while random undersampling “removes” instances from the classes with abundant training instances. Thus, these techniques address imbalanced datasets by means of artificially balancing the training set. An alternative approach to deal with long-tailed datasets use transfer learning techniques. Wang et al. (2017) proposed MetaModelNet, a meta-learning algorithm that learns the evolution of parameters when gradually including more training samples. MetaModelNet improves the performance of CNN models since it transfers the parameter-evolution knowledge from data-rich classes to categories in the tail. Rather than artificially modifying the training set or use transfer learning, the proposed approach aims to learn an embedding that allows classifiers to generalize when learning from a long-tailed dataset. Consequently, the proposed method can complement sampling or transfer-learning-based methods.
+
+# 2.2 FEW-SHOT LEARNING AND CLASS-CENTROID-BASED REPRESENTATIONS
+
+Recent approaches in this category aim to learn good parameters from a few training instances (Snell et al., 2017; Hariharan & Girshick, 2017). A recent approach that considers an imbalanced dataset to tackle few-shot learning is the work by Hariharan & Girshick (2017). Their proposed approach learns a feature embedding from the classes with the most samples in the dataset. Then, the approach “hallucinates” samples for classes with a few training instances in the learned embedding. While this work learns from an imabalanced dataset, it considers a different setting that that of the proposed approach. The work by Hariharan & Girshick (2017) assumes that classes with few instances are added incrementally. The proposed approach differs in this regard, since the introduced method aims to learn the embedding using the entire long-tailed dataset, generalize, and avoid any bias towards the classes with abundant training instances.
+
+To achieve generalization given a few shots in an incremental learning context, Rebuffi et al. (2017) proposed iCaRL, a deep-learning-based incremental classifier. Similarly to the proposed approach, iCaRL represents each class using a single centroid in an embedding learned using a regular CNN model. However, instead of using the learned softmax classifier, it uses a nearestclass-mean (Mensink et al., 2013) classifier. Unlike iCaRL that uses features from a learned CNNsoftmax model, the proposed approach learns an embedding using a generative model. It is worth noting that the proposed approach uses a GMM, which by default includes a nearest-class-mean classifier as part of the learning problem. The use of class-centroids in learning representations is also useful to improve discriminative properties. Wen et al. (2016) proposed a loss that aims to minimize intra-class variation in CNN-softmax models. Unlike the center-loss approach, the proposed method minimizes the intra-class variation automatically by finding the GMM parameters in the learned embedding. Different from the center-loss that requires a mechanism to estimate the class-centroids, the proposed approach uses back-propagation to learn the GMM parameters. A recent approach that aims to generalize by using class-centroid representations are the Prototypical Networks (proto-nets) by Snell et al. (2017). Proto-nets estimate the class centroids from a slice of a mini-batch-like subset of the training set. Then, they evaluate the loss from the complementary slice of the mini-batch-like subset, and update the feature encoder weights. The proposed approach has two main differences with proto-nets. First, the proposed approach is based on generative models describing the statistics of an imbalanced dataset, rather than learning an embedding tailored for a nearest-class-mean classifier that requires specific parameter-update rules. Second, the proposed approach uses regular batching mechanisms and updates parameters using back-propagation. Thus, in constrast with proto-nets, the proposed approach avoids modifying components in the deep learning frameworks.
+
+# 3 BAYESIAN EMBEDDINGS
+
+The goal of this work is to learn an embedding that allows a simple Bayesian classifier to robustly operate given a long-tailed training dataset. Specifically, this work aims to learn an encoder $f _ { w } ( \cdot )$ , parameterized by its set of weights $w$ , that produces a good representation for Bayesian classification given a long-tailed dataset.
+
+In order to learn the aforementioned encoder, the proposed approach requires a model that describes the distribution of the data. Let $x = f _ { w } ( I )$ be the encoded feature for image $I$ and $y$ be its corresponding class label. Thus, the distribution of the training set can be described with the following joint probability:
+
+$$
+\begin{array} { r l } & { p ( x , y ) = p ( x \mid y ) p ( y ) } \\ & { \qquad = p ( f _ { w } ( I ) \mid y ; \theta _ { y } ) \pi _ { y } } \\ & { \qquad = p ( x , y ; \ w , \theta ) } \end{array}
+$$
+
+where $p ( f _ { w } ( I ) \mid y ; \theta _ { y } )$ represents the likelihood of observing the feature vector $x$ as part of class $y$ , and $\pi _ { y }$ is the prior probabilities for class $y$ . The likelihood is a function with parameters $\theta _ { y }$ (e.g., parameters of a multivariate Gaussian) that describes the distribution of the feature vectors in the embedding. Thus, the joint probability of the data $p ( x , y ; ~ w , \theta )$ is a function with parameters composed by the the encoder $w$ parameters, and the Bayesian parameters $\theta$ which include the likelihood parameters $\theta _ { y }$ , and priors $\pi _ { y }$ . In practice, the likelihood parameters proves most crucial as it is not sensitive to class priors, which can be misleading in the long-tailed setting (as discussed in Section 3.1).
+
+Given the above joint probability model, the posterior probability for class $y$ given a feature vector $x$ can be computed using Bayes rule as follows:
+
+$$
+p ( y \mid x ; \boldsymbol { w } , \boldsymbol { \theta } ) = \frac { p ( f _ { w } ( I ) \mid y ; \theta _ { y } ) \pi _ { y } } { \sum _ { k } p ( f _ { w } ( I ) \mid k ; \theta _ { k } ) \pi _ { k } } ,
+$$
+
+where $\theta$ is a concatenation of the likelihood parameters and priors of all the classes. Thus, the class posterior probability is a function that depends on the encoder parameters $w$ and the Bayesian parameters $\theta$ .
+
+The overall objective of this work is to jointly learn the weights $w$ of the feature encoder and the Bayesian parameters $\theta$ to guarantee a good classification performance. Given a training dataset of images and label pairs $\mathcal { D } = \{ ( x _ { i } , y _ { i } ) \}$ , we propose to learn parameters by maximizing the Bayesian class-posterior probability of the true class labels:
+
+$$
+\operatorname* { m i n i m i z e } _ { \boldsymbol { w } } \sum _ { i } - \log p ( \boldsymbol { y } _ { i } \mid \boldsymbol { x } _ { i } ; \boldsymbol { w } , \boldsymbol { \theta } ) \qquad \mathrm { s u b j e c t ~ t o } \qquad \boldsymbol { \theta } = \mathbf { M L E } ( \mathcal { D } ) ,
+$$
+
+where MLE is a function that computes the closed form maximum likelihood estimates of the parameters of our Bayesian model, a procedure commonly known as Empirical Bayes (Bishop, 2006).
+
+To use existing solvers for learning deep networks, we reformulate the problem shown in Eq. (3) as an unconstrained optimization by using a Lagrangian penalty (Boyd & Vandenberghe, 2004) that penalizes solutions which violate the constraint:
+
+$$
+\operatorname* { m i n i m i z e } _ { \boldsymbol { w } , \boldsymbol { \theta } } \quad \sum _ { i } - \log p ( y _ { i } \mid \boldsymbol { x } _ { i } ; \boldsymbol { w } , \boldsymbol { \theta } ) + \lambda \| \boldsymbol { \theta } - \mathbf { M } \mathbf { L } \mathbf { E } ( \mathcal { D } ) \| ^ { 2 } \quad ,
+$$
+
+where $\lambda \geq 0$ . In this formulation, the optimization explicitly searches over the feature encoder parameters $w$ and the Bayesian parameters $\theta$ so as to maximize class posterior probabilities. The last term penalizes deviations of the $\theta$ parameters from their MLE estimates, effectively acting as a regularizer.
+
+# 3.1 GMM EMBEDDINGS FOR HEAVILY TAILED DATASETS
+
+GMMs: The likelihood models are crucial to determine the parameters that allows the proposed approach to learn the feature encoder given a long-tailed dataset. We propose to use a multivariate Gaussian probability density function as the likelihood model. Given this likelihood model, the proposed approach implicitly uses a Gaussian mixture model to represent the distribution of the training set. Using a multivariate Gaussian brings benefits to the proposed formulation. This is because its parameters (the centroid $\mu$ , covariance matrix $\Sigma$ , and prior $\pi$ ) have an intuitive meaning and closed-form-maximum-likelihood estimators. Interestingly, as discussed by van den Oord & Schrauwen (2014) and Patel et al. (2016), a mixture of multivariate Gaussians can be used to theoretically motivate the success of deep learning.
+
+Balancing: The use of a GMM not only brings simplicity into the formulation, but also allows the feature encoder to generalize better for classes in the tail. The generalization aspect of a GMM model comes from the fact that a class is described with a single centroid. The benefit of this class representation is that estimating the centroid with a handful of examples is simple and produces a good estimate. Perhaps more importantly, a GMM allows us to access specific parameters that control the probabilistic “footprint” of each class in the embedded space. We can set these parameters to ensure balanced footprints by fixing the covariance matrices to be the identity and the class priors to be uniform - see Fig. 1-(c). The remaining parameters to be estimated are then the class means $\boldsymbol { \mu } = ( \mu _ { 1 } , \dots , \mu _ { n _ { c } } )$ . Given this setting and considering that deep-learning frameworks use mini batches, the unconstrained problem shown in Eq. (4) becomes:
+
+![](images/91335f7e72779fdebb18a37fd60ffe71643340e092071ef8efcdf04d035d7840.jpg)  
+Figure 2: We compare the effect of gradient-based updates for a traditional softmax classifier versus our Bayesian embedding model. Recall that our approach learns an embedding for which Bayesian classifiers produce accurate class posteriors. During softmax training, an “easy” example of a class will tend to not generate a strong gradient update, and so is not useful for learning (left). This might be considered paradoxical: when children learn a new concept (for say, a never-before-seen animal), an easy or “protypical” example might be most informative for learning. On the other hand, in our framework, an easy example of a class will change its centroid, generating a strong signal for updating our learned representation (right).
+
+$$
+\underset { w , \mu } { \mathrm { n i m i z e } } \quad \frac { 1 } { m } \sum _ { i = 1 } ^ { m } - \log \left( \frac { \exp \left( - \frac { 1 } { 2 } \| f _ { w } ( I _ { i } ) - \mu _ { y _ { i } } \| ^ { 2 } \right) } { \sum _ { k } \exp \left( - \frac { 1 } { 2 } \| f _ { w } ( I _ { i } ) - \mu _ { k } \| ^ { 2 } \right) } \right) + \lambda \sum _ { j \in \mathcal { M } } \| \mu _ { j } - \frac { 1 } { n _ { j } } \sum _ { i ^ { \prime } : y _ { i ^ { \prime } } = j } f _ { w } ( I _ { i ^ { \prime } } ) \| ^ { 2 } \quad ,
+$$
+
+where $y _ { i }$ is the true class label/index for the $i$ -th data point, $m$ is the batch size, $\mathcal { M }$ is the set of class indices in the batch, $n _ { j }$ is the number of samples of the $j$ -th class in the batch, and $i ^ { \prime }$ is the index running over instances in the batch.
+
+# 3.2 DISCUSSION
+
+Other probabilistic models: Our analysis and experiments focus on Gaussian Mixture Models, but the general learning problem from Eq. (4) holds for other probabilistic models. For example, deep embeddings can be learned for rectified (nonnegative) or binary features (Agrawal et al., 2014; Erin Liong et al., 2015). For such embeddings, likelihood models based on rectified Gaussians or multivariate Bernoulli distributions may be more appropriate Socci et al. (1998); Teugels (1990). Such models do not appear to have closed form maximum likelihood estimates, and so may be challenging to formulate precisely as a constrained optimization problem.
+
+Relationship to softmax: The GMM-based formulation has a direct relationship with softmax classifiers. This relationship can be obtained by expanding the squared distance terms in the classposterior probability, yielding the following:
+
+$$
+\begin{array} { r l } & { p \left( y _ { i } \mid f _ { w } ( I _ { i } ) ; \boldsymbol { w } , \mu \right) = \frac { \exp \big ( - \frac { 1 } { 2 } \| f _ { w } ( I _ { i } ) - \mu _ { j } \| ^ { 2 } \big ) } { \sum _ { k } \exp \big ( - \frac { 1 } { 2 } \| f _ { w } ( I _ { i } ) - \mu _ { k } \| ^ { 2 } \big ) } } \\ & { \qquad = \frac { \exp \big ( \mu _ { j } ^ { T } f _ { w } ( I _ { i } ) - \frac { 1 } { 2 } \big ( \| f _ { w } ( I _ { i } ) \| ^ { 2 } + \| \mu _ { j } \| ^ { 2 } \big ) \big ) } { \sum _ { k } \exp \big ( \mu _ { k } ^ { T } f _ { w } ( I _ { i } ) - \frac { 1 } { 2 } \big ( \| f _ { w } ( I _ { i } ) \| ^ { 2 } + \| \mu _ { k } \| ^ { 2 } \big ) \big ) } , } \\ & { \qquad = \frac { \exp \big ( v _ { j } ^ { T } f _ { w } ( I _ { i } ) + b _ { j } \big ) } { \sum _ { k } \exp \big ( v _ { k } ^ { T } f _ { w } ( I _ { i } ) + b _ { k } \big ) } } \end{array}
+$$
+
+where $v _ { j } = \mu _ { j }$ and $b _ { j } = - { \textstyle \frac { 1 } { 2 } } \| v _ { j } \| ^ { 2 }$ , since $- \frac { 1 } { 2 } \| f _ { w } ( I _ { i } ) \| ^ { 2 }$ is a common term between the numerator and denominator. This relationship thus indicates that the proposed approach fits linear classifiers with restricted biases. This relationship is useful for an easy implementation in many deep learning frameworks. This is because this approach can be implemented using a dense layer without the bias terms. In addition, this relationship shows that the proposed approach requires fewer parametersto-learn in comparison with classical CNN-softmax models. An more intuitive comparison between GMMs and softmax classifiers can be made with respect to to their parameter updates. Intuitively, during softmax training, an “easy” example of a class will not generate a model update. In some sense, this might be considered paradoxical. When children learn a new concept (for say, a neverbefore-seen animal), they tend to be presented with an easy or “protypical” example. On the other hand, an easy example of a class will change its centroid, generating a signal for learning - see Fig. 2.
+
+# 4 EXPERIMENTS
+
+This section presents a series of experiments evaluating the learned embedding computed using the proposed method and long-tailed datasets. Since the goal of the experiments is to evaluate the feature encoder, all the experiments trained all the baselines or competing methods and the proposed one from scratch. An additional goal of the experiments is to show that the proposed approach can be adapted to any CNN architecture. For this reason, the experiments also used legacy and recent CNN architectures.
+
+Datasets: One evaluation aspect of the experiments is to measure the performance on smalland medium-scale datasets. The experiments included MNIST (LeCun et al., 1998) and CIFAR 10 (Krizhevsky & Hinton, 2009) as the small-scale datasets (each with ten classes); and CIFAR 100 (Krizhevsky & Hinton, 2009) and Tiny ImageNet 1 as the medium-scale datasets (with hundred and two hundred classes, respectively). The balanced MNIST dataset contains 60,000 and 10,000 $2 8 \mathbf { x } 2 8$ training and testing images depicting hand-written digits, respectively. The CIFAR 10 dataset contains 50,000 and $1 0 , 0 0 0 3 2 \mathrm { x } 3 2$ training and testing images, respectively. The CIFAR 100 dataset contains 500 and $1 0 0 \ 3 2 \mathrm { x } \lambda 2$ training and testing images per class, respectively. Lastly, Tiny ImageNet has 500 and 50 64x64 training and testing images for every class, respectively. However, the experiments used a $2 2 4 \mathbf { x } 2 2 4$ image instead. See Sec. 4.1 for details on how the experiments processed these datasets to evaluate classifiers using long-tailed datasets.
+
+Baselines: The experiments included recent approaches that deal with imbalanced datasets. These approaches include iCaRL (Rebuffi et al., 2017), center loss (Wen et al., 2016), and a plain softmax classifier. The experiments also consider a variation of iCaRL. This variation does not use normalized feature vectors as originally proposed by Rebuffi et al. (2017). While prototypical networks (Snell et al., 2017) are similar to the proposed approach, they require a balanced dataset with a few training instances for every class. Since prototypical networks do not assume a long-tailed dataset, these experiments did not include it as a competing method. The experiment also considered a method that uses a full GMM model (i.e., full covariance, means, and priors) of a softmax representation of the training set. As discussed in Sec. 2, MetaModelNet (Wang et al., 2017) deals with long-tailed datasets by operating at the classifier-parameter level, since it is a meta-learning algorithm. Thus, MetaModelNet does not learn an embedding, and consequently complements the proposed method.
+
+Implementation Details: All the experiments were implemented on top of TensorFlow Models $( \mathrm { T F M } ) ^ { 2 }$ . This open-source project implements various legacy architectures, and several preprocessing imaging techniques (e.g., random translations and shifts). The experiments used the following CNN architectures: LeNet (LeCun et al., 1998) for MNIST; CifarNet (Krizhevsky & Hinton, 2009) for CIFAR 10; AllCNN (Springenberg et al., 2014) for CIFAR 100; and VGG 16 (Simonyan & Zisserman, 2015) for Tiny ImageNet. We implemented center loss (Wen et al., 2016) and verified correctness using a balanced setting. We implemented the proposed approach in TFM using a fully connected layer with a restrictive bias. This is possible thanks to the relationship with linear classifiers discussed in Sec. 3.2. The regularizer was implemented using plain Tensorflow operations and was added as a regularizer function for the fully connected layer with restrictive bias. We will release the code upon publication. The hyperparameters for center-loss and the proposed approach were estimated using a validation set for every dataset. See Sec. A in the Appendix for the specific parameters.
+
+![](images/04550cb04c486edb38153b88e185b99d5ab24c22f5da6dd192fc128774d55a5b.jpg)  
+Figure 3: Histogram of the number of training instances per class in the long-tailed datasets. From left to right, the datasets are MNIST, CIFAR 10, CIFAR 100, and Tiny ImageNet.
+
+# 4.1 EVALUATION FOR LONG-TAILED DATASETS
+
+The main motivation of this work is to learn from a realistic dataset representing the statistics of the real visual world. Recall that realistic datasets are long-tailed since the visual world has a few predominant classes while others are rare. As such, the performance evaluation of the visual recognition system in this setting needs to be discussed, since common evaluation methods may not be adequate given this context.
+
+Intuitively, since the visual world yields long-tailed datasets, then the test set should ideally be long-tailed as well. While this rationale is logical given the statistics of the world, it has a main drawback: a simple classifier that is biased towards classes in the head is likely to perform well using a long-tailed testing set. While this setting may reflect a good performance for the common classes in practice, achieving a good performance for classes in the tail is still desirable in real practical applications. For instance, consider a self-driving car: the vehicle may easily detect common objects or events, e.g., pedestrians walking on the sidewalk. However, children playing soccer on the street is a rare event that can occur in the real world, and it is important to evaluate autonomous systems on such rare but crucial events. Thus, although rare events are infrequent, classifiers still need to account for them. Consequently, average accuracy on a long-tailed dataset is not an adequate measure of performance across rare classes.
+
+An alternative approach using long-tailed testing sets is to evaluate per-class accuracy. This explicitly weights all classes – both in the head and tail – equally. However, this has the drawback that performance estimates of rare classes in the tail have high variability and can be unreliable. In the autonomous vehicle scenario above, we might encounter very few (or even no) examples of children playing street soccer in any finite testset. This means that performance estimates fort tail classes can be unreliable.
+
+We propose an evaluation approach that addresses the bias towards the head and intra-class variation of classes in the tail. The proposed evaluation protocol requires a training and an evaluation procedure. The training setting includes several training trials that used different versions of long-tailed training sets. The evaluation procedure uses a balanced dataset. The use of a balanced testing set addresses the issue of classifiers that are biased towards the head since the class-priors are uniform and both classes in the head and tail contribute to the performance measure. Training a classifier using different long-tailed sets accounts for intra-class variation for classes in the tail. Consequently, aggregates of performance from these different trials account for the intra-class variation noise from classes in the tail. The experiments report a per-class accuracy average, the average class-accuracy, and their standard deviations over three different trails.
+
+Because the considered datasets are balanced, the experiments “long-tailed” these datasets following the procedure proposed by Wang et al. (2017). For every class, the procedure computed the number of samples to draw from the balanced set using an exponential distribution. Thus, as the class index grows, the number of training instances decreases according to the exponential distribution. Given the computed number of samples to draw, the procedure randomly selects these instances from the balanced set to generate a training long-tailed dataset version. Fig. 3 shows a visualization of the training-instance distribution of the resultant long-tailed datasets. The experiments used the balanced testing sets because the goal is to measure generalization and overall performance.
+
+# 4.2 PERFORMANCE ON LONG-TAILED DATASETS
+
+The goal of this experiment is to evaluate the learned embedding using a long-tailed dataset. To do so, the experiments used the long-tailed datasets described above. In particular, the target is to measure any classification improvement for classes in the tail with respect to the regular softmax classifier. Since most of the baselines rely on class-centroids to classify, the experiments use a nearest-class-mean (Mensink et al., 2013) classifier. Thus, the experiments computed the deepfeatures for the training and testing sets after learning the feature encoder $f _ { w } ( \cdot )$ ; a deep feature is the output of $f _ { w } ( \cdot )$ which is the input tensor to the classifier or softmax layer. Then, the experiments computed a class centroid using the long-tailed training set for every method.
+
+![](images/696dbac649133647dbfaa21c3422527d3f197a60b304f84a44f8345d043cce28.jpg)  
+Figure 4: Left column: Relative classification accuracy gain of the competing and proposed methods with respect to a softmax classifier using long-tailed datasets. Overall, the proposed method tends to achieve a comparable accuracy to that of a softmax classifier while delivering an increase for tail classes. Right column: The performance of a softmax classifier. The performance for classes in the head is higher than that of the classes in the tail.
+
+To measure the classification improvements, the experiments trained all the methods with three different long-tailed datasets and used the balanced testing sets. Then, the experiment computed an average class-accuracy from the three trials for every baseline. To measure the relative performance with respect to a softmax classifier, the experiment computed the ratio between the average classaccuracy of a competing method (i.e., iCaRL (Rebuffi et al., 2017), center loss (Wen et al., 2016), and the proposed method) and the average class-accuracy of a softmax classifier; the softmax classifier is the reference because it tends to bias towards classes in the head (Wang et al., 2017).
+
+Table 1: Average relative performance with respect to a softmax classifier for classes in the head (H column) and tail (T column); the relative performance is the ratio between the class accuracies of a competing method and a softmax classifier. The proposed method increases the performance on classes in the tail while maintaining a comparable performance to that of a softmax classifier for classes in the head. Bold numbers indicate the highest performance per dataset in each row.   
+
+<table><tr><td rowspan="2">Datasets</td><td rowspan="2">iCarl [Unorm] H</td><td rowspan="2">T</td><td rowspan="2">H</td><td rowspan="2">iCarl [Norm] T</td><td rowspan="2">Center loss H</td><td rowspan="2">T</td><td colspan="2">Proposed</td></tr><tr><td>H</td><td>T</td></tr><tr><td>MNIST</td><td>0.98</td><td>1.00</td><td>0.99</td><td>1.01</td><td>0.99</td><td>1.00</td><td>0.99</td><td>1.01</td></tr><tr><td>CIFAR 10</td><td>0.95</td><td>2.22</td><td>0.95</td><td>2.22</td><td>0.92</td><td>1.8</td><td>0.98</td><td>2.44</td></tr><tr><td>CIFAR 100</td><td>0.72</td><td>0.80</td><td>0.83</td><td>0.90</td><td>0.71</td><td>0.66</td><td>0.96</td><td>1.04</td></tr><tr><td>Tiny ImageNet</td><td>0.86</td><td>1.07</td><td>0.95</td><td>1.06</td><td>0.76</td><td>0.8</td><td>0.97</td><td>1.12</td></tr></table>
+
+Fig. 4 shows the results of this experiment on small- and medium-scale datasets in the first two rows and last two rows, respectively. The Figure shows the relative performance for all the classes in a dataset in the left column, the class accuracy of a softmax classifier on the right column, and the average class-accuracy of the compared methods in the labels. All the plots in the left column show a black solid line indicating the performance of a softmax classifier. Thus, a decrement falls below the line while an increment raises above the line.
+
+The results on the MNIST dataset (first row) show that most of the competing methods perform comparable to that of a softmax classifier. However, the GMM method underperforms for classes in the tail. For this dataset, a softmax classifier does not present a significant bias towards classes in the head. Thus, these results indicate that the competing and proposed methods, with the exception of the GMM, operate well given a dataset with minor visual variations (e.g., illumination variations, pose, occlusion, among others). Consequently, these results effectively work as a sanity check of the proposed and competing methods (i.e., iCaRl and Centerloss). The results on CIFAR 10 (second row) show that the proposed approach and competing methods tend to perform comparable to a softmax classifier for classes in the head (i.e., the first three classes). In addition, the results show that the GMM also underperforms for classes in the tail. However, the proposed approach and competing methods tend to increase relative performance for classes in the tail. In this dataset, the proposed approach achieved an average class-accuracy of $68 \%$ , which is the highest compared to all the methods.
+
+The plots in the third row show the results on CIFAR 100. The plot in the left shows that the proposed method achieves a comparable performance with respect to a softmax classifier for classes in the head (i.e., the first twenty classes). On the other hand, the competing methods have a larger decrease in accuracy for classes in the head. The GMM in this dataset again underperforms for classes in the tail. The plot in the left shows that the proposed approach tends to increase the relative performance for classes in the tail. Overall, they tend to be larger than those of the competing methods and a softmax classifier. Lastly, the plot at the bottom shows the results on Tiny ImageNet. The plot in the left shows similar observations. The proposed approach maintains a comparable performance with respect to a softmax classifier for classes in the head. However, it delivers an increase in relative performance for classes in the tail. The GMM approach suffers for classes in the tail because the covariance estimates are poor due to the lack of data.
+
+To highlight the previous observations, Table 1 shows a break down of the average relative performance for classes in the head (H column) and in the tail (T column); this experiment excludes the GMM approach. To measure an average relative performance for classes in the head, the experiments used a weighted average of the relative performance considering all the classes. The average used the fraction of instances for a given class in the training set as its corresponding weight. Specifically, the weight for the $i$ -th class is $\begin{array} { r } { w _ { i } = { \frac { n _ { i } } { n } } } \\ { \qquad \mathbf { \cdots } \qquad } \end{array}$ , where $n _ { i }$ is the number of training instances for the $i$ -th class and $n$ is the total number of training instances in the long-tailed training set. Thus, this average emphasizes the relative performance of classes with abundant training instances while decreasing the contribution of the classes with scarce training data. To compute a weighted average of the relative performance for classes in the tail, the experiment calculated the weight $w _ { i } ^ { \prime }$ for the $i$ -th class as follows: $\begin{array} { r } { w _ { i } ^ { \prime } = \frac { 1 - w _ { i } } { \sum _ { i } 1 - w _ { i } } } \end{array}$ These weights emphasize the relative performance of the classes in the tail while diminishing the relative performance of classes in the head. The results in Table 1 show that the proposed method maintains a comparable peformance for classes in the head with respect to a softmax classifier. At the same time, the proposed method consistently improves the performance for classes in the tail.
+
+Table 2: Classification performance improvement by using the regularizer in the proposed approach on CIFAR 10. The proposed approach with regularizer achieves a higher classification accuracy than the approach without the regularizer.   
+
+<table><tr><td rowspan="2">Configuration</td><td colspan="10">Class Index</td><td rowspan="2">Avg. Acc.</td></tr><tr><td>1</td><td>2</td><td>3</td><td>4</td><td>5</td><td>6</td><td>7</td><td>8</td><td>9</td><td>10</td></tr><tr><td>w/regularizer</td><td>81</td><td>85</td><td>68</td><td>62</td><td>67</td><td>58</td><td>70</td><td>61</td><td>65</td><td>68</td><td>68</td></tr><tr><td>w/o regularizer</td><td>72</td><td>72</td><td>57</td><td>63</td><td>65</td><td>55</td><td>67</td><td>63</td><td>68</td><td>58</td><td>64</td></tr></table>
+
+![](images/2d8f2a40598e5cf35e43968af729b45f30c97d6162de793775d9693763a43076.jpg)  
+Figure 5: Accuracy increase achieved by using the proposed regularizer on CIFAR 100. Overall, the proposed approach with regularizer tends to increase the accuracy across all classes compared to the proposed approach without one.
+
+# 4.3 EFFECT OF THE CENTROIDS REGULARIZER
+
+The goal of this experiment is to measure the benefits of the regularizer in the proposed method. To do so, this experiment compared the proposed method with a hyperparemeter $\lambda = 0$ , leaving only the Bayesian classifier, and the configuration tested in the previous Section. Note that this setting is equivalent to only using a linear classifier with restricted bias, according to the discussion in Sec. 3.2. This experiment only considered CIFAR 10 and 100, and tested performance also considering three different long-tailed training sets for each dataset.
+
+The results of this experiment on CIFAR 10 are shown in Table 2. The table shows the average accuracies per class for the proposed method using a regularizer with $\lambda = 0 . 0 0 1$ (top row), and without a regularizer (bottom row). The last column of the table shows the average classification performance. This table shows that the regularizer overall improves classification performance. This is expected since the regularizer aims to retain the centroid-parameters that are as close as possible to the batch-sample-mean centroids.
+
+Fig. 5 presents the results of this experiment on CIFAR 100. The plot shows the accuracy gains obtained by comparing the accuracies of the proposed method using a regularizer with $\lambda = 0 . 0 0 0 1$ across all classes. Also, the plot shows the average accuracies for both methods. The plot indicates that the regularizer consistently provides an accuracy increase across classes. Thus, the regularizer is an important component that overall improves the classification performance.
+
+# 5 CONCLUSION
+
+This work introduced a method that improves the classification performance for classes in the tail. The proposed approach is based on a Gaussian mixture model that allows a Bayesian classifier to represent the distribution of a long-tailed dataset and to compute the class-prediction probabilities. The experiments on publicly available dataset show that the proposed approach tends to increase the classification accuracy for classes in the tail while maintaining a comparable accuracy to that of a softmax classifier for classes in the head. In addition, this work introduced an evaluation method for methods that tackle the learning of concepts from a long-tailed dataset. Finally, this work demonstrated that class-centroid approaches overall tend to generalize well for classes in the tail while maintaining a comparable performance to that of a softmax classifiers for classes in the head.
+
+# REFERENCES
+
+Pulkit Agrawal, Ross Girshick, and Jitendra Malik. Analyzing the performance of multilayer neural networks for object recognition. In European conference on computer vision, pp. 329–344. Springer, 2014.
+
+Christopher M Bishop. Pattern recognition and machine learning. springer, 2006.
+
+Stephen Boyd and Lieven Vandenberghe. Convex optimization. Cambridge university press, 2004.
+
+J. Deng, W. Dong, R. Socher, L.-J. Li, K. Li, and L. Fei-Fei. ImageNet: A Large-Scale Hierarchical Image Database. In Proc. of the IEEE Conf. on Computer Vision and Pattern Recognition (CVPR), 2009.
+
+Venice Erin Liong, Jiwen Lu, Gang Wang, Pierre Moulin, and Jie Zhou. Deep hashing for compact binary codes learning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2475–2483, 2015.
+
+Gregory Griffin, Alex Holub, and Pietro Perona. Caltech-256 object category dataset, 2007.
+
+Bharath Hariharan and Ross Girshick. Low-shot visual recognition by shrinking and hallucinating features. In Proc. of the IEEE International Conf. on Computer Vision (ICCV), October 2017.
+
+Haibo He and Edwardo A Garcia. Learning from imbalanced data. IEEE Trans. on Knowledge and Data Engineering, 21(9):1263–1284, 2009.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proc. of the IEEE Conf. on Computer Vision and Pattern Recognition (CVPR), June 2016.
+
+Chen Huang, Yining Li, Chen Change Loy, and Xiaoou Tang. Learning deep representation for imbalanced classification. In Proc. of the IEEE Conf. Computer Vision and Pattern Recognition (CVPR), June 2016.
+
+Gao Huang, Zhuang Liu, Laurens van der Maaten, and Kilian Q Weinberger. Densely connected convolutional networks. In Proc. of the IEEE Conf. on Computer Vision and Pattern Recognition (CVPR), 2017.
+
+Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. CoRR, abs/1412.6980, 2014.
+
+Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In Advances in Neural Information Processing Systems (NIPS). 2012.
+
+Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.
+
+Tsung-Yi Lin, Michael Maire, Serge Belongie, James Hays, Pietro Perona, Deva Ramanan, Piotr Dollar, and C Lawrence Zitnick. Microsoft coco: Common objects in context. In ´ European Conference on Computer Vision, pp. 740–755. Springer, 2014.
+
+Thomas Mensink, Jakob Verbeek, Florent Perronnin, and Gabriela Csurka. Distance-based image classification: Generalizing to new classes at near-zero cost. IEEE Transactions on Pattern Analysis and Machine Intelligence, 35(11):2624–2637, 2013.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Alex Graves, Ioannis Antonoglou, Daan Wierstra, and Martin A. Riedmiller. Playing atari with deep reinforcement learning. CoRR, abs/1312.5602, 2013.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, 2015.
+
+Sameer A. Nene, Shree K. Nayar, and Hiroshi Murase. Columbia object image library (coil-20. Technical report, 1996.
+
+Ankit B Patel, Minh Tan Nguyen, and Richard Baraniuk. A probabilistic framework for deep learning. In Advances in Neural Information Processing Systems (NIPS), pp. 2558–2566. 2016.
+
+Ariadna Quattoni and Antonio Torralba. Recognizing indoor scenes. In Proc of the IEEE Conf. on Computer Vision and Pattern Recognition (CVPR), 2009.
+
+Sylvestre-Alvise Rebuffi, Alexander Kolesnikov, Georg Sperl, and Christoph H. Lampert. iCaRL: Incremental Classifier and Representation Learning. In Proc. of the IEEE Conf. on Computer Vision and Pattern Recognition (CVPR), July 2017.
+
+Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, Alexander C. Berg, and Li FeiFei. Imagenet large scale visual recognition challenge. Int. J. Comput. Vision (IJCV), 115(3): 211–252, December 2015.
+
+Ruslan Salakhutdinov, Antonio Torralba, and Josh Tenenbaum. Learning to share visual appearance for multiclass object detection. In Proc. of the IEEE Conf. on Computer Vision and Pattern Recognition (CVPR), 2011.
+
+K. Simonyan and A. Zisserman. Very deep convolutional networks for large-scale image recognition. In Proc. of the International Conference on Learning Representations (ICLR), 2015.
+
+J. Snell, K. Swersky, and R. S. Zemel. Prototypical Networks for Few-shot Learning. In Advances in Neural Information Processing Systems (NIPS). 2017.
+
+Nicholas D Socci, Daniel D Lee, and H Sebastian Seung. The rectified gaussian distribution. In Advances in neural information processing systems, pp. 350–356, 1998.
+
+Jost Tobias Springenberg, Alexey Dosovitskiy, Thomas Brox, and Martin Riedmiller. Striving for simplicity: The all convolutional net. arXiv preprint arXiv:1412.6806, 2014.
+
+Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. In Proc. of the IEEE Conf. on Computer Vision and Pattern Recognition (CVPR), June 2015.
+
+Jozef L Teugels. Some representations of the multivariate bernoulli and binomial distributions. Journal of multivariate analysis, 32(2):256–268, 1990.
+
+Aaron van den Oord and Benjamin Schrauwen. Factoring variations in natural images with deep gaussian mixture models. In Advances in Neural Information Processing Systems (NIPS), pp. 3518–3526. 2014.
+
+Grant Van Horn and Pietro Perona. The devil is in the tails: Fine-grained classification in the wild. arXiv preprint arXiv:1709.01450, 2017.
+
+Yu-Xiong Wang and Martial Hebert. Learning from Small Sample Sets by Combining Unsupervised Meta-Training with CNNs. In Advances in Neural Information Processing Systems (NIPS). 2016.
+
+Yu-Xiong Wang, Deva Ramanan, and Martial Hebert. Learning To Model the Tail. In Advances in Neural Information Processing Systems (NIPS). 2017.
+
+Yandong Wen, Kaipeng Zhang, Zhifeng Li, and Yu Qiao. A discriminative feature learning approach for deep face recognition. In Proc. of the European Conference on Computer Vision (ECCV), pp. 499–515. Springer, 2016.
+
+Xiangxin Zhu, Dragomir Anguelov, and Deva Ramanan. Capturing long-tail distributions of object subcategories. In Proc. of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2014.
+
+Xiangxin Zhu, Carl Vondrick, Charless C. Fowlkes, and Deva Ramanan. Do we need more training data? International Journal of Computer Vision (IJCV), 119(1):76–92, Aug 2016.
+
+# A HYPERPARAMETERS AND IMPLEMENTATION DETAILS
+
+In order to guarantee similar training conditions for all the methods, the experiments used the same framework parameters (e.g., number of steps, learning rate, decay factors, among others) for all the considered methods.
+
+All the tested methods used an Adam optimizer (Kingma & Ba, 2014) and a batch size of 32. The experiments used a learning rate of 0.01 and 0.1 for the small- and medium-scale datasets, respectively. The experiments used the default exponential-learning-rate decay, weight decay, and drop-out parameters provided in TensorFlow Models. The hyperparameters used for center-loss are 0.5 for the centroids learning rate and a scale value of 0.001 for MNIST and CIFAR 10, 0.0001 for CIFAR 100 and Tiny ImageNet the proposed method. The hyperparameter for the proposed approach was set to 0.001 for MNIST and CIFAR 10, and 0.0001 for CIFAR 100 and Tiny ImageNet.

parse/train/Bk9nkMa4G/Bk9nkMa4G_content_list.json

@@ -0,0 +1,1402 @@
+[
+    {
+        "type": "text",
+        "text": "BAYESIAN EMBEDDINGS FOR LONG-TAILED DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            823,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            170,
+            400,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The statistics of the real visual world presents a long-tailed distribution: a few classes have significantly more training instances than the remaining classes in a dataset. This is because the real visual world has a few classes that are common while others are rare. Unfortunately, the performance of a convolutional neural network is typically unsatisfactory when trained using a long-tailed dataset. To alleviate this issue, we propose a method that discriminatively learns an embedding in which a simple Bayesian classifier can balance the class-priors to generalize well for rare classes. To this end, the proposed approach uses a Gaussian mixture model to factor out class-likelihoods and class-priors in a long-tailed dataset. The proposed method is simple and easy-to-implement in existing deep learning frameworks. Experiments on publicly available datasets show that the proposed approach improves the performance on classes with few training instances, while maintaining a comparable performance to the state-of-the-art on classes with abundant training examples. ",
+        "bbox": [
+            233,
+            263,
+            764,
+            458
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            482,
+            336,
+            498
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep convolutional neural networks (CNN) have achieved impressive results in large-scale visual recognition tasks (Krizhevsky et al., 2012; Simonyan & Zisserman, 2015; Szegedy et al., 2015; Mnih et al., 2015; 2013; He et al., 2016; Huang et al., 2017). However, despite the significant impact in visual perception, the vast majority of these advancements learn from artificially balanced largescale datasets that are not representative of the real visual world (Nene et al., 1996; Griffin et al., 2007; Deng et al., 2009; Quattoni & Torralba, 2009; Lin et al., 2014; Russakovsky et al., 2015). The statistics of the real visual world follow a long-tailed distribution (Zhu et al., 2014; 2016; Van Horn & Perona, 2017; Salakhutdinov et al., 2011; Wang & Hebert, 2016; Wang et al., 2017). This means that a few classes are predominant in the world while others are rare. Consequently, representative real-world datasets have a few classes with significantly more training instances than the remaining classes in the set; see Fig. 1(a) for an illustration of a long-tailed dataset. We refer to classes with abundant training instances as classes in the head, and unrepresented classes as classes in the tail. ",
+        "bbox": [
+            174,
+            512,
+            825,
+            679
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "As Van Horn & Perona (2017) note, the main motivation for visual recognition is to understand and learn from the real visual world. Thus, while the state-of-the-art can challenge humans in visual recognition tasks, it misses a mechanism that effectively learns from long-tailed datasets. As Van Horn & Perona (2017) found, training models using long-tailed datasets often leads to unsatisfying performance. This is because classifiers tend to generalize well for classes in the head, but lack generalization for classes in the tail. ",
+        "bbox": [
+            174,
+            686,
+            825,
+            770
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To alleviate this issue, learned classifiers need to generalize for classes in the tail while maintaining a good performance for all the classes. Recent efforts that aim to learn from long-tailed datasets consider penalities in the optimization-learning problem (Huang et al., 2016), sampling-based methods (He & Garcia, 2009), and transfer-learning algorithms (Wang & Hebert, 2016; Wang et al., 2017). In contrast with these solutions, the proposed method aims to learn an embedding in which the distribution of the real visual world allows a simple Bayesian classifier to predict robustly given a long-tailed dataset. ",
+        "bbox": [
+            174,
+            777,
+            823,
+            875
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Long-tailed datasets have class-prior statistics that heavily skew towards classes in the head. This skew can bias classifiers towards classes in the head, and consequently can reduce generalization for classes in the tail. To remove this skew, we appeal to Bayesian classifiers that can explicitly factor out the likelihood and prior when computing posteriors over class labels. Thus, the main goal of this work is to learn a feature embedding in which class prior statistics do not affect/skew class likelihoods. The proposed approach uses a simple Gaussian mixture model (GMM) to describe the statistics of a long-tailed dataset. This is because it enables a clean factorization of the class-likelihoods and class-priors. Moreover, it easily fits within an empirical Bayesian classification framework, because a GMM enables the computation of closed-form maximum likelihood estimation (MLE) of class-specific means, covariance matrices, and priors. We show that such closed-form estimates can be integrated into existing deep learning optimizers without much effort. By fixing the covariance matrices of all the classes to be the identity and the priors over each class to be uniform, we can explicitly enforce that both rare classes in the tail and dominant classes in the head have equal weight for Bayesian classification. In simple terms: we learn a discriminative embedding of training data such that Bayesian classifiers with balanced priors produce accurate class posteriors. As a point of clarity, the proposed approach does not learn an embedding in the traditional Bayesian sense, which might define a prior distribution over embeddings that is then combined with training data to produce a posterior embedding. Rather, it learns a single embedding that is discriminatively trained to produce accurate features for Bayesian classifiers. See Fig. 1 for an illustration about the proposed approach. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/1d2129a3dbac2fa15d2af3f0eb09c915cc1c4fc9698fffe6985a1f92708b292b.jpg",
+        "image_caption": [
+            "Figure 1: (a) The real visual world yields long-tailed datasets. Classes in the head are common (e.g., cats) while classes in the tail are rare (e.g., white reindeers). (b) The proposed approach builds a generative (Bayesian) classifier over a learned embedding to compute class-posterior probabilities. In an empirical Bayesian framework, posteriors are computed through class likelihoods and priors fit to the data (e.g., sample means, variances, and counts assuming Gaussian Mixture Models). We introduce an end-to-end pipeline for jointly learning embeddings and Bayesian models built upon them. (c) Bayesian models are particularly well-suited for long-tailed datasets because class priors and likelihoods can be fixed to be uniform and isotropic, ensuring that the learned representation is balanced across the head and tail. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            108,
+            825,
+            200
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            358,
+            825,
+            594
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A GMM not only is useful for learning an embedding using a long-tailed dataset, but also provides flexibility at the evaluation stage. This is because it enables the measurement of generalization for classes in the tail by simply setting equal class-prior probabilities. In addition, it enables the possibility of giving more importance to the most frequent classes by adjusting their respective class-prior probabilities. ",
+        "bbox": [
+            174,
+            601,
+            825,
+            671
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In sum, the proposed approach aims to learn an embedding in which a GMM enables a Bayesian classifier to generalize well for classes in the tail by balancing out class-priors. The proposed method is simple, easy-to-train using deep learning frameworks, and increases classification performance for classes in the tail. The experiments on publicly available datasets show that this approach tends to perform better on classes in the tail than the competing methods, while performing comparable to the state-of-the-art on classes with abundant training instances. ",
+        "bbox": [
+            174,
+            678,
+            825,
+            762
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            779,
+            343,
+            795
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The main challenges for learning models using long-tailed datasets comprise learning parameters that generalize from a few-shots and avoiding classifier bias. While the proposed approach aims to tackle these two problems simultaneously, methods that tackle each of these problems independently are still relevant. As such, this section not only covers prior work on learning using imbalanced datasets, but also covers relevant solutions for few-shot learning. Given that the proposed approach is based on a GMM model, this section also covers recent approaches that use class-centroid representations for incremental learning and for improving discriminative properties. ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 LEARNING FROM LONG-TAILED DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            104,
+            511,
+            117
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Simple techniques that deal with imbalanced datasets use random sampling to artificially create a more balanced training set (He & Garcia, 2009). For instance, random oversampling effectively “repeats” training instances from the classes in the tail, while random undersampling “removes” instances from the classes with abundant training instances. Thus, these techniques address imbalanced datasets by means of artificially balancing the training set. An alternative approach to deal with long-tailed datasets use transfer learning techniques. Wang et al. (2017) proposed MetaModelNet, a meta-learning algorithm that learns the evolution of parameters when gradually including more training samples. MetaModelNet improves the performance of CNN models since it transfers the parameter-evolution knowledge from data-rich classes to categories in the tail. Rather than artificially modifying the training set or use transfer learning, the proposed approach aims to learn an embedding that allows classifiers to generalize when learning from a long-tailed dataset. Consequently, the proposed method can complement sampling or transfer-learning-based methods. ",
+        "bbox": [
+            174,
+            131,
+            825,
+            297
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 FEW-SHOT LEARNING AND CLASS-CENTROID-BASED REPRESENTATIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            318,
+            725,
+            332
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Recent approaches in this category aim to learn good parameters from a few training instances (Snell et al., 2017; Hariharan & Girshick, 2017). A recent approach that considers an imbalanced dataset to tackle few-shot learning is the work by Hariharan & Girshick (2017). Their proposed approach learns a feature embedding from the classes with the most samples in the dataset. Then, the approach “hallucinates” samples for classes with a few training instances in the learned embedding. While this work learns from an imabalanced dataset, it considers a different setting that that of the proposed approach. The work by Hariharan & Girshick (2017) assumes that classes with few instances are added incrementally. The proposed approach differs in this regard, since the introduced method aims to learn the embedding using the entire long-tailed dataset, generalize, and avoid any bias towards the classes with abundant training instances. ",
+        "bbox": [
+            174,
+            345,
+            825,
+            484
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To achieve generalization given a few shots in an incremental learning context, Rebuffi et al. (2017) proposed iCaRL, a deep-learning-based incremental classifier. Similarly to the proposed approach, iCaRL represents each class using a single centroid in an embedding learned using a regular CNN model. However, instead of using the learned softmax classifier, it uses a nearestclass-mean (Mensink et al., 2013) classifier. Unlike iCaRL that uses features from a learned CNNsoftmax model, the proposed approach learns an embedding using a generative model. It is worth noting that the proposed approach uses a GMM, which by default includes a nearest-class-mean classifier as part of the learning problem. The use of class-centroids in learning representations is also useful to improve discriminative properties. Wen et al. (2016) proposed a loss that aims to minimize intra-class variation in CNN-softmax models. Unlike the center-loss approach, the proposed method minimizes the intra-class variation automatically by finding the GMM parameters in the learned embedding. Different from the center-loss that requires a mechanism to estimate the class-centroids, the proposed approach uses back-propagation to learn the GMM parameters. A recent approach that aims to generalize by using class-centroid representations are the Prototypical Networks (proto-nets) by Snell et al. (2017). Proto-nets estimate the class centroids from a slice of a mini-batch-like subset of the training set. Then, they evaluate the loss from the complementary slice of the mini-batch-like subset, and update the feature encoder weights. The proposed approach has two main differences with proto-nets. First, the proposed approach is based on generative models describing the statistics of an imbalanced dataset, rather than learning an embedding tailored for a nearest-class-mean classifier that requires specific parameter-update rules. Second, the proposed approach uses regular batching mechanisms and updates parameters using back-propagation. Thus, in constrast with proto-nets, the proposed approach avoids modifying components in the deep learning frameworks. ",
+        "bbox": [
+            174,
+            491,
+            825,
+            809
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 BAYESIAN EMBEDDINGS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            834,
+            411,
+            851
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The goal of this work is to learn an embedding that allows a simple Bayesian classifier to robustly operate given a long-tailed training dataset. Specifically, this work aims to learn an encoder $f _ { w } ( \\cdot )$ , parameterized by its set of weights $w$ , that produces a good representation for Bayesian classification given a long-tailed dataset. ",
+        "bbox": [
+            176,
+            867,
+            823,
+            922
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In order to learn the aforementioned encoder, the proposed approach requires a model that describes the distribution of the data. Let $x = f _ { w } ( I )$ be the encoded feature for image $I$ and $y$ be its corresponding class label. Thus, the distribution of the training set can be described with the following joint probability: ",
+        "bbox": [
+            173,
+            103,
+            825,
+            159
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7e7755a1a2e9a02175afa7ed526f973ba8a21c1ecf67fbb71f340ba3a455b5d0.jpg",
+        "text": "$$\n\\begin{array} { r l } & { p ( x , y ) = p ( x \\mid y ) p ( y ) } \\\\ & { \\qquad = p ( f _ { w } ( I ) \\mid y ; \\theta _ { y } ) \\pi _ { y } } \\\\ & { \\qquad = p ( x , y ; \\ w , \\theta ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            398,
+            156,
+            598,
+            212
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $p ( f _ { w } ( I ) \\mid y ; \\theta _ { y } )$ represents the likelihood of observing the feature vector $x$ as part of class $y$ , and $\\pi _ { y }$ is the prior probabilities for class $y$ . The likelihood is a function with parameters $\\theta _ { y }$ (e.g., parameters of a multivariate Gaussian) that describes the distribution of the feature vectors in the embedding. Thus, the joint probability of the data $p ( x , y ; ~ w , \\theta )$ is a function with parameters composed by the the encoder $w$ parameters, and the Bayesian parameters $\\theta$ which include the likelihood parameters $\\theta _ { y }$ , and priors $\\pi _ { y }$ . In practice, the likelihood parameters proves most crucial as it is not sensitive to class priors, which can be misleading in the long-tailed setting (as discussed in Section 3.1). ",
+        "bbox": [
+            173,
+            212,
+            825,
+            324
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Given the above joint probability model, the posterior probability for class $y$ given a feature vector $x$ can be computed using Bayes rule as follows: ",
+        "bbox": [
+            176,
+            330,
+            821,
+            358
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1806c576b02c37fd902c4b49a288604d601658cf015f11290c6b0c60fa9afafb.jpg",
+        "text": "$$\np ( y \\mid x ; \\boldsymbol { w } , \\boldsymbol { \\theta } ) = \\frac { p ( f _ { w } ( I ) \\mid y ; \\theta _ { y } ) \\pi _ { y } } { \\sum _ { k } p ( f _ { w } ( I ) \\mid k ; \\theta _ { k } ) \\pi _ { k } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            359,
+            362,
+            637,
+            397
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\theta$ is a concatenation of the likelihood parameters and priors of all the classes. Thus, the class posterior probability is a function that depends on the encoder parameters $w$ and the Bayesian parameters $\\theta$ . ",
+        "bbox": [
+            176,
+            401,
+            823,
+            443
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The overall objective of this work is to jointly learn the weights $w$ of the feature encoder and the Bayesian parameters $\\theta$ to guarantee a good classification performance. Given a training dataset of images and label pairs $\\mathcal { D } = \\{ ( x _ { i } , y _ { i } ) \\}$ , we propose to learn parameters by maximizing the Bayesian class-posterior probability of the true class labels: ",
+        "bbox": [
+            173,
+            449,
+            825,
+            506
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2b4c2f1a5b3c96066d8bc7d8a23c3538c5f48208ad94621899edcbc58875c193.jpg",
+        "text": "$$\n\\operatorname* { m i n i m i z e } _ { \\boldsymbol { w } } \\sum _ { i } - \\log p ( \\boldsymbol { y } _ { i } \\mid \\boldsymbol { x } _ { i } ; \\boldsymbol { w } , \\boldsymbol { \\theta } ) \\qquad \\mathrm { s u b j e c t ~ t o } \\qquad \\boldsymbol { \\theta } = \\mathbf { M L E } ( \\mathcal { D } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            267,
+            510,
+            725,
+            542
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where MLE is a function that computes the closed form maximum likelihood estimates of the parameters of our Bayesian model, a procedure commonly known as Empirical Bayes (Bishop, 2006). ",
+        "bbox": [
+            174,
+            546,
+            825,
+            575
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To use existing solvers for learning deep networks, we reformulate the problem shown in Eq. (3) as an unconstrained optimization by using a Lagrangian penalty (Boyd & Vandenberghe, 2004) that penalizes solutions which violate the constraint: ",
+        "bbox": [
+            174,
+            582,
+            825,
+            623
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c71f538dff5d633d2fb1ea6b5553229aa31b36d7361466936bee3f471f0d6998.jpg",
+        "text": "$$\n\\operatorname* { m i n i m i z e } _ { \\boldsymbol { w } , \\boldsymbol { \\theta } } \\quad \\sum _ { i } - \\log p ( y _ { i } \\mid \\boldsymbol { x } _ { i } ; \\boldsymbol { w } , \\boldsymbol { \\theta } ) + \\lambda \\| \\boldsymbol { \\theta } - \\mathbf { M } \\mathbf { L } \\mathbf { E } ( \\mathcal { D } ) \\| ^ { 2 } \\quad ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            290,
+            627,
+            705,
+            661
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\lambda \\geq 0$ . In this formulation, the optimization explicitly searches over the feature encoder parameters $w$ and the Bayesian parameters $\\theta$ so as to maximize class posterior probabilities. The last term penalizes deviations of the $\\theta$ parameters from their MLE estimates, effectively acting as a regularizer. ",
+        "bbox": [
+            173,
+            665,
+            825,
+            720
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 GMM EMBEDDINGS FOR HEAVILY TAILED DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            736,
+            589,
+            752
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "GMMs: The likelihood models are crucial to determine the parameters that allows the proposed approach to learn the feature encoder given a long-tailed dataset. We propose to use a multivariate Gaussian probability density function as the likelihood model. Given this likelihood model, the proposed approach implicitly uses a Gaussian mixture model to represent the distribution of the training set. Using a multivariate Gaussian brings benefits to the proposed formulation. This is because its parameters (the centroid $\\mu$ , covariance matrix $\\Sigma$ , and prior $\\pi$ ) have an intuitive meaning and closed-form-maximum-likelihood estimators. Interestingly, as discussed by van den Oord & Schrauwen (2014) and Patel et al. (2016), a mixture of multivariate Gaussians can be used to theoretically motivate the success of deep learning. ",
+        "bbox": [
+            173,
+            762,
+            825,
+            888
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Balancing: The use of a GMM not only brings simplicity into the formulation, but also allows the feature encoder to generalize better for classes in the tail. The generalization aspect of a GMM model comes from the fact that a class is described with a single centroid. The benefit of this class representation is that estimating the centroid with a handful of examples is simple and produces a good estimate. Perhaps more importantly, a GMM allows us to access specific parameters that control the probabilistic “footprint” of each class in the embedded space. We can set these parameters to ensure balanced footprints by fixing the covariance matrices to be the identity and the class priors to be uniform - see Fig. 1-(c). The remaining parameters to be estimated are then the class means $\\boldsymbol { \\mu } = ( \\mu _ { 1 } , \\dots , \\mu _ { n _ { c } } )$ . Given this setting and considering that deep-learning frameworks use mini batches, the unconstrained problem shown in Eq. (4) becomes: ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/91335f7e72779fdebb18a37fd60ffe71643340e092071ef8efcdf04d035d7840.jpg",
+        "image_caption": [
+            "Figure 2: We compare the effect of gradient-based updates for a traditional softmax classifier versus our Bayesian embedding model. Recall that our approach learns an embedding for which Bayesian classifiers produce accurate class posteriors. During softmax training, an “easy” example of a class will tend to not generate a strong gradient update, and so is not useful for learning (left). This might be considered paradoxical: when children learn a new concept (for say, a never-before-seen animal), an easy or “protypical” example might be most informative for learning. On the other hand, in our framework, an easy example of a class will change its centroid, generating a strong signal for updating our learned representation (right). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            299,
+            102,
+            691,
+            222
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            359,
+            825,
+            472
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c3a7cea735edb20a8cb8b3c0bda96a1590ef3f95e24822f93503e918818936c6.jpg",
+        "text": "$$\n\\underset { w , \\mu } { \\mathrm { n i m i z e } } \\quad \\frac { 1 } { m } \\sum _ { i = 1 } ^ { m } - \\log \\left( \\frac { \\exp \\left( - \\frac { 1 } { 2 } \\| f _ { w } ( I _ { i } ) - \\mu _ { y _ { i } } \\| ^ { 2 } \\right) } { \\sum _ { k } \\exp \\left( - \\frac { 1 } { 2 } \\| f _ { w } ( I _ { i } ) - \\mu _ { k } \\| ^ { 2 } \\right) } \\right) + \\lambda \\sum _ { j \\in \\mathcal { M } } \\| \\mu _ { j } - \\frac { 1 } { n _ { j } } \\sum _ { i ^ { \\prime } : y _ { i ^ { \\prime } } = j } f _ { w } ( I _ { i ^ { \\prime } } ) \\| ^ { 2 } \\quad ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            477,
+            834,
+            522
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $y _ { i }$ is the true class label/index for the $i$ -th data point, $m$ is the batch size, $\\mathcal { M }$ is the set of class indices in the batch, $n _ { j }$ is the number of samples of the $j$ -th class in the batch, and $i ^ { \\prime }$ is the index running over instances in the batch. ",
+        "bbox": [
+            174,
+            532,
+            823,
+            575
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            592,
+            302,
+            607
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Other probabilistic models: Our analysis and experiments focus on Gaussian Mixture Models, but the general learning problem from Eq. (4) holds for other probabilistic models. For example, deep embeddings can be learned for rectified (nonnegative) or binary features (Agrawal et al., 2014; Erin Liong et al., 2015). For such embeddings, likelihood models based on rectified Gaussians or multivariate Bernoulli distributions may be more appropriate Socci et al. (1998); Teugels (1990). Such models do not appear to have closed form maximum likelihood estimates, and so may be challenging to formulate precisely as a constrained optimization problem. ",
+        "bbox": [
+            173,
+            618,
+            825,
+            717
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Relationship to softmax: The GMM-based formulation has a direct relationship with softmax classifiers. This relationship can be obtained by expanding the squared distance terms in the classposterior probability, yielding the following: ",
+        "bbox": [
+            176,
+            722,
+            823,
+            765
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/50b0a44c8fb92ad24e3b16b3a459c2363ece227cccf0380cc9badf5ac110015c.jpg",
+        "text": "$$\n\\begin{array} { r l } & { p \\left( y _ { i } \\mid f _ { w } ( I _ { i } ) ; \\boldsymbol { w } , \\mu \\right) = \\frac { \\exp \\big ( - \\frac { 1 } { 2 } \\| f _ { w } ( I _ { i } ) - \\mu _ { j } \\| ^ { 2 } \\big ) } { \\sum _ { k } \\exp \\big ( - \\frac { 1 } { 2 } \\| f _ { w } ( I _ { i } ) - \\mu _ { k } \\| ^ { 2 } \\big ) } } \\\\ & { \\qquad = \\frac { \\exp \\big ( \\mu _ { j } ^ { T } f _ { w } ( I _ { i } ) - \\frac { 1 } { 2 } \\big ( \\| f _ { w } ( I _ { i } ) \\| ^ { 2 } + \\| \\mu _ { j } \\| ^ { 2 } \\big ) \\big ) } { \\sum _ { k } \\exp \\big ( \\mu _ { k } ^ { T } f _ { w } ( I _ { i } ) - \\frac { 1 } { 2 } \\big ( \\| f _ { w } ( I _ { i } ) \\| ^ { 2 } + \\| \\mu _ { k } \\| ^ { 2 } \\big ) \\big ) } , } \\\\ & { \\qquad = \\frac { \\exp \\big ( v _ { j } ^ { T } f _ { w } ( I _ { i } ) + b _ { j } \\big ) } { \\sum _ { k } \\exp \\big ( v _ { k } ^ { T } f _ { w } ( I _ { i } ) + b _ { k } \\big ) } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            258,
+            771,
+            736,
+            891
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $v _ { j } = \\mu _ { j }$ and $b _ { j } = - { \\textstyle \\frac { 1 } { 2 } } \\| v _ { j } \\| ^ { 2 }$ , since $- \\frac { 1 } { 2 } \\| f _ { w } ( I _ { i } ) \\| ^ { 2 }$ is a common term between the numerator and denominator. This relationship thus indicates that the proposed approach fits linear classifiers with restricted biases. This relationship is useful for an easy implementation in many deep learning frameworks. This is because this approach can be implemented using a dense layer without the bias terms. In addition, this relationship shows that the proposed approach requires fewer parametersto-learn in comparison with classical CNN-softmax models. An more intuitive comparison between GMMs and softmax classifiers can be made with respect to to their parameter updates. Intuitively, during softmax training, an “easy” example of a class will not generate a model update. In some sense, this might be considered paradoxical. When children learn a new concept (for say, a neverbefore-seen animal), they tend to be presented with an easy or “protypical” example. On the other hand, an easy example of a class will change its centroid, generating a signal for learning - see Fig. 2. ",
+        "bbox": [
+            173,
+            893,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            229
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            236,
+            328,
+            251
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "This section presents a series of experiments evaluating the learned embedding computed using the proposed method and long-tailed datasets. Since the goal of the experiments is to evaluate the feature encoder, all the experiments trained all the baselines or competing methods and the proposed one from scratch. An additional goal of the experiments is to show that the proposed approach can be adapted to any CNN architecture. For this reason, the experiments also used legacy and recent CNN architectures. ",
+        "bbox": [
+            174,
+            253,
+            825,
+            337
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Datasets: One evaluation aspect of the experiments is to measure the performance on smalland medium-scale datasets. The experiments included MNIST (LeCun et al., 1998) and CIFAR 10 (Krizhevsky & Hinton, 2009) as the small-scale datasets (each with ten classes); and CIFAR 100 (Krizhevsky & Hinton, 2009) and Tiny ImageNet 1 as the medium-scale datasets (with hundred and two hundred classes, respectively). The balanced MNIST dataset contains 60,000 and 10,000 $2 8 \\mathbf { x } 2 8$ training and testing images depicting hand-written digits, respectively. The CIFAR 10 dataset contains 50,000 and $1 0 , 0 0 0 3 2 \\mathrm { x } 3 2$ training and testing images, respectively. The CIFAR 100 dataset contains 500 and $1 0 0 \\ 3 2 \\mathrm { x } \\lambda 2$ training and testing images per class, respectively. Lastly, Tiny ImageNet has 500 and 50 64x64 training and testing images for every class, respectively. However, the experiments used a $2 2 4 \\mathbf { x } 2 2 4$ image instead. See Sec. 4.1 for details on how the experiments processed these datasets to evaluate classifiers using long-tailed datasets. ",
+        "bbox": [
+            174,
+            353,
+            825,
+            506
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Baselines: The experiments included recent approaches that deal with imbalanced datasets. These approaches include iCaRL (Rebuffi et al., 2017), center loss (Wen et al., 2016), and a plain softmax classifier. The experiments also consider a variation of iCaRL. This variation does not use normalized feature vectors as originally proposed by Rebuffi et al. (2017). While prototypical networks (Snell et al., 2017) are similar to the proposed approach, they require a balanced dataset with a few training instances for every class. Since prototypical networks do not assume a long-tailed dataset, these experiments did not include it as a competing method. The experiment also considered a method that uses a full GMM model (i.e., full covariance, means, and priors) of a softmax representation of the training set. As discussed in Sec. 2, MetaModelNet (Wang et al., 2017) deals with long-tailed datasets by operating at the classifier-parameter level, since it is a meta-learning algorithm. Thus, MetaModelNet does not learn an embedding, and consequently complements the proposed method. ",
+        "bbox": [
+            174,
+            522,
+            825,
+            688
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Implementation Details: All the experiments were implemented on top of TensorFlow Models $( \\mathrm { T F M } ) ^ { 2 }$ . This open-source project implements various legacy architectures, and several preprocessing imaging techniques (e.g., random translations and shifts). The experiments used the following CNN architectures: LeNet (LeCun et al., 1998) for MNIST; CifarNet (Krizhevsky & Hinton, 2009) for CIFAR 10; AllCNN (Springenberg et al., 2014) for CIFAR 100; and VGG 16 (Simonyan & Zisserman, 2015) for Tiny ImageNet. We implemented center loss (Wen et al., 2016) and verified correctness using a balanced setting. We implemented the proposed approach in TFM using a fully connected layer with a restrictive bias. This is possible thanks to the relationship with linear classifiers discussed in Sec. 3.2. The regularizer was implemented using plain Tensorflow operations and was added as a regularizer function for the fully connected layer with restrictive bias. We will release the code upon publication. The hyperparameters for center-loss and the proposed approach were estimated using a validation set for every dataset. See Sec. A in the Appendix for the specific parameters. ",
+        "bbox": [
+            173,
+            704,
+            825,
+            883
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/04550cb04c486edb38153b88e185b99d5ab24c22f5da6dd192fc128774d55a5b.jpg",
+        "image_caption": [
+            "Figure 3: Histogram of the number of training instances per class in the long-tailed datasets. From left to right, the datasets are MNIST, CIFAR 10, CIFAR 100, and Tiny ImageNet. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            102,
+            821,
+            170
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.1 EVALUATION FOR LONG-TAILED DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            212,
+            517,
+            227
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The main motivation of this work is to learn from a realistic dataset representing the statistics of the real visual world. Recall that realistic datasets are long-tailed since the visual world has a few predominant classes while others are rare. As such, the performance evaluation of the visual recognition system in this setting needs to be discussed, since common evaluation methods may not be adequate given this context. ",
+        "bbox": [
+            174,
+            238,
+            825,
+            308
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Intuitively, since the visual world yields long-tailed datasets, then the test set should ideally be long-tailed as well. While this rationale is logical given the statistics of the world, it has a main drawback: a simple classifier that is biased towards classes in the head is likely to perform well using a long-tailed testing set. While this setting may reflect a good performance for the common classes in practice, achieving a good performance for classes in the tail is still desirable in real practical applications. For instance, consider a self-driving car: the vehicle may easily detect common objects or events, e.g., pedestrians walking on the sidewalk. However, children playing soccer on the street is a rare event that can occur in the real world, and it is important to evaluate autonomous systems on such rare but crucial events. Thus, although rare events are infrequent, classifiers still need to account for them. Consequently, average accuracy on a long-tailed dataset is not an adequate measure of performance across rare classes. ",
+        "bbox": [
+            174,
+            315,
+            825,
+            468
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "An alternative approach using long-tailed testing sets is to evaluate per-class accuracy. This explicitly weights all classes – both in the head and tail – equally. However, this has the drawback that performance estimates of rare classes in the tail have high variability and can be unreliable. In the autonomous vehicle scenario above, we might encounter very few (or even no) examples of children playing street soccer in any finite testset. This means that performance estimates fort tail classes can be unreliable. ",
+        "bbox": [
+            174,
+            474,
+            825,
+            559
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We propose an evaluation approach that addresses the bias towards the head and intra-class variation of classes in the tail. The proposed evaluation protocol requires a training and an evaluation procedure. The training setting includes several training trials that used different versions of long-tailed training sets. The evaluation procedure uses a balanced dataset. The use of a balanced testing set addresses the issue of classifiers that are biased towards the head since the class-priors are uniform and both classes in the head and tail contribute to the performance measure. Training a classifier using different long-tailed sets accounts for intra-class variation for classes in the tail. Consequently, aggregates of performance from these different trials account for the intra-class variation noise from classes in the tail. The experiments report a per-class accuracy average, the average class-accuracy, and their standard deviations over three different trails. ",
+        "bbox": [
+            174,
+            565,
+            825,
+            704
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Because the considered datasets are balanced, the experiments “long-tailed” these datasets following the procedure proposed by Wang et al. (2017). For every class, the procedure computed the number of samples to draw from the balanced set using an exponential distribution. Thus, as the class index grows, the number of training instances decreases according to the exponential distribution. Given the computed number of samples to draw, the procedure randomly selects these instances from the balanced set to generate a training long-tailed dataset version. Fig. 3 shows a visualization of the training-instance distribution of the resultant long-tailed datasets. The experiments used the balanced testing sets because the goal is to measure generalization and overall performance. ",
+        "bbox": [
+            174,
+            712,
+            825,
+            823
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 PERFORMANCE ON LONG-TAILED DATASETS",
+        "text_level": 1,
+        "bbox": [
+            178,
+            840,
+            524,
+            856
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The goal of this experiment is to evaluate the learned embedding using a long-tailed dataset. To do so, the experiments used the long-tailed datasets described above. In particular, the target is to measure any classification improvement for classes in the tail with respect to the regular softmax classifier. Since most of the baselines rely on class-centroids to classify, the experiments use a nearest-class-mean (Mensink et al., 2013) classifier. Thus, the experiments computed the deepfeatures for the training and testing sets after learning the feature encoder $f _ { w } ( \\cdot )$ ; a deep feature is the output of $f _ { w } ( \\cdot )$ which is the input tensor to the classifier or softmax layer. Then, the experiments computed a class centroid using the long-tailed training set for every method. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            922
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/696dbac649133647dbfaa21c3422527d3f197a60b304f84a44f8345d043cce28.jpg",
+        "image_caption": [
+            "Figure 4: Left column: Relative classification accuracy gain of the competing and proposed methods with respect to a softmax classifier using long-tailed datasets. Overall, the proposed method tends to achieve a comparable accuracy to that of a softmax classifier while delivering an increase for tail classes. Right column: The performance of a softmax classifier. The performance for classes in the head is higher than that of the classes in the tail. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            98,
+            820,
+            700
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            790,
+            823,
+            847
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To measure the classification improvements, the experiments trained all the methods with three different long-tailed datasets and used the balanced testing sets. Then, the experiment computed an average class-accuracy from the three trials for every baseline. To measure the relative performance with respect to a softmax classifier, the experiment computed the ratio between the average classaccuracy of a competing method (i.e., iCaRL (Rebuffi et al., 2017), center loss (Wen et al., 2016), and the proposed method) and the average class-accuracy of a softmax classifier; the softmax classifier is the reference because it tends to bias towards classes in the head (Wang et al., 2017). ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/f15737100b2934a598eb272df160e86877bbd816356e5b4018a14f1c087f578f.jpg",
+        "table_caption": [
+            "Table 1: Average relative performance with respect to a softmax classifier for classes in the head (H column) and tail (T column); the relative performance is the ratio between the class accuracies of a competing method and a softmax classifier. The proposed method increases the performance on classes in the tail while maintaining a comparable performance to that of a softmax classifier for classes in the head. Bold numbers indicate the highest performance per dataset in each row. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Datasets</td><td rowspan=\"2\">iCarl [Unorm] H</td><td rowspan=\"2\">T</td><td rowspan=\"2\">H</td><td rowspan=\"2\">iCarl [Norm] T</td><td rowspan=\"2\">Center loss H</td><td rowspan=\"2\">T</td><td colspan=\"2\">Proposed</td></tr><tr><td>H</td><td>T</td></tr><tr><td>MNIST</td><td>0.98</td><td>1.00</td><td>0.99</td><td>1.01</td><td>0.99</td><td>1.00</td><td>0.99</td><td>1.01</td></tr><tr><td>CIFAR 10</td><td>0.95</td><td>2.22</td><td>0.95</td><td>2.22</td><td>0.92</td><td>1.8</td><td>0.98</td><td>2.44</td></tr><tr><td>CIFAR 100</td><td>0.72</td><td>0.80</td><td>0.83</td><td>0.90</td><td>0.71</td><td>0.66</td><td>0.96</td><td>1.04</td></tr><tr><td>Tiny ImageNet</td><td>0.86</td><td>1.07</td><td>0.95</td><td>1.06</td><td>0.76</td><td>0.8</td><td>0.97</td><td>1.12</td></tr></table>",
+        "bbox": [
+            248,
+            183,
+            741,
+            261
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            280,
+            823,
+            308
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Fig. 4 shows the results of this experiment on small- and medium-scale datasets in the first two rows and last two rows, respectively. The Figure shows the relative performance for all the classes in a dataset in the left column, the class accuracy of a softmax classifier on the right column, and the average class-accuracy of the compared methods in the labels. All the plots in the left column show a black solid line indicating the performance of a softmax classifier. Thus, a decrement falls below the line while an increment raises above the line. ",
+        "bbox": [
+            173,
+            314,
+            825,
+            397
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The results on the MNIST dataset (first row) show that most of the competing methods perform comparable to that of a softmax classifier. However, the GMM method underperforms for classes in the tail. For this dataset, a softmax classifier does not present a significant bias towards classes in the head. Thus, these results indicate that the competing and proposed methods, with the exception of the GMM, operate well given a dataset with minor visual variations (e.g., illumination variations, pose, occlusion, among others). Consequently, these results effectively work as a sanity check of the proposed and competing methods (i.e., iCaRl and Centerloss). The results on CIFAR 10 (second row) show that the proposed approach and competing methods tend to perform comparable to a softmax classifier for classes in the head (i.e., the first three classes). In addition, the results show that the GMM also underperforms for classes in the tail. However, the proposed approach and competing methods tend to increase relative performance for classes in the tail. In this dataset, the proposed approach achieved an average class-accuracy of $68 \\%$ , which is the highest compared to all the methods. ",
+        "bbox": [
+            174,
+            405,
+            825,
+            585
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The plots in the third row show the results on CIFAR 100. The plot in the left shows that the proposed method achieves a comparable performance with respect to a softmax classifier for classes in the head (i.e., the first twenty classes). On the other hand, the competing methods have a larger decrease in accuracy for classes in the head. The GMM in this dataset again underperforms for classes in the tail. The plot in the left shows that the proposed approach tends to increase the relative performance for classes in the tail. Overall, they tend to be larger than those of the competing methods and a softmax classifier. Lastly, the plot at the bottom shows the results on Tiny ImageNet. The plot in the left shows similar observations. The proposed approach maintains a comparable performance with respect to a softmax classifier for classes in the head. However, it delivers an increase in relative performance for classes in the tail. The GMM approach suffers for classes in the tail because the covariance estimates are poor due to the lack of data. ",
+        "bbox": [
+            174,
+            592,
+            825,
+            746
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "To highlight the previous observations, Table 1 shows a break down of the average relative performance for classes in the head (H column) and in the tail (T column); this experiment excludes the GMM approach. To measure an average relative performance for classes in the head, the experiments used a weighted average of the relative performance considering all the classes. The average used the fraction of instances for a given class in the training set as its corresponding weight. Specifically, the weight for the $i$ -th class is $\\begin{array} { r } { w _ { i } = { \\frac { n _ { i } } { n } } } \\\\ { \\qquad \\mathbf { \\cdots } \\qquad } \\end{array}$ , where $n _ { i }$ is the number of training instances for the $i$ -th class and $n$ is the total number of training instances in the long-tailed training set. Thus, this average emphasizes the relative performance of classes with abundant training instances while decreasing the contribution of the classes with scarce training data. To compute a weighted average of the relative performance for classes in the tail, the experiment calculated the weight $w _ { i } ^ { \\prime }$ for the $i$ -th class as follows: $\\begin{array} { r } { w _ { i } ^ { \\prime } = \\frac { 1 - w _ { i } } { \\sum _ { i } 1 - w _ { i } } } \\end{array}$ These weights emphasize the relative performance of the classes in the tail while diminishing the relative performance of classes in the head. The results in Table 1 show that the proposed method maintains a comparable peformance for classes in the head with respect to a softmax classifier. At the same time, the proposed method consistently improves the performance for classes in the tail. ",
+        "bbox": [
+            173,
+            752,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/3294334cc4c853edb6a7d75bb60f3974a69b9bd3936370cc303b3cc4599edbb7.jpg",
+        "table_caption": [
+            "Table 2: Classification performance improvement by using the regularizer in the proposed approach on CIFAR 10. The proposed approach with regularizer achieves a higher classification accuracy than the approach without the regularizer. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Configuration</td><td colspan=\"10\">Class Index</td><td rowspan=\"2\">Avg. Acc.</td></tr><tr><td>1</td><td>2</td><td>3</td><td>4</td><td>5</td><td>6</td><td>7</td><td>8</td><td>9</td><td>10</td></tr><tr><td>w/regularizer</td><td>81</td><td>85</td><td>68</td><td>62</td><td>67</td><td>58</td><td>70</td><td>61</td><td>65</td><td>68</td><td>68</td></tr><tr><td>w/o regularizer</td><td>72</td><td>72</td><td>57</td><td>63</td><td>65</td><td>55</td><td>67</td><td>63</td><td>68</td><td>58</td><td>64</td></tr></table>",
+        "bbox": [
+            246,
+            156,
+            750,
+            210
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/2d8f2a40598e5cf35e43968af729b45f30c97d6162de793775d9693763a43076.jpg",
+        "image_caption": [
+            "Figure 5: Accuracy increase achieved by using the proposed regularizer on CIFAR 100. Overall, the proposed approach with regularizer tends to increase the accuracy across all classes compared to the proposed approach without one. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            294,
+            226,
+            691,
+            390
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            450,
+            826,
+            493
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "4.3 EFFECT OF THE CENTROIDS REGULARIZER ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            515,
+            514,
+            529
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The goal of this experiment is to measure the benefits of the regularizer in the proposed method. To do so, this experiment compared the proposed method with a hyperparemeter $\\lambda = 0$ , leaving only the Bayesian classifier, and the configuration tested in the previous Section. Note that this setting is equivalent to only using a linear classifier with restricted bias, according to the discussion in Sec. 3.2. This experiment only considered CIFAR 10 and 100, and tested performance also considering three different long-tailed training sets for each dataset. ",
+        "bbox": [
+            174,
+            531,
+            825,
+            614
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The results of this experiment on CIFAR 10 are shown in Table 2. The table shows the average accuracies per class for the proposed method using a regularizer with $\\lambda = 0 . 0 0 1$ (top row), and without a regularizer (bottom row). The last column of the table shows the average classification performance. This table shows that the regularizer overall improves classification performance. This is expected since the regularizer aims to retain the centroid-parameters that are as close as possible to the batch-sample-mean centroids. ",
+        "bbox": [
+            174,
+            621,
+            825,
+            705
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Fig. 5 presents the results of this experiment on CIFAR 100. The plot shows the accuracy gains obtained by comparing the accuracies of the proposed method using a regularizer with $\\lambda = 0 . 0 0 0 1$ across all classes. Also, the plot shows the average accuracies for both methods. The plot indicates that the regularizer consistently provides an accuracy increase across classes. Thus, the regularizer is an important component that overall improves the classification performance. ",
+        "bbox": [
+            174,
+            712,
+            825,
+            782
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            792,
+            318,
+            808
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This work introduced a method that improves the classification performance for classes in the tail. The proposed approach is based on a Gaussian mixture model that allows a Bayesian classifier to represent the distribution of a long-tailed dataset and to compute the class-prediction probabilities. The experiments on publicly available dataset show that the proposed approach tends to increase the classification accuracy for classes in the tail while maintaining a comparable accuracy to that of a softmax classifier for classes in the head. In addition, this work introduced an evaluation method for methods that tackle the learning of concepts from a long-tailed dataset. Finally, this work demonstrated that class-centroid approaches overall tend to generalize well for classes in the tail while maintaining a comparable performance to that of a softmax classifiers for classes in the head. ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            154,
+            287,
+            167
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Pulkit Agrawal, Ross Girshick, and Jitendra Malik. Analyzing the performance of multilayer neural networks for object recognition. In European conference on computer vision, pp. 329–344. Springer, 2014. ",
+        "bbox": [
+            176,
+            176,
+            823,
+            218
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Christopher M Bishop. Pattern recognition and machine learning. springer, 2006. ",
+        "bbox": [
+            174,
+            228,
+            710,
+            243
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Stephen Boyd and Lieven Vandenberghe. Convex optimization. Cambridge university press, 2004. ",
+        "bbox": [
+            171,
+            252,
+            816,
+            268
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "J. Deng, W. Dong, R. Socher, L.-J. Li, K. Li, and L. Fei-Fei. ImageNet: A Large-Scale Hierarchical Image Database. In Proc. of the IEEE Conf. on Computer Vision and Pattern Recognition (CVPR), 2009. ",
+        "bbox": [
+            173,
+            276,
+            823,
+            319
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Venice Erin Liong, Jiwen Lu, Gang Wang, Pierre Moulin, and Jie Zhou. Deep hashing for compact binary codes learning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2475–2483, 2015. ",
+        "bbox": [
+            176,
+            329,
+            825,
+            372
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Gregory Griffin, Alex Holub, and Pietro Perona. Caltech-256 object category dataset, 2007. ",
+        "bbox": [
+            171,
+            381,
+            774,
+            397
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Bharath Hariharan and Ross Girshick. Low-shot visual recognition by shrinking and hallucinating features. In Proc. of the IEEE International Conf. on Computer Vision (ICCV), October 2017. ",
+        "bbox": [
+            173,
+            405,
+            823,
+            435
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Haibo He and Edwardo A Garcia. Learning from imbalanced data. IEEE Trans. on Knowledge and Data Engineering, 21(9):1263–1284, 2009. ",
+        "bbox": [
+            171,
+            443,
+            823,
+            473
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proc. of the IEEE Conf. on Computer Vision and Pattern Recognition (CVPR), June 2016. ",
+        "bbox": [
+            174,
+            481,
+            825,
+            523
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chen Huang, Yining Li, Chen Change Loy, and Xiaoou Tang. Learning deep representation for imbalanced classification. In Proc. of the IEEE Conf. Computer Vision and Pattern Recognition (CVPR), June 2016. ",
+        "bbox": [
+            174,
+            534,
+            825,
+            577
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Gao Huang, Zhuang Liu, Laurens van der Maaten, and Kilian Q Weinberger. Densely connected convolutional networks. In Proc. of the IEEE Conf. on Computer Vision and Pattern Recognition (CVPR), 2017. ",
+        "bbox": [
+            173,
+            585,
+            825,
+            628
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. CoRR, abs/1412.6980, 2014. ",
+        "bbox": [
+            173,
+            638,
+            823,
+            666
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009. ",
+        "bbox": [
+            174,
+            676,
+            821,
+            693
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In Advances in Neural Information Processing Systems (NIPS). 2012. ",
+        "bbox": [
+            174,
+            700,
+            823,
+            729
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998. ",
+        "bbox": [
+            171,
+            738,
+            823,
+            768
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tsung-Yi Lin, Michael Maire, Serge Belongie, James Hays, Pietro Perona, Deva Ramanan, Piotr Dollar, and C Lawrence Zitnick. Microsoft coco: Common objects in context. In ´ European Conference on Computer Vision, pp. 740–755. Springer, 2014. ",
+        "bbox": [
+            176,
+            776,
+            825,
+            820
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Thomas Mensink, Jakob Verbeek, Florent Perronnin, and Gabriela Csurka. Distance-based image classification: Generalizing to new classes at near-zero cost. IEEE Transactions on Pattern Analysis and Machine Intelligence, 35(11):2624–2637, 2013. ",
+        "bbox": [
+            176,
+            829,
+            823,
+            872
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Alex Graves, Ioannis Antonoglou, Daan Wierstra, and Martin A. Riedmiller. Playing atari with deep reinforcement learning. CoRR, abs/1312.5602, 2013. ",
+        "bbox": [
+            176,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, 2015. ",
+        "bbox": [
+            176,
+            103,
+            820,
+            146
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sameer A. Nene, Shree K. Nayar, and Hiroshi Murase. Columbia object image library (coil-20. Technical report, 1996. ",
+        "bbox": [
+            173,
+            154,
+            821,
+            183
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ankit B Patel, Minh Tan Nguyen, and Richard Baraniuk. A probabilistic framework for deep learning. In Advances in Neural Information Processing Systems (NIPS), pp. 2558–2566. 2016. ",
+        "bbox": [
+            173,
+            190,
+            821,
+            220
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ariadna Quattoni and Antonio Torralba. Recognizing indoor scenes. In Proc of the IEEE Conf. on Computer Vision and Pattern Recognition (CVPR), 2009. ",
+        "bbox": [
+            171,
+            228,
+            825,
+            257
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sylvestre-Alvise Rebuffi, Alexander Kolesnikov, Georg Sperl, and Christoph H. Lampert. iCaRL: Incremental Classifier and Representation Learning. In Proc. of the IEEE Conf. on Computer Vision and Pattern Recognition (CVPR), July 2017. ",
+        "bbox": [
+            176,
+            265,
+            825,
+            309
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, Alexander C. Berg, and Li FeiFei. Imagenet large scale visual recognition challenge. Int. J. Comput. Vision (IJCV), 115(3): 211–252, December 2015. ",
+        "bbox": [
+            173,
+            315,
+            825,
+            372
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ruslan Salakhutdinov, Antonio Torralba, and Josh Tenenbaum. Learning to share visual appearance for multiclass object detection. In Proc. of the IEEE Conf. on Computer Vision and Pattern Recognition (CVPR), 2011. ",
+        "bbox": [
+            174,
+            381,
+            823,
+            424
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "K. Simonyan and A. Zisserman. Very deep convolutional networks for large-scale image recognition. In Proc. of the International Conference on Learning Representations (ICLR), 2015. ",
+        "bbox": [
+            174,
+            431,
+            820,
+            462
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "J. Snell, K. Swersky, and R. S. Zemel. Prototypical Networks for Few-shot Learning. In Advances in Neural Information Processing Systems (NIPS). 2017. ",
+        "bbox": [
+            174,
+            468,
+            821,
+            498
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Nicholas D Socci, Daniel D Lee, and H Sebastian Seung. The rectified gaussian distribution. In Advances in neural information processing systems, pp. 350–356, 1998. ",
+        "bbox": [
+            174,
+            506,
+            823,
+            536
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jost Tobias Springenberg, Alexey Dosovitskiy, Thomas Brox, and Martin Riedmiller. Striving for simplicity: The all convolutional net. arXiv preprint arXiv:1412.6806, 2014. ",
+        "bbox": [
+            171,
+            542,
+            823,
+            571
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. In Proc. of the IEEE Conf. on Computer Vision and Pattern Recognition (CVPR), June 2015. ",
+        "bbox": [
+            176,
+            579,
+            823,
+            623
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jozef L Teugels. Some representations of the multivariate bernoulli and binomial distributions. Journal of multivariate analysis, 32(2):256–268, 1990. ",
+        "bbox": [
+            169,
+            631,
+            821,
+            660
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Aaron van den Oord and Benjamin Schrauwen. Factoring variations in natural images with deep gaussian mixture models. In Advances in Neural Information Processing Systems (NIPS), pp. 3518–3526. 2014. ",
+        "bbox": [
+            173,
+            667,
+            823,
+            710
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Grant Van Horn and Pietro Perona. The devil is in the tails: Fine-grained classification in the wild. arXiv preprint arXiv:1709.01450, 2017. ",
+        "bbox": [
+            169,
+            718,
+            821,
+            747
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yu-Xiong Wang and Martial Hebert. Learning from Small Sample Sets by Combining Unsupervised Meta-Training with CNNs. In Advances in Neural Information Processing Systems (NIPS). 2016. ",
+        "bbox": [
+            174,
+            756,
+            821,
+            785
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yu-Xiong Wang, Deva Ramanan, and Martial Hebert. Learning To Model the Tail. In Advances in Neural Information Processing Systems (NIPS). 2017. ",
+        "bbox": [
+            171,
+            792,
+            823,
+            821
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yandong Wen, Kaipeng Zhang, Zhifeng Li, and Yu Qiao. A discriminative feature learning approach for deep face recognition. In Proc. of the European Conference on Computer Vision (ECCV), pp. 499–515. Springer, 2016. ",
+        "bbox": [
+            176,
+            830,
+            823,
+            873
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Xiangxin Zhu, Dragomir Anguelov, and Deva Ramanan. Capturing long-tail distributions of object subcategories. In Proc. of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2014. ",
+        "bbox": [
+            174,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Xiangxin Zhu, Carl Vondrick, Charless C. Fowlkes, and Deva Ramanan. Do we need more training data? International Journal of Computer Vision (IJCV), 119(1):76–92, Aug 2016. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A HYPERPARAMETERS AND IMPLEMENTATION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            159,
+            656,
+            174
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In order to guarantee similar training conditions for all the methods, the experiments used the same framework parameters (e.g., number of steps, learning rate, decay factors, among others) for all the considered methods. ",
+        "bbox": [
+            178,
+            189,
+            823,
+            232
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "All the tested methods used an Adam optimizer (Kingma & Ba, 2014) and a batch size of 32. The experiments used a learning rate of 0.01 and 0.1 for the small- and medium-scale datasets, respectively. The experiments used the default exponential-learning-rate decay, weight decay, and drop-out parameters provided in TensorFlow Models. The hyperparameters used for center-loss are 0.5 for the centroids learning rate and a scale value of 0.001 for MNIST and CIFAR 10, 0.0001 for CIFAR 100 and Tiny ImageNet the proposed method. The hyperparameter for the proposed approach was set to 0.001 for MNIST and CIFAR 10, and 0.0001 for CIFAR 100 and Tiny ImageNet. ",
+        "bbox": [
+            174,
+            238,
+            825,
+            337
+        ],
+        "page_idx": 12
+    }
+]

parse/train/HkGzUjR5tQ/HkGzUjR5tQ.md

@@ -0,0 +1,290 @@
+# DATNET: DUAL ADVERSARIAL TRANSFER FOR LOWRESOURCE NAMED ENTITY RECOGNITION
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+We propose a new architecture termed Dual Adversarial Transfer Network (DATNet) for addressing low-resource Named Entity Recognition (NER). Specifically, two variants of DATNet, i.e., DATNet-F and DATNet-P, are proposed to explore effective feature fusion between high and low resource. To address the noisy and imbalanced training data, we propose a novel Generalized ResourceAdversarial Discriminator (GRAD). Additionally, adversarial training is adopted to boost model generalization. We examine the effects of different components in DATNet across domains and languages, and show that significant improvement can be obtained especially for low-resource data. Without augmenting any additional hand-crafted features, we achieve new state-of-the-art performances on CoNLL and Twitter NER— $8 8 . 1 6 \%$ F1 for Spanish, $5 3 . 4 3 \%$ F1 for WNUT-2016, and $4 2 . 8 3 \%$ F1 for WNUT- $2 0 1 7 ^ { 1 }$ .
+
+# 1 INTRODUCTION
+
+Named entity recognition (NER) is an important step in most natural language processing (NLP) applications. It detects not only the type of named entity, but also the entity boundaries, which requires deep understanding of the contextual semantics to disambiguate the different entity types of same tokens. To tackle this challenging problem, most early studies were based on hand-crafted rules, which suffered from limited performance in practice. Current methods are devoted to developing learning based algorithms, especially neural network based methods, and have been advancing the state-of-the-art consecutively (Collobert et al., 2011; Huang et al., 2015; Lample et al., 2016; Chiu & Nichols, 2016; Ma & Hovy, 2016). These end-to-end models generalize well on new entities based on features automatically learned from the data. However, when the annotated corpora is small, especially in the low resource scenario (Zhang et al., 2016), the performance of these methods degrades significantly since the hidden feature representations cannot be learned adequately.
+
+Recently, more and more approaches have been proposed to address low-resource NER. Early works (Chen et al., 2010; Li et al., 2012) primarily assumed a large parallel corpus and focused on exploiting them to project information from high- to low-resource. Unfortunately, such a large parallel corpus may not be available for many low-resource languages. More recently, cross-resource word embedding (Fang & Cohn, 2017; Adams et al., 2017; Yang et al., 2017) was proposed to bridge the low and high resources and enable knowledge transfer. Although the aforementioned transferbased methods show promising performance in low-resource NER, there are two issues deserved to be further investigated on: 1) Representation Difference - they did not consider the representation difference across resources and enforced the feature representation to be shared across languages/domains; 2) Resource Data Imbalance - the training size of high-resource is usually much larger than that of low-resource. The existing methods neglect such difference in their models, resulting in poor generalization.
+
+In this work, we present an approach termed Dual Adversarial Transfer Network (DATNet) to address the above issues in a unified framework for low-resource NER. Specifically, to handle the representation difference, we first investigate on two architectures of hidden layers (we use bidirectional long-short term memory (BiLSTM) model as hidden layer) for transfer. The first one is that all the units in hidden layers are common units shared across languages/domains. The second one is composed of both private and common units, where the private part preserves the independent language/domain information. Extensive experiments are conducted to show their advantages over each other in different situations. On top of common units, the adversarial discriminator (AD) loss is introduced to encourage the resource-agnostic representation so that the knowledge from high resource can be more compatible with low resource. To handle the resource data imbalance issue, we further propose a variant of the AD loss, termed Generalized Resource-Adversarial Discriminator (GRAD), to impose the resource weight during training so that low-resource and hard samples can be paid more attention to. In addition, we create adversarial samples to conduct the Adversarial Training (AT), further improving the generalization and alleviating over-fitting problem. We unify two kinds of adversarial learning, i.e., GRAD and AT, into one transfer learning model, termed Dual Adversarial Transfer Network (DATNet), to achieve end-to-end training and obtain the state-of-the-art performance on a series of NER tasks– $8 8 . 1 6 \%$ F1 for CoNLL-2002 Spanish, $5 3 . 4 3 \%$ and $4 2 . 8 3 \%$ F1 for WNUT-2016 and 2017. Different from prior works, we do not use additional hand-crafted features and do not use cross-lingual word embeddings while addressing the cross-language tasks.
+
+# 2 RELATED WORK
+
+Named Entity Recognition NER is typically framed as a sequence labeling task which aims at automatic detection of named entities (e.g., person, organization, location and etc.) from free text (Marrero et al., 2013). The early works applied CRF, SVM, and perception models with handcrafted features (Ratinov & Roth, 2009; Passos et al., 2014; Luo et al., 2015). With the advent of deep learning, research focus has been shifting towards deep neural networks (DNN), which requires little feature engineering and domain knowledge (Lample et al., 2016; Zukov Gregoric et al., 2018). Collobert et al. (2011) proposed a feed-forward neural network with a fixed sized window for each word, which failed in considering useful relations between long-distance words. To overcome this limitation, Chiu & Nichols (2016) presented a bidirectional LSTM-CNNs architecture that automatically detects word- and character-level features. Ma & Hovy (2016) further extended it into bidirectional LSTM-CNNs-CRF architecture, where the CRF module was added to optimize the output label sequence. Liu et al. (2018) proposed task-aware neural language model termed LMLSTM-CRF, where character-aware neural language models were incorporated to extract characterlevel embedding under a multi-task framework.
+
+Transfer Learning for NER Transfer learning can be a powerful tool to low resource NER tasks. To bridge high and low resource, transfer learning methods for NER can be divided into two types: the parallel corpora based transfer and the shared representation based transfer. Early works mainly focused on exploiting parallel corpora to project information between the high- and low-resource language (Yarowsky et al., 2001; Chen et al., 2010; Li et al., 2012; Feng et al., 2018). For example, Chen et al. (2010) and Feng et al. (2018) proposed to jointly identify and align bilingual named entities. On the other hand, the shared representation methods do not require the parallel correspondence (Rei & Søgaard, 2018). For instance, Fang & Cohn (2017) proposed cross-lingual word embeddings to transfer knowledge across resources. Yang et al. (2017) presented a transfer learning approach based on a deep hierarchical recurrent neural network (RNN), where full/partial hidden features between source and target tasks are shared. Ni et al. (Ni & Florian, 2016; Ni et al., 2017) utilized the Wikipedia entity type mappings to improve low-resource NER. Al-Rfou’ et al. (2015) built massive multilingual annotators with minimal human expertise by using language agnostic techniques. Mayhew et al. (2017) created a cross-language NER system, which works well for very minimal resources by translate annotated data of high-resource into low-resource. Cotterell & Duh (2017) proposed character-level neural CRFs to jointly train and predict low- and high-resource languages. Pan et al. (2017) proposes a large-scale cross-lingual named entity dataset which contains 282 languages for evaluation. In addition, multi-task learning (Yang et al., 2016; Luong et al., 2016; Rei, 2017; Aguilar et al., 2017; Hashimoto et al., 2017; Lin et al., 2018) shows that jointly training on multiple tasks/languages helps improve performance. Different from transfer learning methods, multi-task learning aims at improving the performance of all the resources instead of low resource only.
+
+Adversarial Learning Adversarial learning originates from Generative Adversarial Nets (GAN) (Goodfellow et al., 2014), which shows impressing results in computer vision. Recently, many papers have tried to apply adversarial learning to NLP tasks. Liu et al. (2017) presented an adversarial multi-task learning framework for text classification. Gui et al. (2017) applied the adversarial discriminator to POS tagging for Twitter. Kim et al. (2017) proposed a language discriminator to enable language-adversarial training for cross-language POS tagging. Apart from adversarial discriminator, adversarial training is another concept originally introduced by (Szegedy et al., 2014; Goodfellow et al., 2015) to improve the robustness of image classification model by injecting malicious perturbations into input images. Recently, Miyato et al. (2017) proposed a semi-supervised text classification method by applying adversarial training, where for the first time adversarial perturbations were added onto word embeddings. Yasunaga et al. (2018) applied adversarial training to POS tagging. Different from all these adversarial learning methods, our method integrates both the adversarial discriminator and adversarial training in an unified framework to enable end-to-end training.
+
+# 3 DUAL ADVERSARIAL TRANSFER NETWORK (DATNET)
+
+In this section, we introduce DATNet in more details. We first describe a base model for NER, and then discuss two proposed transfer architectures for DATNet.
+
+![](images/c12e79f3e88fd641871ac1c2081f1c626fa1b8792b17590e421f4bb59c842530.jpg)  
+Figure 1: The general architecture of proposed models.
+
+# 3.1 BASIC ARCHITECTURE
+
+We follow state-of-the-art models for NER task (Huang et al., 2015; Lample et al., 2016; Chiu & Nichols, 2016; Ma & Hovy, 2016), i.e., LSTM-CNNs-CRF based structure, to build the base model. It consists of the following pieces: character-level embedding, word-level embedding, BiLSTM for feature representation, and CRF as the decoder. The character-level embedding takes a sequence of characters in the word as atomic units input to derive the word representation that encodes the morphological information, such as root, prefix, and suffix. These character features are usually encoded by character-level CNN or BiLSTM, then concatenated with word-level embedding to form the final word vectors. On top of them, the network further incorporates the contextual information using BiLSTM to output new feature representations, which is subsequently fed into CRF layer to predict label sequence. Although both of the word-level layer and the character-level layer can be implemented using CNNs or RNNs, we use CNNs for extracting character-level and RNNs for extracting word-level representation. Fig. 1(a) shows the the architecture of the base model.
+
+# 3.2 DUAL ADVERSARIAL TRANSFER ARCHITECTURE
+
+# 3.2.1 CHARACTER-LEVEL ENCODER
+
+Previous works have shown that character features can boost sequence labeling performance by capturing morphological and semantic information (Lin et al., 2018). For low-resource dataset to obtain high-quality word features, character features learned from other language/domain may provide crucial information for labeling, especially for rare and out-of-vocabulary words. Character-level encoder usually contains BiLSTM (Lample et al., 2016) and CNN (Chiu & Nichols, 2016; Ma & Hovy,
+
+2016) approaches. In practice, Reimers & Gurevych (2017) observed that the difference between the two approaches is statistically insignificant in sequence labeling tasks, but character-level CNN is more efficient and has less parameters. Thus, we use character-level CNN and share character features between high- and low-resource tasks to enhance the representations of low-resource.
+
+# 3.2.2 WORD-LEVEL ENCODER
+
+To learn a better word-level representation, we concatenate character-level features of each word with a latent word embedding as $\mathbf { w } _ { i } = [ \mathbf { w } _ { i } ^ { c h a r } , \mathbf { w } _ { i } ^ { e m b } ]$ , where the latent word embedding $\mathbf { w } _ { i } ^ { e m b }$ is initialized with pre-trained embeddings and fixed during training. One unique characteristic of NER is that the historical and future input for a given time step could be useful for label inference. To exploit such a characteristic, we use a bidirectional LSTM architecture (Hochreiter & Schmidhuber, 1997) to extract contextualized word-level features. In this way, we can gather the information from the past and future for a particular time frame $t$ as follows, $\vec { \mathbf { h } } _ { t } = \mathtt { l s t m } ( \vec { \mathbf { h } } _ { t - 1 } , \mathbf { w } _ { t } ) , \ \overleftarrow { \mathbf { h } } _ { t } $ $\left\{ \overline { { \mathbf { h } } } _ { t } = \right.$ $\mathtt { l s t m } ( \overleftarrow { \mathbf { h } } _ { t + 1 } , \mathbf { w } _ { t } )$ . After the LSTM layer, the representation of a word is obtained by concatenating its left and right context representation as follows, $\mathbf h _ { t } = [ \widehat { \mathbf h } _ { t } , \widetilde { \mathbf h } _ { t } ]$ .
+
+To consider the resource representation difference on word-level features, we introduce two kinds of transferable word-level encoder in our model, namely DATNet-Full Share (DATNet-F) and DATNetPart Share (DATNet-P). In DATNet-F, all the BiLSTM units are shared by both resources while word embeddings for different resources are disparate. The illustrative figure is depicted in the Fig. 1(c). Different from DATNet-F, the DATNet-P decomposes the BiLSTM units into the shared component and the resource-related one, which is shown in the Fig. 1(b).
+
+# 3.2.3 GENERALIZED RESOURCE-ADVERSARIAL DISCRIMINATOR
+
+In order to make the feature representation extracted from the source domain more compatible with those from the target domain, we encourage the outputs of the shared BiLSTM part to be resourceagnostic by constructing a resource-adversarial discriminator, which is inspired by the LanguageAdversarial Discriminator proposed by Kim et al. (2017). Unfortunately, previous works did not consider the imbalance of training size for two resources. Specifically, the target domain consists of very limited labeled training data, e.g., 10 sentences. In contrast, labeled training data in the source domain are much richer, e.g., 10k sentences. If such imbalance was not considered during training, the stochastic gradient descent (SGD) optimization would make the model more biased to high resource (Lin et al., 2017b). To address this imbalance problem, we impose a weight $\alpha$ on two resources to balance their influences. However, in the experiment we also observe that the easily classified samples from high resource comprise the majority of the loss and dominate the gradient. To overcome this issue, we further propose Generalized Resource-Adversarial Discriminator (GRAD) to enable adaptive weights for each sample (note that the sample here means each sentence of resource), which focuses the model training on hard samples.
+
+To compute the loss of GRAD, the output sequence of the shared BiLSTM is firstly encoded into a single vector via a self-attention module (Bahdanau et al., 2015), and then projected into a scalar $r$ via a linear transformation. The loss function of the resource classifier is formulated as:
+
+$$
+\ell _ { G R A D } = - \sum _ { i } \{ \mathbf { I } _ { i \in \mathcal { D } _ { S } } \alpha ( 1 - r _ { i } ) ^ { \gamma } \log r _ { i } + \mathbf { I } _ { i \in \mathcal { D } _ { T } } ( 1 - \alpha ) r _ { i } ^ { \gamma } \log ( 1 - r _ { i } ) \}
+$$
+
+where $\mathbf { I } _ { i \in \mathcal { D } _ { S } } , \mathbf { I } _ { i \in \mathcal { D } _ { T } }$ are the identity functions to denote whether a sentence is from high resource (source) and low resource (target), respectively; $\alpha$ is a weighting factor to balance the loss contribution from high and low resource; the parameter $( 1 - r _ { i } ) ^ { \gamma }$ (or $r _ { i } ^ { \gamma }$ ) controls the loss contribution from individual samples by measuring the discrepancy between prediction and true label (easy samples have smaller contribution); and $\gamma$ scales the contrast of loss contribution from hard and easy samples. In practice, the value of $\gamma$ does not need to be tuned much and usually set as 2 in our experiment. Intuitively, the weighting factors $\alpha$ and $( 1 - r _ { i } ) ^ { \gamma }$ reduce the loss contribution from high resource and easy samples, respectively. Note that though the resource classifier is optimized to minimize the resource classification error, when the gradients originated from the resource classification loss are back-propagated to the other model parts than the resource classifier, they are negated for parameter updates so that these bottom layers are trained to be resource-agnostic.
+
+# 3.2.4 LABEL DECODER
+
+The label decoder induces a probability distribution over sequences of labels, conditioned on the word-level encoder features. In this paper, we use a linear chain model based on the first-order Markov chain structure, termed the chain conditional random field (CRF) Lafferty et al. (2001), as the decoder. In this decoder, there are two kinds of cliques: local cliques and transition cliques. Specifically, local cliques correspond to the individual elements in the sequence. And transition cliques, on the other hand, reflect the evolution of states between two neighboring elements at time $t - 1$ and $t$ and we define the transition distribution as $\theta$ . Formally, a linear-chain CRF can be written $\begin{array} { r } { p ( \mathbf { y } | \mathbf { h } _ { 1 : T } ) = \frac { 1 } { Z ( \mathbf { h } _ { 1 : T } ) } \exp \left\{ \sum _ { t = 2 } ^ { T } \theta _ { y _ { t - 1 } , y _ { t } } + \sum _ { t = 1 } ^ { T } \mathbf { W } _ { y _ { t } } \mathbf { h } _ { t } \right\} } \end{array}$ , where $Z ( \mathbf { h } _ { 1 : T } )$ is a normalization term and $\mathbf { y }$ is the sequence of predicted labels as follows: $\mathbf { y } = y _ { 1 : T }$ . Model parameters are optimized to maximize this conditional log likelihood, which acts as the objective function of the model. We define the loss function for source and target resources as follows, $\begin{array} { r } { \ell _ { S } = - \sum _ { i } \log p ( \mathbf { y } | \mathbf { h } _ { 1 : T } ) } \end{array}$ , $\ell _ { T } =$ $\begin{array} { r } { - \sum _ { i } \log p ( \mathbf { y } | \mathbf { h } _ { 1 : T } ) } \end{array}$ .
+
+# 3.2.5 ADVERSARIAL TRAINING
+
+So far our model can be trained end-to-end with standard back-propagation by minimizing the following loss:
+
+$$
+\ell = \ell _ { G R A D } + \ell _ { S } + \ell _ { T }
+$$
+
+Recent works have demonstrated that deep learning models are fragile to adversarial examples Goodfellow et al. (2015). In computer vision, those adversarial examples can be constructed by changing a very small number of pixels, which are virtually indistinguishable to human perception (Pin-Yu et al., 2018). Recently, adversarial samples are widely incorporated into training to improve the generalization and robustness of the model, which is so-called adversarial training (AT) (Miyato et al., 2017). It emerges as a powerful regularization tool to stabilize training and prevent the model from being stuck in local minimum. In this paper, we explore AT in context of NER. To be specific, we prepare an adversarial sample by adding the original sample with a perturbation bounded by a small norm $\epsilon$ to maximize the loss function as follows:
+
+$$
+\eta _ { \mathbf { x } } = \arg \operatorname* { m a x } _ { \eta : \| \eta \| _ { 2 } \leq \epsilon } \ell ( \Theta ; \mathbf { x } + \eta )
+$$
+
+where $\Theta$ is the current model parameters set. However, we cannot calculate the value of $\eta$ exactly in general, because the exact optimization with respect to $\eta$ is intractable in neural networks. Following the strategy in Goodfellow et al. (2015), this value can be approximated by linearizing it as follows,
+
+$$
+\eta _ { \mathbf { x } } = \epsilon \frac { \mathbf { g } } { \| \mathbf { g } \| _ { 2 } } , \mathrm { w h e r e } \mathbf { g } = \nabla \ell ( \Theta ; \mathbf { x } )
+$$
+
+where $\epsilon$ can be determined on the validation set. In this way, adversarial examples are generated by adding small perturbations to the inputs in the direction that most significantly increases the loss function of the model. We find such $\eta$ against the current model parameterized by $\Theta$ , at each training step, and construct an adversarial example by ${ \bf x } _ { a d v } = { \bf x } + \eta _ { \bf x }$ . Noted that we generate this adversarial example on the word and character embedding layer, respectively, as shown in the Fig. 1(b) and 1(c). Then, the classifier is trained on the mixture of original and adversarial examples to improve the generalization. To this end, we augment the loss in Eqn. 2 and define the loss function for adversarial training as:
+
+$$
+\ell _ { A T } = \ell ( \Theta ; \mathbf { x } ) + \ell ( \Theta ; \mathbf { x } _ { a d v } )
+$$
+
+where $\ell ( \Theta ; { \mathbf x } ) , \ell ( \Theta ; { \mathbf x } _ { a d v } )$ represents the loss from an original example and its adversarial counterpart, respectively. Note that we present the AT in a general form for the convenience of presentation. For different samples, the loss and parameters should correspond to their counterparts. For example, for the source data with word embedding $\mathbf { w } _ { S }$ , the loss for AT can be defined as follows, $\bar { \ell _ { A T } } = \ell ( \Theta ; \mathbf { w } _ { S } ) + \ell ( \Theta ; \mathbf { w } _ { S , a d v } )$ with $\mathbf { w } _ { S , a d v } = \mathbf { w } _ { S } + \eta _ { \mathbf { w } _ { S } }$ and $\ell = \ell _ { G R A D } + \ell _ { S }$ . Similarly, we can compute the perturbations $\eta _ { \mathbf { c } }$ for char-embedding and $\eta _ { \mathbf { w } _ { T } }$ for target word embedding.
+
+# 4 EXPERIMENTS
+
+# 4.1 DATASETS
+
+In order to evaluate the performance of DATNet, we conduct the experiments on following widely used NER datasets: CoNLL-2003 English NER (Kim & De, 2003), CoNLL-2002 Spanish & Dutch NER (Kim, 2002), WNUT-2016 & 2017 English Twitter NER (Zeman, 2017). The statistics of these datasets are described in Table 1. We use the official split of training/validation/test sets. Since our goal is to study the effects of transferring knowledge from high-resource dataset to low-resource dataset, unlike previous works (Collobert et al., 2011; Chiu & Nichols, 2016; Yang et al., 2017) to append one-hot gazetteer features to the input of the CRF layer, and the works (Partalas et al., 2016; Limsopatham & Collier, 2016; Aguilar et al., 2017) to introduce orthographic feature as additional input for learning social media NER in tweets, we do not experiment with hand-crafted features and only consider words and characters embeddings as the inputs of our model. To be noted, we used only train set for model training for all datasets except the WNUT-2016 NER dataset. Since in this dataset, all the previous studies merged the training and validation sets together for training, we followed the same way for fair comparison. Specifically, we use CoNLL-2003 English NER dataset as high-resource (i.e., source) for all the experiments on CoNLL and WNUT datasets, while CoNLL-2002 Spanish & Dutch NER datasets and WNUT-2016 & 2017 Twitter NER datasets as low-resource (i.e., target) in cross-language and cross-domain NER settings, respectively.
+
+Table 1: Statistics of CoNLL and WNUT Named Entity Recognition Datasets.   
+
+<table><tr><td>Benchmark</td><td>Resource</td><td>Language</td><td># Training Tokens (# Entities)</td><td># Dev Tokens (# Entities)</td><td># Test Tokens (# Entities)</td></tr><tr><td>CoNLL-2003</td><td>English</td><td></td><td>204,567 (23,499)</td><td>51,578 (5,942)</td><td>46,666 (5,648)</td></tr><tr><td colspan="6">Cross-language NER</td></tr><tr><td>CoNLL-2002</td><td>Target</td><td>Spanish</td><td>207,484 (18,797)</td><td>51,645 (4,351)</td><td>52.098 (3,558)</td></tr><tr><td>CoNLL-2002</td><td>Target</td><td>Dutch</td><td>202,931 (13,344)</td><td>37,761 (2.616)</td><td>68,994 (3.941)</td></tr><tr><td colspan="6">Cross-domain NER</td></tr><tr><td>WNUT-2016</td><td>Target</td><td>English</td><td>46,469 (2,462)</td><td>16,261 (1,128)</td><td>61,908 (5,955)</td></tr><tr><td>WNUT-2017</td><td>Target</td><td>English</td><td>62,730 (3,160)</td><td>15,733 (1,250)</td><td>23,394 (1,740)</td></tr></table>
+
+In addition to the CoNLL and WNUT datasets, we also experiment on the cross-language named entity dataset described in Pan et al. (2017), which contains datasets for 282 languages, to evaluate our methods and investigate the transferability of different linguistic families and branches in both low- and high-resource scenarios. We choose 9 languages in our experiment, where Galician (gl), West Frisian (fy), Ukrainian (uk) and Marathi (mr) are target languages, the corresponding source languages are Spanish (es), Dutch (nl), Russian $( r u )$ and Hindi (hi), and Arabic (ar) is also a source language, which is from different linguistic family. Following the setting in Cotterell & Duh (2017), we also simulate the low- and high-resource scenarios by creating 100 and 10,000 sentences split for training target language datasets, respectively. Then we create 1,000 sentences split for validation and test, respectively. For source languages, we create 10,000 sentence split for training only. For high-resource scenario, we only conduct experiments on Galician (gl-high) and Ukrainian (uk-high). The list of selected datasets are described in Table 2.
+
+Table 2: List of Named Entity Recognition Datasets in Pan et al. (2017).   
+
+<table><tr><td>Language</td><td>Resource</td><td>Linguistic Family</td><td></td><td>Linguistic Branch # Training Sentences# Dev Sentences</td><td></td><td>：#Test Sentences</td></tr><tr><td>Spanish (es)</td><td>Source</td><td>Indo-European</td><td>Romance</td><td>10,000</td><td></td><td></td></tr><tr><td>Galician (gl/ gl-high)</td><td>Target</td><td>Indo-European</td><td>Romance</td><td>100 /10.000</td><td>1,000</td><td>1,000</td></tr><tr><td>Dutch (nl)</td><td>Source</td><td>Indo-European</td><td>Germanic</td><td>10,000</td><td></td><td></td></tr><tr><td>West Frisian (fy)</td><td>Target</td><td>Indo-European</td><td>Germanic</td><td>100</td><td>1,000</td><td>1,000</td></tr><tr><td>Russian (ru)</td><td>Source</td><td>Indo-European</td><td>Slavic</td><td>10,000</td><td></td><td></td></tr><tr><td>Ukrainian (uk /uk-high)</td><td>Target</td><td>Indo-European</td><td>Slavic</td><td>100 /10.000</td><td>1,000</td><td>1,000</td></tr><tr><td>Hindi (hi)</td><td>Source</td><td>Indo-European</td><td>Indo-Aryan</td><td>10.000</td><td></td><td></td></tr><tr><td>Marathi (mr)</td><td>Target</td><td>Indo-European</td><td>Indo-Aryan</td><td>100</td><td>1,000</td><td>1,000</td></tr><tr><td>Arabic (ar)</td><td>Source</td><td>Afro-Asiatic</td><td>Semitic</td><td>10.000</td><td>-</td><td>-</td></tr></table>
+
+# 4.2 EXPERIMENTAL SETUP
+
+We use 50-dimensional publicly available pre-trained word embeddings for English, Spanish and Dutch languages of CoNLL and WNUT datasets in our experiments, which are trained by word2vec package2 on the corresponding Wikipedia articles (2017-12-20 dumps) (Lin et al., 2018). For the named entity datasets selected from Pan et al. (2017), we use 300-dimensional pre-trained word embeddings trained by fastText package3 on Wikipedia (Bojanowski et al., 2017), and the 30- dimensional randomly initialized character embeddings are used for all the datasets. We set the filter number as 20 for char-level CNN and the dimension of hidden states of the word-level LSTM as 200 for both base model and DATNet-F. For DATNet-P, we set 100 for source, share, and target LSTMs dimension, respectively. Parameters optimization is performed by Adam optimizer (Kingma & Ba, 2014) with gradient clipping of 5.0 and learning rate decay strategy. We set the initial learning rate of $\beta _ { 0 } ~ = ~ 0 . 0 0 1$ for all experiments. At each epoch $t$ , learning rate $\beta _ { t }$ is updated using $\beta _ { t } = \beta _ { 0 } / ( 1 + \rho \times t )$ , where $\rho$ is decay rate with 0.05. To reduce over-fitting, we also apply Dropout (Srivastava et al., 2014) to the embedding layer and the output of the LSTM layer, respectively.
+
+# 4.3 COMPARISON WITH STATE-OF-THE-ART RESULTS
+
+In this section, we compare our approach with state-of-the-art (SOTA) methods on CoNLL and WNUT benchmark datasets. In the experiment, we exploit all the source data (i.e., CoNLL-2003 English NER) and target data to improve performance of target tasks. The averaged results with standard deviation over 10 repetitive runs are summarized in Table 3, and we also report the best results on each task for fair comparison with other SOTA methods. From results, we observe that incorporating the additional resource is helpful to improve performance. DATNet-P model achieves the highest F1 score on CoNLL-2002 Spanish and second F1 score on CoNLL-2002 Dutch dataset while DATNet-F model beats others on WNUT-2016 and WNUT-2017 English Twitter datasets. Different from other state-of-the-art models, DATNets do not use any addition features4.
+
+Table 3: Comparison with State-of-the-art Results in CoNLL and WNUT datasets (F1-score)   
+
+<table><tr><td rowspan="2">Mode</td><td rowspan="2">Methods</td><td rowspan="2"></td><td colspan="2">Additional Features</td><td colspan="2">CoNLL Datasets</td><td colspan="2">WNUT Datasets</td></tr><tr><td></td><td>POS Gazetteers Orthographic</td><td>Spanish</td><td>Dutch</td><td>WNUT-2016 WNUT-2017</td><td></td></tr><tr><td rowspan="7">Mono-language /domain</td><td>Gillick et al. (2016)</td><td>×</td><td>×</td><td>×</td><td>82.59</td><td>82.84</td><td></td><td></td></tr><tr><td>Lample et al. (2016)</td><td>×</td><td>&lt;√√x</td><td>× &lt;</td><td>85.75</td><td>81.74</td><td>-</td><td></td></tr><tr><td>Partalas et al. (2016)</td><td></td><td></td><td></td><td>=</td><td>=</td><td>46.16</td><td></td></tr><tr><td>Limsopatham&amp; Collier (2016)</td><td></td><td></td><td></td><td></td><td>=</td><td>52.41</td><td></td></tr><tr><td rowspan="2">Lin et al. (2017a)</td><td></td><td>√</td><td>√</td><td></td><td></td><td></td><td>40.42</td></tr><tr><td>Best Our Base Model Mean&amp; Std</td><td>×</td><td></td><td></td><td>85.53</td><td>85.55 44.96</td><td>35.20 34.67±0.34</td></tr><tr><td colspan="2"></td><td></td><td>× √</td><td>× ×</td><td>85.35±0.15 85.24±0.21 85.77</td><td></td><td>44.37±0.31</td><td></td></tr><tr><td rowspan="8">Cross-language</td><td colspan="2">Yang et al. (2017)</td><td></td><td></td><td></td><td>85.19</td><td></td><td></td></tr><tr><td colspan="2">Lin et al. (2018)</td><td></td><td></td><td>85.88</td><td>86.55 88.39</td><td></td><td></td></tr><tr><td colspan="2">Feng et al. (2018)</td><td></td><td></td><td></td><td>86.42</td><td></td><td></td></tr><tr><td colspan="2">von Däniken &amp; Cieliebak (2017)</td><td>×</td><td>√ ×</td><td>√</td><td></td><td></td><td>40.78</td></tr><tr><td rowspan="2">Aguilar et al. (2017) DATNet-P</td><td></td><td>√</td><td></td><td>88.16</td><td>88.32</td><td>50.85</td><td>41.86</td></tr><tr><td>Best</td><td></td><td>×</td><td></td><td></td><td></td><td>41.12</td></tr><tr><td rowspan="2">DATNet-F</td><td>Mean&amp; Std</td><td>×</td><td></td><td>87.89±0.18 87.04</td><td>87.77</td><td>88.09±0.13 50.41±0.32 53.43</td><td>40.52±0.38 42.83</td></tr><tr><td>Best Mean&amp; Std</td><td>×</td><td>×</td><td>×</td><td>86.79±0.20</td><td>87.52±0.19</td><td>53.03±0.24 42.32±0.32</td></tr></table>
+
+Table 4 summarizes the results of our methods under different cross-language transfer settings as well as the comparison with Cotterell & Duh (2017). In this experiment, we study the transferability between languages not only from same linguistic family and branch, but also from different linguistic families or branches. According to the results, DATNets outperform the transfer method of Cotterell & Duh (2017) for both low- and high-resource scenarios within the same linguistic family and branch (i.e., in-family in-branch) transfer case. We also observe that: 1) For the low-resource scenario, transfer learning is significantly helpful for improving the performance of target datasets within both same and different linguistic family or branch (i.e., in/cross-family in/cross-branch) transfer cases, while the improvements are more prominent under the in-family in-branch case. 2) For the high-resource scenario, say, when the target language data is sufficient, the improvements of transfer learning are not very distinct compared with that for low-resource scenario under in-family in-branch case. We also find that there is no effect by transferring knowledge from Arabic to Galician and Ukrainian. We suspect that it is caused by the great linguistic differences between source and target languages, since, for example, Arabic and Galician are from totally different linguistic families.
+
+Table 4: Results of Varying Cross-language Transfer Settings in Pan et al. (2017) Datasets (F1-score).   
+
+<table><tr><td colspan="2">Language</td><td rowspan="2">Transferring Strategy</td><td colspan="2">Cotterell &amp; Duh (2017)</td><td colspan="3">Our Methods</td></tr><tr><td>Source</td><td>Target</td><td>Base Model</td><td>Transfer</td><td>Base Model</td><td>DATNet-P</td><td>DATNet-F</td></tr><tr><td>nl</td><td>fy</td><td>In-Family In-Branch</td><td>58.43</td><td>72.12</td><td>57.47</td><td>75.08</td><td>76.05</td></tr><tr><td>hi</td><td>fy</td><td>In-Family Cross-Branch</td><td>-</td><td>-</td><td>57.47</td><td>69.25</td><td>68.44</td></tr><tr><td>ar</td><td>fy</td><td>Cross-Family Cross-Branch</td><td>1</td><td>1</td><td>57.47</td><td>67.89</td><td>66.05</td></tr><tr><td>hi</td><td>mr</td><td>In-Family In-Branch</td><td>39.02</td><td>60.92</td><td>43.55</td><td>68.55</td><td>64.87</td></tr><tr><td>nl</td><td>mr</td><td>In-Family Cross-Branch</td><td>-</td><td>1</td><td>43.55</td><td>63.83</td><td>60.50</td></tr><tr><td>ar</td><td>mr</td><td>Cross-Family Cross-Branch</td><td>-</td><td>1</td><td>43.55</td><td>63.28</td><td>59.76</td></tr><tr><td>es</td><td>g</td><td>In-Family In-Branch</td><td>49.19</td><td>76.40</td><td>49.94</td><td>79.60</td><td>86.01</td></tr><tr><td>hi</td><td>g</td><td>In-Family Cross-Branch</td><td>-</td><td>-</td><td>49.94</td><td>60.57</td><td>61.68</td></tr><tr><td>ar</td><td>g</td><td>Cross-Family Cross-Branch</td><td></td><td>-</td><td>49.94</td><td>59.18</td><td>60.43</td></tr><tr><td>es</td><td>gl-high</td><td>In-Family In-Branch</td><td>89.42</td><td>89.46</td><td>92.78</td><td>93.14</td><td>93.02</td></tr><tr><td>ar</td><td>gl-high</td><td>Cross-Family Cross-Branch</td><td>-</td><td>1</td><td>92.78</td><td>92.63</td><td>92.21</td></tr><tr><td>ru</td><td>uk</td><td>In-Family In-Branch</td><td>60.65</td><td>76.74</td><td>61.48</td><td>79.02</td><td>80.76</td></tr><tr><td>hi</td><td>uk</td><td>In-Family Cross-Branch</td><td>1</td><td>-</td><td>61.48</td><td>72.73</td><td>73.84</td></tr><tr><td>ar</td><td>uk</td><td>Cross-Family Cross-Branch</td><td>-</td><td>1</td><td>61.48</td><td>71.55</td><td>72.24</td></tr><tr><td>ru</td><td>uk-high</td><td>In-Family In-Branch</td><td>87.39</td><td>87.42</td><td>93.29</td><td>93.62</td><td>93.51</td></tr><tr><td>ar</td><td>uk-high</td><td>Cross-Family Cross-Branch</td><td>-1</td><td>-</td><td>93.29</td><td>92.83</td><td>92.42</td></tr></table>
+
+\* Base model means the model is trained by using target language dataset only.
+
+![](images/f72145ff1803baccf438290560a949df8356f92a886dcdb22b498b0c0e817679.jpg)  
+Figure 2: Comparison with Different Target Data Ratio, where AT stands for adversarial training, F(P)- Transfer denotes the DATNet-F(P) without AT.
+
+# 4.4 TRANSFER LEARNING PERFORMANCE
+
+In this section, we investigate on improvements with transfer learning under multiple low-resource settings with partial target data. To simulate a low-resource setting, we randomly select subsets of target data with varying data ratio at 0.05, 0.1, 0.2, 0.4, 0.6, and 1.0. For example, 20,748 training tokens are sampled from the training set under a data ratio of $r ~ = ~ 0 . 1$ for the dataset CoNLL-2002 Spanish NER (Cf. Table 1). The results for cross-language and cross-domain transfer are shown in Fig. 2(a) and 2(b), respectively, where we compare the results with each part of DATNet under various data ratios. From those figures, we have the following observations: 1) both adversarial training and adversarial discriminator in DATNet consistently contribute to the performance improvement; 2) the transfer learning component in the DATNet consistently improve over the base model results and the improvement margin is more substantial when the target data ratio is lower. For example, when the data ratio is 0.05, DATNet-P model outperforms the base model by more than $4 \%$ absolutely in F1-score on Spanish NER and DATNet-F model improves around $13 \%$ absolutely in F1-score compared to base model on WNUT-2016 NER.
+
+Table 5: Experiments on Extremely Low Resource (F1-score).   
+
+<table><tr><td colspan="2">Tasks</td><td colspan="5">CoNLL-2002 2Spanish NER</td><td colspan="5">WNUT-2016 Twitter NER</td></tr><tr><td>#Target train sentences</td><td>10</td><td>50</td><td>100</td><td>200</td><td>500</td><td>1000</td><td>10</td><td>50</td><td>100</td><td>200 500</td><td>1000</td></tr><tr><td>Base</td><td>21.53</td><td>42.18</td><td>48.35</td><td>63.66</td><td>68.83</td><td>76.69</td><td>3.80 14.07</td><td>17.99</td><td>26.20</td><td>31.78</td><td>36.99</td></tr><tr><td>+ AT</td><td>19.23</td><td>41.01</td><td>50.46</td><td>64.83</td><td>70.85</td><td>77.91</td><td>4.34 16.87</td><td>18.43</td><td>26.32</td><td>35.68</td><td>41.69</td></tr><tr><td>+ P-Transfer</td><td>29.78</td><td>61.09</td><td>64.78</td><td>66.54</td><td>72.94</td><td>78.49</td><td>7.71 16.17</td><td>20.43</td><td>29.20</td><td>34.90</td><td>41.20</td></tr><tr><td>+ F-Transfer</td><td>39.72</td><td>63.00</td><td>63.36</td><td>66.39</td><td>72.88</td><td>78.04</td><td>15.26 20.04</td><td>26.60</td><td>32.22</td><td>38.35</td><td>44.81</td></tr><tr><td>DATNet-P</td><td>39.52</td><td>62.57</td><td>64.05</td><td>68.95</td><td>75.19</td><td>79.46</td><td>9.94 17.09</td><td>25.39</td><td>30.71</td><td>36.05</td><td>42.30</td></tr><tr><td>DATNet-F</td><td>44.52</td><td>63.89</td><td>66.67</td><td>68.35</td><td>74.24</td><td>78.56</td><td>17.14 22.59</td><td>28.41</td><td>32.48</td><td>39.20</td><td>45.25</td></tr></table>
+
+In the second experiment, we further investigate DATNet on the extremely low resource cases, e.g., the number of training target sentences is 10, 50, 100, 200, 500 and 1,000. The setting is quite challenging and fewer previous works have studied before. The results are summarized in Table 5. We have two interesting observations 5: 1) DATNet-F outperforms DATNet-P on cross-language transfer when the target resource is extremely low, however, this situation is reversed when the target dataset size is large enough (here for this specific dataset, the threshold is 100 sentences); 2) DATNet-F is always superior to DATNet-P on cross-domain transfer. For the first observation, it is because DATNet-F with more shared hidden units is more efficient to transfer knowledge than DATNet-P when data size is extremely small. For the second observation, because cross-domain transfer are in the same language, more knowledge is common between the source and target domains, requiring more shared hidden features to carry with these knowledge compared to cross-language transfer. Therefore, for cross-language transfer with an extremely low resource and cross-domain transfer, we suggest using DATNet-F model to achieve better performance. As for cross-language transfer with relatively more training data, DATNet-P model is preferred.
+
+![](images/38bd30d068e4b39c5cd4a5729fc9ffba13a24ca5e60e11bf15adfd7bfc834cd6.jpg)  
+Figure 3: The visualization of extracted features from shared bidirectional-LSTM layer. The left, middle, and right figures show the results when no Adversarial Discriminator (AD), AD, and GRAD is performed, respectively. Red points correspond to the source CoNLL-2003 English examples, and blue points correspond to the target CoNLL-2002 Spanish examples.
+
+# 4.5 ABLATION STUDY OF DATNET
+
+In the proposed DATNet, both GRAD and AT play important roles in low resource NER. In this experiment, we further investigate how GRAD and AT help transfer knowledge across language/domain. In the first experiment6, we used t-SNE (Maaten & Hinton, 2008) to visualize the feature distribution of BiLSTM outputs without AD, with normal AD (GRAD without considering data imbalance), and with the proposed GRAD in Figure 3. From this figure, we can see that the GRAD in DATNet makes the distribution of extracted features from the source and target datasets much more similar by considering the data imbalance, which indicates that the outputs of BiLSTM are resource-invariant.
+
+Table 6: Quantitative Performance Comparison between Models with Different Components.   
+
+<table><tr><td colspan="4">CoNLL-2002 Spanish NER</td><td colspan="4">WNUT-2016TwitterNER</td></tr><tr><td>Model</td><td>F1-score</td><td>Model</td><td>F1-score</td><td>Model</td><td>F1-score</td><td>Model</td><td>F1-score</td></tr><tr><td>Base</td><td>85.35</td><td>+AT</td><td>86.12</td><td>Base</td><td>44.37</td><td>+AT</td><td>47.41</td></tr><tr><td>+P-T (no AD)</td><td>86.15</td><td>+AT +P-T (no AD)</td><td>86.90</td><td>+P-T (no AD)</td><td>47.66</td><td>+AT +P-T (no AD)</td><td>48.44</td></tr><tr><td>+F-T (no AD)</td><td>85.46</td><td>+AT +F-T (no AD)</td><td>86.17</td><td>+F-T (no AD)</td><td>49.79</td><td>+AT +F-T (no AD)</td><td>50.93</td></tr><tr><td>+P-T (AD)</td><td>86.32</td><td>+AT +P-T (AD)</td><td>87.19</td><td>+P-T (AD)</td><td>48.14</td><td>+AT+P-T (AD)</td><td>49.41</td></tr><tr><td>+F-T(AD)</td><td>85.58</td><td>+AT +F-T (AD) +AT +P-T (GRAD)</td><td>86.38</td><td>+F-T(AD)</td><td>50.48</td><td>+AT +F-T (AD)</td><td>51.84</td></tr><tr><td>+P-T (GRAD)</td><td>86.93</td><td>(DATNet-P)</td><td>88.16</td><td>+P-T (GRAD)</td><td>48.91</td><td>+AT+P-T (GRAD) (DATNet-P)</td><td>50.85</td></tr><tr><td>+F-T(GRAD)</td><td>85.91</td><td>+AT+F-T (GRAD) (DATNet-F)</td><td>87.04</td><td>+F-T(GRAD)</td><td>51.31</td><td>+AT +F-T (GRAD) (DATNet-F)</td><td>53.43</td></tr></table>
+
+\* AT: Adversarial Training; P-T: P-Transfer; F-T: F-Transfer; AD: Adversarial Discriminator; GRAD: Generalized Resource-Adversarial Discriminator.
+
+To better understand the working mechanism, Table 6 further reports the quantitative performance comparison between models with different components. We observe that GRAD shows the stable superiority over the normal AD regardless of other components. There are no always winner between DATNet-P and DATNet-F on different settings. DATNet-P architecture is more suitable to cross-language transfer while DATNet-F is more suitable to cross-domain transfer.
+
+Table 7: Analysis of Maximum Perturbation $\epsilon _ { \mathbf { w } _ { T } }$ in AT with Varying Data Ratio $\rho$ (F1-score).   
+
+<table><tr><td>EwT</td><td>1.0</td><td>3.0</td><td>5.0</td><td>7.0</td><td>9.0</td></tr><tr><td>Ratio</td><td colspan="5">CoNLL-2002 Spanish NER</td></tr><tr><td>p=0.1</td><td>75.90</td><td>76.23</td><td>77.38</td><td>77.77</td><td>78.13</td></tr><tr><td>p=0.2</td><td>81.54</td><td>81.65</td><td>81.32</td><td>81.81</td><td>81.68</td></tr><tr><td>p=0.4</td><td>83.62</td><td>83.83</td><td>83.43</td><td>83.99</td><td>83.40</td></tr><tr><td>p=0.6</td><td>84.44</td><td>84.47</td><td>84.72</td><td>84.04</td><td>84.05</td></tr></table>
+
+From the previous results, we know that AT helps enhance the overall performance by adding perturbations to inputs with the limit of $\epsilon = 5$ , i.e., $\| \bar { \boldsymbol { \eta } } \| _ { 2 } \le 5$ . In this experiment, we further investigate how target perturbation $\epsilon _ { \mathbf { w } _ { T } }$ with fixed source perturbation ${ \epsilon _ { { \bf w } _ { S } } } = 5$ in AT affects knowledge transfer and the results on Spanish NER are summarized in Table 7. The results generally indicate that less training data require a larger $\epsilon$ to prevent over-fitting, which further validates the necessity of AT in the case of low resource data.
+
+Table 8: Analysis of Discriminator Weight $\alpha$ in GRAD with Varying Data Ratio $\rho$ (F1-score).   
+
+<table><tr><td>α</td><td>0.1</td><td>0.15</td><td>0.2</td><td>0.25</td><td>0.3</td><td>0.35</td><td>0.4</td><td>0.45</td><td>0.5</td><td>0.55</td><td>0.6</td><td>0.65</td><td>0.7</td><td>0.75</td><td>0.8</td></tr><tr><td>Ratio</td><td></td><td></td><td></td><td></td><td></td><td></td><td>CoNLL-2002 Spanish NER</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>p=0.1</td><td>78.37</td><td>78.63</td><td>78.70</td><td>78.32</td><td>77.96</td><td>77.92</td><td>77.88</td><td>77.78</td><td>77.85</td><td>77.90</td><td>77.65</td><td>77.57</td><td>77.38</td><td>77.49</td><td>77.29</td></tr><tr><td>p=0.2</td><td>80.99</td><td>81.71</td><td>82.18</td><td>81.57</td><td>81.53</td><td>81.55</td><td>81.44</td><td>81.25</td><td>81.32</td><td>81.16</td><td>81.02</td><td>81.16</td><td>80.63</td><td>80.79</td><td>80.54</td></tr><tr><td>p=0.4</td><td>83.76</td><td>83.73</td><td>84.18</td><td>84.48</td><td>84.26</td><td>84.12</td><td>83.54</td><td>83.40</td><td>83.52</td><td>84.18</td><td>83.42</td><td>83.47</td><td>83.28</td><td>83.33</td><td>83.19</td></tr><tr><td>p=0.6</td><td>85.18</td><td>85.24</td><td>85.85</td><td>85.68</td><td>85.84</td><td>86.10</td><td>85.71</td><td>85.74</td><td>85.42</td><td>85.60</td><td>85.20</td><td>85.40</td><td>85.26</td><td>85.24</td><td>84.98</td></tr></table>
+
+Finally, we analyze the discriminator weight $\alpha$ in GRAD and results are summarized in Table 8. From the results, it is interesting to find that $\alpha$ is directly proportional to the data ratio $\rho$ , basically, which means that more target training data requires larger $\alpha$ (i.e., smaller $1 - \alpha$ to reduce training emphasis on the target domain) to achieve better performance.
+
+# 5 CONCLUSION
+
+In this paper we develop a transfer learning model DATNet for low-resource NER, which aims at addressing two problems remained in existing work, namely representation difference and resource data imbalance. We introduce two variants of DATNet, DATNet-F and DATNet-P, which can be chosen for use according to the cross-language/domain user case and the target dataset size. To improve model generalization, we propose dual adversarial learning strategies, i.e., AT and GRAD. Extensive experiments show the superiority of DATNet over existing models and it achieves new state-of-the-art performance on CoNLL NER and WNUT NER benchmark datasets.
+
+# REFERENCES
+
+Oliver Adams, Adam Makarucha, Graham Neubig, Steven Bird, and Trevor Cohn. Cross-lingual word embeddings for low-resource language modeling. In EACL, pp. 937–947. Association for Computational Linguistics, 2017.
+
+Gustavo Aguilar, Suraj Maharjan, Adrian Pastor Lopez Monroy, and Thamar Solorio. A multi-task ´ approach for named entity recognition in social media data. In Proceedings of the 3rd Workshop on Noisy User-generated Text, pp. 148–153, 2017.
+
+Rami Al-Rfou’, Vivek Kulkarni, Bryan Perozzi, and Steven Skiena. Polyglot-ner: Massive multilingual named entity recognition. In SDM, 2015.
+
+Dzmitry Bahdanau, KyungHyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. In ICLR, 2015.
+
+Piotr Bojanowski, Edouard Grave, Armand Joulin, and Tomas Mikolov. Enriching word vectors with subword information. Transactions of the Association for Computational Linguistics, 5:135–146, 2017.
+
+Yufeng Chen, Chengqing Zong, and Keh-Yih Su. On jointly recognizing and aligning bilingual named entities. In ACL, pp. 631–639, 2010.
+
+Jason Chiu and Eric Nichols. Named entity recognition with bidirectional lstm-cnns. Transactions of the Association for Computational Linguistics, 4:357–370, 2016.
+
+Ronan Collobert, Jason Weston, Leon Bottou, Michael Karlen, Koray Kavukcuoglu, and Pavel ´ Kuksa. Natural language processing (almost) from scratch. JMLR, pp. 2493–2537, 2011.
+
+Ryan Cotterell and Kevin Duh. Low-resource named entity recognition with cross-lingual, character-level neural conditional random fields. In Proceedings of the Eighth International Joint Conference on Natural Language Processing (Volume 2: Short Papers), pp. 91–96. Asian Federation of Natural Language Processing, 2017.
+
+Meng Fang and Trevor Cohn. Model transfer for tagging low-resource languages using a bilingual dictionary. In ACL, pp. 587–593, 2017.
+
+Xiaocheng Feng, Xiachong Feng, Bing Qin, Zhangyin Feng, and Ting Liu. Improving low resource named entity recognition using cross-lingual knowledge transfer. In IJCAI, pp. 4071–4077, 2018.
+
+Dan Gillick, Cliff Brunk, Oriol Vinyals, and Amarnag Subramanya. Multilingual language processing from bytes. In NAACL HLT, pp. 1296–1306, 2016.
+
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in neural information processing systems, 2014.
+
+Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. In ICLR, 2015.
+
+Tao Gui, Qi Zhang, Haoran Huang, Minlong Peng, and Xuanjing Huang. Part-of-speech tagging for twitter with adversarial neural networks. In EMNLP, pp. 2411–2420, 2017.
+
+Kazuma Hashimoto, caiming xiong, Yoshimasa Tsuruoka, and Richard Socher. A joint many-task model: Growing a neural network for multiple nlp tasks. In EMNLP, pp. 1923–1933, 2017.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 1997.
+
+Zhiheng Huang, Wei Xu, and Kai Yu. Bidirectional lstm-crf models for sequence tagging. CoRR, abs/1508.01991, 2015.
+
+Joo-Kyung Kim, Young-Bum Kim, Ruhi Sarikaya, and Eric Fosler-Lussier. Cross-lingual transfer learning for pos tagging without cross-lingual resources. In EMNLP, pp. 2832–2838, 2017.
+
+Sang Erik F. Tjong Kim. Introduction to the conll-2002 shared task: Language-independent named entity recognition. In COLING-02: The 6th Conference on Natural Language Learning 2002 (CoNLL-2002), 2002.
+
+Sang Erik F. Tjong Kim and Meulder Fien De. Introduction to the conll-2003 shared task: Languageindependent named entity recognition. In NAACL HLT, 2003.
+
+Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. CoRR, 2014.
+
+John D. Lafferty, Andrew McCallum, and Fernando C. N. Pereira. Conditional random fields: Probabilistic models for segmenting and labeling sequence data. In Proceedings of the Eighteenth International Conference on Machine Learning, ICML ’01, 2001.
+
+Guillaume Lample, Miguel Ballesteros, Sandeep Subramanian, Kazuya Kawakami, and Chris Dyer. Neural architectures for named entity recognition. In NAACL HLT, pp. 260–270, 2016.
+
+Qi Li, Haibo Li, Heng Ji, Wen Wang, Jing Zheng, and Fei Huang. Joint bilingual name tagging for parallel corpora. In CIKM ’12, pp. 1727–1731, 2012.
+
+Nut Limsopatham and Nigel Collier. Bidirectional lstm for named entity recognition in twitter messages. In Proceedings of the 2nd Workshop on Noisy User-generated Text (WNUT), pp. 145– 152, 2016.
+
+Bill Y. Lin, Frank Xu, Zhiyi Luo, and Kenny Zhu. Multi-channel bilstm-crf model for emerging named entity recognition in social media. In Proceedings of the 3rd Workshop on Noisy Usergenerated Text, pp. 160–165, 2017a.
+
+T. Lin, P. Goyal, R. Girshick, K. He, and P. Dollar. Focal loss for dense object detection. In 2017 IEEE International Conference on Computer Vision (ICCV), 2017b.
+
+Ying Lin, Shengqi Yang, Veselin Stoyanov, and Heng Ji. A multi-lingual multi-task architecture for low-resource sequence labeling. In ACL, 2018.
+
+L. Liu, J. Shang, F. Xu, X. Ren, H. Gui, J. Peng, and J. Han. Empower sequence labeling with task-aware neural language model. In AAAI, 2018.
+
+Pengfei Liu, Xipeng Qiu, and Xuanjing Huang. Adversarial multi-task learning for text classification. In ACL, 2017.
+
+Gang Luo, Xiaojiang Huang, Chin-Yew Lin, and Zaiqing Nie. Joint entity recognition and disambiguation. In EMNLP, pp. 879–888, 2015.
+
+Minh-Thang Luong, Quoc V. Le, Ilya Sutskever, Oriol Vinyals, and Lukasz Kaiser. Multi-task sequence to sequence learning. In ICLR, 2016.
+
+Xuezhe Ma and Eduard Hovy. End-to-end sequence labeling via bi-directional lstm-cnns-crf. In ACL, pp. 1064–1074, 2016.
+
+Laurens van der Maaten and Geoffrey Hinton. Visualizing data using t-sne. JMLR, 9:2579–2605, 2008.
+
+Monica Marrero, Juli ´ an Urbano, Sonia S ´ anchez-Cuadrado, Jorge Morato, and Juan Miguel G ´ omez- ´ Berb´ıs. Named entity recognition: Fallacies, challenges and opportunities. Computer Standards & Interfaces, (5):482–489, 2013.
+
+Stephen Mayhew, Chen-Tse Tsai, and Dan Roth. Cheap translation for cross-lingual named entity recognition. In Proceedings of the 2017 Conference on Empirical Methods in Natural Language Processing, pp. 2536–2545. Association for Computational Linguistics, 2017.
+
+Takeru Miyato, Andrew M Dai, and Ian Goodfellow. Adversarial training methods for semisupervised text classification. In ICLR, 2017.
+
+Jian Ni and Radu Florian. Improving multilingual named entity recognition with wikipedia entity type mapping. In Proceedings of the 2016 Conference on Empirical Methods in Natural Language Processing, pp. 1275–1284, 2016.
+
+Jian Ni, Georgiana Dinu, and Radu Florian. Weakly supervised cross-lingual named entity recognition via effective annotation and representation projection. In ACL, pp. 1470–1480, 2017.
+
+Xiaoman Pan, Boliang Zhang, Jonathan May, Joel Nothman, Kevin Knight, and Heng Ji. Crosslingual name tagging and linking for 282 languages. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp. 1946–1958. Association for Computational Linguistics, 2017.
+
+Ioannis Partalas, Cedric Lopez, Nadia Derbas, and Ruslan Kalitvianski. Learning to search for rec-´ ognizing named entities in twitter. In Proceedings of the 2nd Workshop on Noisy User-generated Text (WNUT), pp. 171–177, 2016.
+
+Alexandre Passos, Vineet Kumar, and Andrew McCallum. Lexicon infused phrase embeddings for named entity resolution. arXiv preprint arXiv:1404.5367, 2014.
+
+Chen Pin-Yu, Sharma Yash, Zhang Huan, Yi Jinfeng, and Cho-Jui Hsieh. Ead: Elastic-net attacks to deep neural networks via adversarial examples. In AAAI, 2018.
+
+Lev Ratinov and Dan Roth. Design challenges and misconceptions in named entity recognition. In Proceedings of the Thirteenth Conference on Computational Natural Language Learning, pp. 147–155, 2009.
+
+Marek Rei. Semi-supervised multitask learning for sequence labeling. In ACL, pp. 2121–2130, 2017.
+
+Marek Rei and Anders Søgaard. Zero-shot sequence labeling: Transferring knowledge from sentences to tokens. In NAACL HLT, pp. 293–302, 2018.
+
+Nils Reimers and Iryna Gurevych. Reporting score distributions makes a difference: Performance study of lstm-networks for sequence tagging. In EMNLP, pp. 338–348, 2017.
+
+Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: A simple way to prevent neural networks from overfitting. JMLR, pp. 1929–1958, 2014.
+
+Christian Szegedy, Wojciech Zaremba, Dumitru Erhan Ian Goodfellow Ilya Sutskever, Joan Bruna, and Rob Fergus. Intriguing properties of neural networks. In ICLR, 2014.
+
+Pius von Daniken and Mark Cieliebak. Transfer learning and sentence level features for named ¨ entity recognition on tweets. In Proceedings of the 3rd Workshop on Noisy User-generated Text, pp. 166–171, 2017.
+
+Zhilin Yang, Ruslan Salakhutdinov, and William W. Cohen. Multi-task cross-lingual sequence tagging from scratch. CoRR, abs/1603.06270, 2016.
+
+Zhilin Yang, Ruslan Salakhutdinov, and William W. Cohen. Transfer learning for sequence tagging with hierarchical recurrent networks. In ICLR, 2017.
+
+David Yarowsky, Grace Ngai, and Richard Wicentowski. Inducing multilingual text analysis tools via robust projection across aligned corpora. In Proceedings of the first international conference on Human language technology research, pp. 1–8, 2001.
+
+Michihiro Yasunaga, Jungo Kasai, and Dragomir Radev. Robust multilingual part-of-speech tagging via adversarial training. In NAACL HLT, pp. 976–986, 2018.
+
+Daniel et al. Zeman. Conll 2017 shared task: Multilingual parsing from raw text to universal dependencies. In Proceedings of the CoNLL 2017 Shared Task: Multilingual Parsing from Raw Text to Universal Dependencies, pp. 1–19, 2017.
+
+Boliang Zhang, Xiaoman Pan, Tianlu Wang, Ashish Vaswani, Heng Ji, Kevin Knight, and Daniel Marcu. Name tagging for low-resource incident languages based on expectation-driven learning. In NAACL HLT, pp. 249–259, 2016.
+
+Andrej Zukov Gregoric, Yoram Bachrach, and Sam Coope. Named entity recognition with parallel recurrent neural networks. In ACL, pp. 69–74, 2018.

parse/train/HkGzUjR5tQ/HkGzUjR5tQ_content_list.json

@@ -0,0 +1,1562 @@
+[
+    {
+        "type": "text",
+        "text": "DATNET: DUAL ADVERSARIAL TRANSFER FOR LOWRESOURCE NAMED ENTITY RECOGNITION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            821,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            171,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            236,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We propose a new architecture termed Dual Adversarial Transfer Network (DATNet) for addressing low-resource Named Entity Recognition (NER). Specifically, two variants of DATNet, i.e., DATNet-F and DATNet-P, are proposed to explore effective feature fusion between high and low resource. To address the noisy and imbalanced training data, we propose a novel Generalized ResourceAdversarial Discriminator (GRAD). Additionally, adversarial training is adopted to boost model generalization. We examine the effects of different components in DATNet across domains and languages, and show that significant improvement can be obtained especially for low-resource data. Without augmenting any additional hand-crafted features, we achieve new state-of-the-art performances on CoNLL and Twitter NER— $8 8 . 1 6 \\%$ F1 for Spanish, $5 3 . 4 3 \\%$ F1 for WNUT-2016, and $4 2 . 8 3 \\%$ F1 for WNUT- $2 0 1 7 ^ { 1 }$ . ",
+        "bbox": [
+            233,
+            267,
+            764,
+            433
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            462,
+            336,
+            478
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Named entity recognition (NER) is an important step in most natural language processing (NLP) applications. It detects not only the type of named entity, but also the entity boundaries, which requires deep understanding of the contextual semantics to disambiguate the different entity types of same tokens. To tackle this challenging problem, most early studies were based on hand-crafted rules, which suffered from limited performance in practice. Current methods are devoted to developing learning based algorithms, especially neural network based methods, and have been advancing the state-of-the-art consecutively (Collobert et al., 2011; Huang et al., 2015; Lample et al., 2016; Chiu & Nichols, 2016; Ma & Hovy, 2016). These end-to-end models generalize well on new entities based on features automatically learned from the data. However, when the annotated corpora is small, especially in the low resource scenario (Zhang et al., 2016), the performance of these methods degrades significantly since the hidden feature representations cannot be learned adequately. ",
+        "bbox": [
+            173,
+            494,
+            825,
+            647
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recently, more and more approaches have been proposed to address low-resource NER. Early works (Chen et al., 2010; Li et al., 2012) primarily assumed a large parallel corpus and focused on exploiting them to project information from high- to low-resource. Unfortunately, such a large parallel corpus may not be available for many low-resource languages. More recently, cross-resource word embedding (Fang & Cohn, 2017; Adams et al., 2017; Yang et al., 2017) was proposed to bridge the low and high resources and enable knowledge transfer. Although the aforementioned transferbased methods show promising performance in low-resource NER, there are two issues deserved to be further investigated on: 1) Representation Difference - they did not consider the representation difference across resources and enforced the feature representation to be shared across languages/domains; 2) Resource Data Imbalance - the training size of high-resource is usually much larger than that of low-resource. The existing methods neglect such difference in their models, resulting in poor generalization. ",
+        "bbox": [
+            174,
+            655,
+            825,
+            820
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work, we present an approach termed Dual Adversarial Transfer Network (DATNet) to address the above issues in a unified framework for low-resource NER. Specifically, to handle the representation difference, we first investigate on two architectures of hidden layers (we use bidirectional long-short term memory (BiLSTM) model as hidden layer) for transfer. The first one is that all the units in hidden layers are common units shared across languages/domains. The second one is composed of both private and common units, where the private part preserves the independent language/domain information. Extensive experiments are conducted to show their advantages over each other in different situations. On top of common units, the adversarial discriminator (AD) loss is introduced to encourage the resource-agnostic representation so that the knowledge from high resource can be more compatible with low resource. To handle the resource data imbalance issue, we further propose a variant of the AD loss, termed Generalized Resource-Adversarial Discriminator (GRAD), to impose the resource weight during training so that low-resource and hard samples can be paid more attention to. In addition, we create adversarial samples to conduct the Adversarial Training (AT), further improving the generalization and alleviating over-fitting problem. We unify two kinds of adversarial learning, i.e., GRAD and AT, into one transfer learning model, termed Dual Adversarial Transfer Network (DATNet), to achieve end-to-end training and obtain the state-of-the-art performance on a series of NER tasks– $8 8 . 1 6 \\%$ F1 for CoNLL-2002 Spanish, $5 3 . 4 3 \\%$ and $4 2 . 8 3 \\%$ F1 for WNUT-2016 and 2017. Different from prior works, we do not use additional hand-crafted features and do not use cross-lingual word embeddings while addressing the cross-language tasks. ",
+        "bbox": [
+            174,
+            828,
+            823,
+            897
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            297
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            320,
+            344,
+            337
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Named Entity Recognition NER is typically framed as a sequence labeling task which aims at automatic detection of named entities (e.g., person, organization, location and etc.) from free text (Marrero et al., 2013). The early works applied CRF, SVM, and perception models with handcrafted features (Ratinov & Roth, 2009; Passos et al., 2014; Luo et al., 2015). With the advent of deep learning, research focus has been shifting towards deep neural networks (DNN), which requires little feature engineering and domain knowledge (Lample et al., 2016; Zukov Gregoric et al., 2018). Collobert et al. (2011) proposed a feed-forward neural network with a fixed sized window for each word, which failed in considering useful relations between long-distance words. To overcome this limitation, Chiu & Nichols (2016) presented a bidirectional LSTM-CNNs architecture that automatically detects word- and character-level features. Ma & Hovy (2016) further extended it into bidirectional LSTM-CNNs-CRF architecture, where the CRF module was added to optimize the output label sequence. Liu et al. (2018) proposed task-aware neural language model termed LMLSTM-CRF, where character-aware neural language models were incorporated to extract characterlevel embedding under a multi-task framework. ",
+        "bbox": [
+            174,
+            354,
+            825,
+            549
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Transfer Learning for NER Transfer learning can be a powerful tool to low resource NER tasks. To bridge high and low resource, transfer learning methods for NER can be divided into two types: the parallel corpora based transfer and the shared representation based transfer. Early works mainly focused on exploiting parallel corpora to project information between the high- and low-resource language (Yarowsky et al., 2001; Chen et al., 2010; Li et al., 2012; Feng et al., 2018). For example, Chen et al. (2010) and Feng et al. (2018) proposed to jointly identify and align bilingual named entities. On the other hand, the shared representation methods do not require the parallel correspondence (Rei & Søgaard, 2018). For instance, Fang & Cohn (2017) proposed cross-lingual word embeddings to transfer knowledge across resources. Yang et al. (2017) presented a transfer learning approach based on a deep hierarchical recurrent neural network (RNN), where full/partial hidden features between source and target tasks are shared. Ni et al. (Ni & Florian, 2016; Ni et al., 2017) utilized the Wikipedia entity type mappings to improve low-resource NER. Al-Rfou’ et al. (2015) built massive multilingual annotators with minimal human expertise by using language agnostic techniques. Mayhew et al. (2017) created a cross-language NER system, which works well for very minimal resources by translate annotated data of high-resource into low-resource. Cotterell & Duh (2017) proposed character-level neural CRFs to jointly train and predict low- and high-resource languages. Pan et al. (2017) proposes a large-scale cross-lingual named entity dataset which contains 282 languages for evaluation. In addition, multi-task learning (Yang et al., 2016; Luong et al., 2016; Rei, 2017; Aguilar et al., 2017; Hashimoto et al., 2017; Lin et al., 2018) shows that jointly training on multiple tasks/languages helps improve performance. Different from transfer learning methods, multi-task learning aims at improving the performance of all the resources instead of low resource only. ",
+        "bbox": [
+            173,
+            555,
+            825,
+            861
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Adversarial Learning Adversarial learning originates from Generative Adversarial Nets (GAN) (Goodfellow et al., 2014), which shows impressing results in computer vision. Recently, many papers have tried to apply adversarial learning to NLP tasks. Liu et al. (2017) presented an adversarial multi-task learning framework for text classification. Gui et al. (2017) applied the adversarial discriminator to POS tagging for Twitter. Kim et al. (2017) proposed a language discriminator to enable language-adversarial training for cross-language POS tagging. Apart from adversarial discriminator, adversarial training is another concept originally introduced by (Szegedy et al., 2014; Goodfellow et al., 2015) to improve the robustness of image classification model by injecting malicious perturbations into input images. Recently, Miyato et al. (2017) proposed a semi-supervised text classification method by applying adversarial training, where for the first time adversarial perturbations were added onto word embeddings. Yasunaga et al. (2018) applied adversarial training to POS tagging. Different from all these adversarial learning methods, our method integrates both the adversarial discriminator and adversarial training in an unified framework to enable end-to-end training. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            242
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 DUAL ADVERSARIAL TRANSFER NETWORK (DATNET) ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            263,
+            666,
+            280
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we introduce DATNet in more details. We first describe a base model for NER, and then discuss two proposed transfer architectures for DATNet. ",
+        "bbox": [
+            173,
+            296,
+            826,
+            324
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/c12e79f3e88fd641871ac1c2081f1c626fa1b8792b17590e421f4bb59c842530.jpg",
+        "image_caption": [
+            "Figure 1: The general architecture of proposed models. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            344,
+            821,
+            535
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 BASIC ARCHITECTURE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            590,
+            374,
+            604
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We follow state-of-the-art models for NER task (Huang et al., 2015; Lample et al., 2016; Chiu & Nichols, 2016; Ma & Hovy, 2016), i.e., LSTM-CNNs-CRF based structure, to build the base model. It consists of the following pieces: character-level embedding, word-level embedding, BiLSTM for feature representation, and CRF as the decoder. The character-level embedding takes a sequence of characters in the word as atomic units input to derive the word representation that encodes the morphological information, such as root, prefix, and suffix. These character features are usually encoded by character-level CNN or BiLSTM, then concatenated with word-level embedding to form the final word vectors. On top of them, the network further incorporates the contextual information using BiLSTM to output new feature representations, which is subsequently fed into CRF layer to predict label sequence. Although both of the word-level layer and the character-level layer can be implemented using CNNs or RNNs, we use CNNs for extracting character-level and RNNs for extracting word-level representation. Fig. 1(a) shows the the architecture of the base model. ",
+        "bbox": [
+            173,
+            617,
+            825,
+            784
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 DUAL ADVERSARIAL TRANSFER ARCHITECTURE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            803,
+            557,
+            816
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2.1 CHARACTER-LEVEL ENCODER ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            829,
+            441,
+            843
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Previous works have shown that character features can boost sequence labeling performance by capturing morphological and semantic information (Lin et al., 2018). For low-resource dataset to obtain high-quality word features, character features learned from other language/domain may provide crucial information for labeling, especially for rare and out-of-vocabulary words. Character-level encoder usually contains BiLSTM (Lample et al., 2016) and CNN (Chiu & Nichols, 2016; Ma & Hovy, ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2016) approaches. In practice, Reimers & Gurevych (2017) observed that the difference between the two approaches is statistically insignificant in sequence labeling tasks, but character-level CNN is more efficient and has less parameters. Thus, we use character-level CNN and share character features between high- and low-resource tasks to enhance the representations of low-resource. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            159
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2.2 WORD-LEVEL ENCODER ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            179,
+            398,
+            193
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To learn a better word-level representation, we concatenate character-level features of each word with a latent word embedding as $\\mathbf { w } _ { i } = [ \\mathbf { w } _ { i } ^ { c h a r } , \\mathbf { w } _ { i } ^ { e m b } ]$ , where the latent word embedding $\\mathbf { w } _ { i } ^ { e m b }$ is initialized with pre-trained embeddings and fixed during training. One unique characteristic of NER is that the historical and future input for a given time step could be useful for label inference. To exploit such a characteristic, we use a bidirectional LSTM architecture (Hochreiter & Schmidhuber, 1997) to extract contextualized word-level features. In this way, we can gather the information from the past and future for a particular time frame $t$ as follows, $\\vec { \\mathbf { h } } _ { t } = \\mathtt { l s t m } ( \\vec { \\mathbf { h } } _ { t - 1 } , \\mathbf { w } _ { t } ) , \\ \\overleftarrow { \\mathbf { h } } _ { t } $ $\\left\\{ \\overline { { \\mathbf { h } } } _ { t } = \\right.$ $\\mathtt { l s t m } ( \\overleftarrow { \\mathbf { h } } _ { t + 1 } , \\mathbf { w } _ { t } )$ . After the LSTM layer, the representation of a word is obtained by concatenating its left and right context representation as follows, $\\mathbf h _ { t } = [ \\widehat { \\mathbf h } _ { t } , \\widetilde { \\mathbf h } _ { t } ]$ . ",
+        "bbox": [
+            174,
+            205,
+            825,
+            342
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To consider the resource representation difference on word-level features, we introduce two kinds of transferable word-level encoder in our model, namely DATNet-Full Share (DATNet-F) and DATNetPart Share (DATNet-P). In DATNet-F, all the BiLSTM units are shared by both resources while word embeddings for different resources are disparate. The illustrative figure is depicted in the Fig. 1(c). Different from DATNet-F, the DATNet-P decomposes the BiLSTM units into the shared component and the resource-related one, which is shown in the Fig. 1(b). ",
+        "bbox": [
+            174,
+            348,
+            825,
+            433
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2.3 GENERALIZED RESOURCE-ADVERSARIAL DISCRIMINATOR ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            452,
+            637,
+            465
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In order to make the feature representation extracted from the source domain more compatible with those from the target domain, we encourage the outputs of the shared BiLSTM part to be resourceagnostic by constructing a resource-adversarial discriminator, which is inspired by the LanguageAdversarial Discriminator proposed by Kim et al. (2017). Unfortunately, previous works did not consider the imbalance of training size for two resources. Specifically, the target domain consists of very limited labeled training data, e.g., 10 sentences. In contrast, labeled training data in the source domain are much richer, e.g., 10k sentences. If such imbalance was not considered during training, the stochastic gradient descent (SGD) optimization would make the model more biased to high resource (Lin et al., 2017b). To address this imbalance problem, we impose a weight $\\alpha$ on two resources to balance their influences. However, in the experiment we also observe that the easily classified samples from high resource comprise the majority of the loss and dominate the gradient. To overcome this issue, we further propose Generalized Resource-Adversarial Discriminator (GRAD) to enable adaptive weights for each sample (note that the sample here means each sentence of resource), which focuses the model training on hard samples. ",
+        "bbox": [
+            174,
+            477,
+            825,
+            672
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To compute the loss of GRAD, the output sequence of the shared BiLSTM is firstly encoded into a single vector via a self-attention module (Bahdanau et al., 2015), and then projected into a scalar $r$ via a linear transformation. The loss function of the resource classifier is formulated as: ",
+        "bbox": [
+            174,
+            679,
+            823,
+            720
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fb4734e92cf79b73ca9f975418b0d1cd0a507d203bfe5bbc9a4d5b8ca974ff59.jpg",
+        "text": "$$\n\\ell _ { G R A D } = - \\sum _ { i } \\{ \\mathbf { I } _ { i \\in \\mathcal { D } _ { S } } \\alpha ( 1 - r _ { i } ) ^ { \\gamma } \\log r _ { i } + \\mathbf { I } _ { i \\in \\mathcal { D } _ { T } } ( 1 - \\alpha ) r _ { i } ^ { \\gamma } \\log ( 1 - r _ { i } ) \\}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            238,
+            727,
+            725,
+            761
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { I } _ { i \\in \\mathcal { D } _ { S } } , \\mathbf { I } _ { i \\in \\mathcal { D } _ { T } }$ are the identity functions to denote whether a sentence is from high resource (source) and low resource (target), respectively; $\\alpha$ is a weighting factor to balance the loss contribution from high and low resource; the parameter $( 1 - r _ { i } ) ^ { \\gamma }$ (or $r _ { i } ^ { \\gamma }$ ) controls the loss contribution from individual samples by measuring the discrepancy between prediction and true label (easy samples have smaller contribution); and $\\gamma$ scales the contrast of loss contribution from hard and easy samples. In practice, the value of $\\gamma$ does not need to be tuned much and usually set as 2 in our experiment. Intuitively, the weighting factors $\\alpha$ and $( 1 - r _ { i } ) ^ { \\gamma }$ reduce the loss contribution from high resource and easy samples, respectively. Note that though the resource classifier is optimized to minimize the resource classification error, when the gradients originated from the resource classification loss are back-propagated to the other model parts than the resource classifier, they are negated for parameter updates so that these bottom layers are trained to be resource-agnostic. ",
+        "bbox": [
+            173,
+            770,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2.4 LABEL DECODER ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            349,
+            117
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The label decoder induces a probability distribution over sequences of labels, conditioned on the word-level encoder features. In this paper, we use a linear chain model based on the first-order Markov chain structure, termed the chain conditional random field (CRF) Lafferty et al. (2001), as the decoder. In this decoder, there are two kinds of cliques: local cliques and transition cliques. Specifically, local cliques correspond to the individual elements in the sequence. And transition cliques, on the other hand, reflect the evolution of states between two neighboring elements at time $t - 1$ and $t$ and we define the transition distribution as $\\theta$ . Formally, a linear-chain CRF can be written $\\begin{array} { r } { p ( \\mathbf { y } | \\mathbf { h } _ { 1 : T } ) = \\frac { 1 } { Z ( \\mathbf { h } _ { 1 : T } ) } \\exp \\left\\{ \\sum _ { t = 2 } ^ { T } \\theta _ { y _ { t - 1 } , y _ { t } } + \\sum _ { t = 1 } ^ { T } \\mathbf { W } _ { y _ { t } } \\mathbf { h } _ { t } \\right\\} } \\end{array}$ , where $Z ( \\mathbf { h } _ { 1 : T } )$ is a normalization term and $\\mathbf { y }$ is the sequence of predicted labels as follows: $\\mathbf { y } = y _ { 1 : T }$ . Model parameters are optimized to maximize this conditional log likelihood, which acts as the objective function of the model. We define the loss function for source and target resources as follows, $\\begin{array} { r } { \\ell _ { S } = - \\sum _ { i } \\log p ( \\mathbf { y } | \\mathbf { h } _ { 1 : T } ) } \\end{array}$ , $\\ell _ { T } =$ $\\begin{array} { r } { - \\sum _ { i } \\log p ( \\mathbf { y } | \\mathbf { h } _ { 1 : T } ) } \\end{array}$ . ",
+        "bbox": [
+            173,
+            130,
+            826,
+            308
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2.5 ADVERSARIAL TRAINING",
+        "text_level": 1,
+        "bbox": [
+            176,
+            327,
+            406,
+            342
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "So far our model can be trained end-to-end with standard back-propagation by minimizing the following loss: ",
+        "bbox": [
+            174,
+            353,
+            823,
+            382
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9fb7cf1f186e404920d937ab5013353c17fb14f303723b0073da6077b9c5d135.jpg",
+        "text": "$$\n\\ell = \\ell _ { G R A D } + \\ell _ { S } + \\ell _ { T }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            405,
+            395,
+            560,
+            411
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Recent works have demonstrated that deep learning models are fragile to adversarial examples Goodfellow et al. (2015). In computer vision, those adversarial examples can be constructed by changing a very small number of pixels, which are virtually indistinguishable to human perception (Pin-Yu et al., 2018). Recently, adversarial samples are widely incorporated into training to improve the generalization and robustness of the model, which is so-called adversarial training (AT) (Miyato et al., 2017). It emerges as a powerful regularization tool to stabilize training and prevent the model from being stuck in local minimum. In this paper, we explore AT in context of NER. To be specific, we prepare an adversarial sample by adding the original sample with a perturbation bounded by a small norm $\\epsilon$ to maximize the loss function as follows: ",
+        "bbox": [
+            173,
+            422,
+            825,
+            549
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9aa627b3cc788957e8a28a8dbd177ecb5542f175894321fb52bcd86f8e3b7913.jpg",
+        "text": "$$\n\\eta _ { \\mathbf { x } } = \\arg \\operatorname* { m a x } _ { \\eta : \\| \\eta \\| _ { 2 } \\leq \\epsilon } \\ell ( \\Theta ; \\mathbf { x } + \\eta )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            397,
+            560,
+            599,
+            587
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\Theta$ is the current model parameters set. However, we cannot calculate the value of $\\eta$ exactly in general, because the exact optimization with respect to $\\eta$ is intractable in neural networks. Following the strategy in Goodfellow et al. (2015), this value can be approximated by linearizing it as follows, ",
+        "bbox": [
+            174,
+            598,
+            825,
+            641
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0d461bc07d4cbeac3e127b210945e9763d99498076f9b92f28d50d81d011d955.jpg",
+        "text": "$$\n\\eta _ { \\mathbf { x } } = \\epsilon \\frac { \\mathbf { g } } { \\| \\mathbf { g } \\| _ { 2 } } , \\mathrm { w h e r e } \\mathbf { g } = \\nabla \\ell ( \\Theta ; \\mathbf { x } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            374,
+            651,
+            624,
+            683
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\epsilon$ can be determined on the validation set. In this way, adversarial examples are generated by adding small perturbations to the inputs in the direction that most significantly increases the loss function of the model. We find such $\\eta$ against the current model parameterized by $\\Theta$ , at each training step, and construct an adversarial example by ${ \\bf x } _ { a d v } = { \\bf x } + \\eta _ { \\bf x }$ . Noted that we generate this adversarial example on the word and character embedding layer, respectively, as shown in the Fig. 1(b) and 1(c). Then, the classifier is trained on the mixture of original and adversarial examples to improve the generalization. To this end, we augment the loss in Eqn. 2 and define the loss function for adversarial training as: ",
+        "bbox": [
+            173,
+            694,
+            825,
+            806
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/26c3cff52ea49bab4a0e7b6786af97c4186475b40103a30258d666d362992977.jpg",
+        "text": "$$\n\\ell _ { A T } = \\ell ( \\Theta ; \\mathbf { x } ) + \\ell ( \\Theta ; \\mathbf { x } _ { a d v } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            401,
+            811,
+            596,
+            829
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\ell ( \\Theta ; { \\mathbf x } ) , \\ell ( \\Theta ; { \\mathbf x } _ { a d v } )$ represents the loss from an original example and its adversarial counterpart, respectively. Note that we present the AT in a general form for the convenience of presentation. For different samples, the loss and parameters should correspond to their counterparts. For example, for the source data with word embedding $\\mathbf { w } _ { S }$ , the loss for AT can be defined as follows, $\\bar { \\ell _ { A T } } = \\ell ( \\Theta ; \\mathbf { w } _ { S } ) + \\ell ( \\Theta ; \\mathbf { w } _ { S , a d v } )$ with $\\mathbf { w } _ { S , a d v } = \\mathbf { w } _ { S } + \\eta _ { \\mathbf { w } _ { S } }$ and $\\ell = \\ell _ { G R A D } + \\ell _ { S }$ . Similarly, we can compute the perturbations $\\eta _ { \\mathbf { c } }$ for char-embedding and $\\eta _ { \\mathbf { w } _ { T } }$ for target word embedding. ",
+        "bbox": [
+            173,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            326,
+            118
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            133,
+            287,
+            148
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In order to evaluate the performance of DATNet, we conduct the experiments on following widely used NER datasets: CoNLL-2003 English NER (Kim & De, 2003), CoNLL-2002 Spanish & Dutch NER (Kim, 2002), WNUT-2016 & 2017 English Twitter NER (Zeman, 2017). The statistics of these datasets are described in Table 1. We use the official split of training/validation/test sets. Since our goal is to study the effects of transferring knowledge from high-resource dataset to low-resource dataset, unlike previous works (Collobert et al., 2011; Chiu & Nichols, 2016; Yang et al., 2017) to append one-hot gazetteer features to the input of the CRF layer, and the works (Partalas et al., 2016; Limsopatham & Collier, 2016; Aguilar et al., 2017) to introduce orthographic feature as additional input for learning social media NER in tweets, we do not experiment with hand-crafted features and only consider words and characters embeddings as the inputs of our model. To be noted, we used only train set for model training for all datasets except the WNUT-2016 NER dataset. Since in this dataset, all the previous studies merged the training and validation sets together for training, we followed the same way for fair comparison. Specifically, we use CoNLL-2003 English NER dataset as high-resource (i.e., source) for all the experiments on CoNLL and WNUT datasets, while CoNLL-2002 Spanish & Dutch NER datasets and WNUT-2016 & 2017 Twitter NER datasets as low-resource (i.e., target) in cross-language and cross-domain NER settings, respectively. ",
+        "bbox": [
+            173,
+            161,
+            825,
+            382
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/29341e6bf175142c4f735b15f3f97d8c9267116689aea131fb76cce1a3e4abe6.jpg",
+        "table_caption": [
+            "Table 1: Statistics of CoNLL and WNUT Named Entity Recognition Datasets. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Benchmark</td><td>Resource</td><td>Language</td><td># Training Tokens (# Entities)</td><td># Dev Tokens (# Entities)</td><td># Test Tokens (# Entities)</td></tr><tr><td>CoNLL-2003</td><td>English</td><td></td><td>204,567 (23,499)</td><td>51,578 (5,942)</td><td>46,666 (5,648)</td></tr><tr><td colspan=\"6\">Cross-language NER</td></tr><tr><td>CoNLL-2002</td><td>Target</td><td>Spanish</td><td>207,484 (18,797)</td><td>51,645 (4,351)</td><td>52.098 (3,558)</td></tr><tr><td>CoNLL-2002</td><td>Target</td><td>Dutch</td><td>202,931 (13,344)</td><td>37,761 (2.616)</td><td>68,994 (3.941)</td></tr><tr><td colspan=\"6\">Cross-domain NER</td></tr><tr><td>WNUT-2016</td><td>Target</td><td>English</td><td>46,469 (2,462)</td><td>16,261 (1,128)</td><td>61,908 (5,955)</td></tr><tr><td>WNUT-2017</td><td>Target</td><td>English</td><td>62,730 (3,160)</td><td>15,733 (1,250)</td><td>23,394 (1,740)</td></tr></table>",
+        "bbox": [
+            178,
+            422,
+            820,
+            545
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In addition to the CoNLL and WNUT datasets, we also experiment on the cross-language named entity dataset described in Pan et al. (2017), which contains datasets for 282 languages, to evaluate our methods and investigate the transferability of different linguistic families and branches in both low- and high-resource scenarios. We choose 9 languages in our experiment, where Galician (gl), West Frisian (fy), Ukrainian (uk) and Marathi (mr) are target languages, the corresponding source languages are Spanish (es), Dutch (nl), Russian $( r u )$ and Hindi (hi), and Arabic (ar) is also a source language, which is from different linguistic family. Following the setting in Cotterell & Duh (2017), we also simulate the low- and high-resource scenarios by creating 100 and 10,000 sentences split for training target language datasets, respectively. Then we create 1,000 sentences split for validation and test, respectively. For source languages, we create 10,000 sentence split for training only. For high-resource scenario, we only conduct experiments on Galician (gl-high) and Ukrainian (uk-high). The list of selected datasets are described in Table 2. ",
+        "bbox": [
+            173,
+            568,
+            825,
+            733
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/83dafb84daa367f902048f3bbc62ade5516e512de77742c2a2b5e0180769b71a.jpg",
+        "table_caption": [
+            "Table 2: List of Named Entity Recognition Datasets in Pan et al. (2017). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Language</td><td>Resource</td><td>Linguistic Family</td><td></td><td>Linguistic Branch # Training Sentences# Dev Sentences</td><td></td><td>：#Test Sentences</td></tr><tr><td>Spanish (es)</td><td>Source</td><td>Indo-European</td><td>Romance</td><td>10,000</td><td></td><td></td></tr><tr><td>Galician (gl/ gl-high)</td><td>Target</td><td>Indo-European</td><td>Romance</td><td>100 /10.000</td><td>1,000</td><td>1,000</td></tr><tr><td>Dutch (nl)</td><td>Source</td><td>Indo-European</td><td>Germanic</td><td>10,000</td><td></td><td></td></tr><tr><td>West Frisian (fy)</td><td>Target</td><td>Indo-European</td><td>Germanic</td><td>100</td><td>1,000</td><td>1,000</td></tr><tr><td>Russian (ru)</td><td>Source</td><td>Indo-European</td><td>Slavic</td><td>10,000</td><td></td><td></td></tr><tr><td>Ukrainian (uk /uk-high)</td><td>Target</td><td>Indo-European</td><td>Slavic</td><td>100 /10.000</td><td>1,000</td><td>1,000</td></tr><tr><td>Hindi (hi)</td><td>Source</td><td>Indo-European</td><td>Indo-Aryan</td><td>10.000</td><td></td><td></td></tr><tr><td>Marathi (mr)</td><td>Target</td><td>Indo-European</td><td>Indo-Aryan</td><td>100</td><td>1,000</td><td>1,000</td></tr><tr><td>Arabic (ar)</td><td>Source</td><td>Afro-Asiatic</td><td>Semitic</td><td>10.000</td><td>-</td><td>-</td></tr></table>",
+        "bbox": [
+            173,
+            772,
+            825,
+            912
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 EXPERIMENTAL SETUP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            375,
+            117
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We use 50-dimensional publicly available pre-trained word embeddings for English, Spanish and Dutch languages of CoNLL and WNUT datasets in our experiments, which are trained by word2vec package2 on the corresponding Wikipedia articles (2017-12-20 dumps) (Lin et al., 2018). For the named entity datasets selected from Pan et al. (2017), we use 300-dimensional pre-trained word embeddings trained by fastText package3 on Wikipedia (Bojanowski et al., 2017), and the 30- dimensional randomly initialized character embeddings are used for all the datasets. We set the filter number as 20 for char-level CNN and the dimension of hidden states of the word-level LSTM as 200 for both base model and DATNet-F. For DATNet-P, we set 100 for source, share, and target LSTMs dimension, respectively. Parameters optimization is performed by Adam optimizer (Kingma & Ba, 2014) with gradient clipping of 5.0 and learning rate decay strategy. We set the initial learning rate of $\\beta _ { 0 } ~ = ~ 0 . 0 0 1$ for all experiments. At each epoch $t$ , learning rate $\\beta _ { t }$ is updated using $\\beta _ { t } = \\beta _ { 0 } / ( 1 + \\rho \\times t )$ , where $\\rho$ is decay rate with 0.05. To reduce over-fitting, we also apply Dropout (Srivastava et al., 2014) to the embedding layer and the output of the LSTM layer, respectively. ",
+        "bbox": [
+            173,
+            130,
+            825,
+            310
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 COMPARISON WITH STATE-OF-THE-ART RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            328,
+            562,
+            342
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section, we compare our approach with state-of-the-art (SOTA) methods on CoNLL and WNUT benchmark datasets. In the experiment, we exploit all the source data (i.e., CoNLL-2003 English NER) and target data to improve performance of target tasks. The averaged results with standard deviation over 10 repetitive runs are summarized in Table 3, and we also report the best results on each task for fair comparison with other SOTA methods. From results, we observe that incorporating the additional resource is helpful to improve performance. DATNet-P model achieves the highest F1 score on CoNLL-2002 Spanish and second F1 score on CoNLL-2002 Dutch dataset while DATNet-F model beats others on WNUT-2016 and WNUT-2017 English Twitter datasets. Different from other state-of-the-art models, DATNets do not use any addition features4. ",
+        "bbox": [
+            174,
+            354,
+            825,
+            478
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/8fbc5242f710a2a9610dfcd56406972ac35e9ae13cdb1a1e052980196348a6e6.jpg",
+        "table_caption": [
+            "Table 3: Comparison with State-of-the-art Results in CoNLL and WNUT datasets (F1-score) "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Mode</td><td rowspan=\"2\">Methods</td><td rowspan=\"2\"></td><td colspan=\"2\">Additional Features</td><td colspan=\"2\">CoNLL Datasets</td><td colspan=\"2\">WNUT Datasets</td></tr><tr><td></td><td>POS Gazetteers Orthographic</td><td>Spanish</td><td>Dutch</td><td>WNUT-2016 WNUT-2017</td><td></td></tr><tr><td rowspan=\"7\">Mono-language /domain</td><td>Gillick et al. (2016)</td><td>×</td><td>×</td><td>×</td><td>82.59</td><td>82.84</td><td></td><td></td></tr><tr><td>Lample et al. (2016)</td><td>×</td><td>&lt;√√x</td><td>× &lt;</td><td>85.75</td><td>81.74</td><td>-</td><td></td></tr><tr><td>Partalas et al. (2016)</td><td></td><td></td><td></td><td>=</td><td>=</td><td>46.16</td><td></td></tr><tr><td>Limsopatham&amp; Collier (2016)</td><td></td><td></td><td></td><td></td><td>=</td><td>52.41</td><td></td></tr><tr><td rowspan=\"2\">Lin et al. (2017a)</td><td></td><td>√</td><td>√</td><td></td><td></td><td></td><td>40.42</td></tr><tr><td>Best Our Base Model Mean&amp; Std</td><td>×</td><td></td><td></td><td>85.53</td><td>85.55 44.96</td><td>35.20 34.67±0.34</td></tr><tr><td colspan=\"2\"></td><td></td><td>× √</td><td>× ×</td><td>85.35±0.15 85.24±0.21 85.77</td><td></td><td>44.37±0.31</td><td></td></tr><tr><td rowspan=\"8\">Cross-language</td><td colspan=\"2\">Yang et al. (2017)</td><td></td><td></td><td></td><td>85.19</td><td></td><td></td></tr><tr><td colspan=\"2\">Lin et al. (2018)</td><td></td><td></td><td>85.88</td><td>86.55 88.39</td><td></td><td></td></tr><tr><td colspan=\"2\">Feng et al. (2018)</td><td></td><td></td><td></td><td>86.42</td><td></td><td></td></tr><tr><td colspan=\"2\">von Däniken &amp; Cieliebak (2017)</td><td>×</td><td>√ ×</td><td>√</td><td></td><td></td><td>40.78</td></tr><tr><td rowspan=\"2\">Aguilar et al. (2017) DATNet-P</td><td></td><td>√</td><td></td><td>88.16</td><td>88.32</td><td>50.85</td><td>41.86</td></tr><tr><td>Best</td><td></td><td>×</td><td></td><td></td><td></td><td>41.12</td></tr><tr><td rowspan=\"2\">DATNet-F</td><td>Mean&amp; Std</td><td>×</td><td></td><td>87.89±0.18 87.04</td><td>87.77</td><td>88.09±0.13 50.41±0.32 53.43</td><td>40.52±0.38 42.83</td></tr><tr><td>Best Mean&amp; Std</td><td>×</td><td>×</td><td>×</td><td>86.79±0.20</td><td>87.52±0.19</td><td>53.03±0.24 42.32±0.32</td></tr></table>",
+        "bbox": [
+            174,
+            518,
+            825,
+            722
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 4 summarizes the results of our methods under different cross-language transfer settings as well as the comparison with Cotterell & Duh (2017). In this experiment, we study the transferability between languages not only from same linguistic family and branch, but also from different linguistic families or branches. According to the results, DATNets outperform the transfer method of Cotterell & Duh (2017) for both low- and high-resource scenarios within the same linguistic family and branch (i.e., in-family in-branch) transfer case. We also observe that: 1) For the low-resource scenario, transfer learning is significantly helpful for improving the performance of target datasets within both same and different linguistic family or branch (i.e., in/cross-family in/cross-branch) transfer cases, while the improvements are more prominent under the in-family in-branch case. 2) For the high-resource scenario, say, when the target language data is sufficient, the improvements of transfer learning are not very distinct compared with that for low-resource scenario under in-family in-branch case. We also find that there is no effect by transferring knowledge from Arabic to Galician and Ukrainian. We suspect that it is caused by the great linguistic differences between source and target languages, since, for example, Arabic and Galician are from totally different linguistic families. ",
+        "bbox": [
+            173,
+            736,
+            825,
+            834
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            214
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/5ab26db08b3f4e7ada1acba9a79fa9894fd42bc26bdb7ce10a5ab1741707cc2f.jpg",
+        "table_caption": [
+            "Table 4: Results of Varying Cross-language Transfer Settings in Pan et al. (2017) Datasets (F1-score). "
+        ],
+        "table_footnote": [
+            "\\* Base model means the model is trained by using target language dataset only. "
+        ],
+        "table_body": "<table><tr><td colspan=\"2\">Language</td><td rowspan=\"2\">Transferring Strategy</td><td colspan=\"2\">Cotterell &amp; Duh (2017)</td><td colspan=\"3\">Our Methods</td></tr><tr><td>Source</td><td>Target</td><td>Base Model</td><td>Transfer</td><td>Base Model</td><td>DATNet-P</td><td>DATNet-F</td></tr><tr><td>nl</td><td>fy</td><td>In-Family In-Branch</td><td>58.43</td><td>72.12</td><td>57.47</td><td>75.08</td><td>76.05</td></tr><tr><td>hi</td><td>fy</td><td>In-Family Cross-Branch</td><td>-</td><td>-</td><td>57.47</td><td>69.25</td><td>68.44</td></tr><tr><td>ar</td><td>fy</td><td>Cross-Family Cross-Branch</td><td>1</td><td>1</td><td>57.47</td><td>67.89</td><td>66.05</td></tr><tr><td>hi</td><td>mr</td><td>In-Family In-Branch</td><td>39.02</td><td>60.92</td><td>43.55</td><td>68.55</td><td>64.87</td></tr><tr><td>nl</td><td>mr</td><td>In-Family Cross-Branch</td><td>-</td><td>1</td><td>43.55</td><td>63.83</td><td>60.50</td></tr><tr><td>ar</td><td>mr</td><td>Cross-Family Cross-Branch</td><td>-</td><td>1</td><td>43.55</td><td>63.28</td><td>59.76</td></tr><tr><td>es</td><td>g</td><td>In-Family In-Branch</td><td>49.19</td><td>76.40</td><td>49.94</td><td>79.60</td><td>86.01</td></tr><tr><td>hi</td><td>g</td><td>In-Family Cross-Branch</td><td>-</td><td>-</td><td>49.94</td><td>60.57</td><td>61.68</td></tr><tr><td>ar</td><td>g</td><td>Cross-Family Cross-Branch</td><td></td><td>-</td><td>49.94</td><td>59.18</td><td>60.43</td></tr><tr><td>es</td><td>gl-high</td><td>In-Family In-Branch</td><td>89.42</td><td>89.46</td><td>92.78</td><td>93.14</td><td>93.02</td></tr><tr><td>ar</td><td>gl-high</td><td>Cross-Family Cross-Branch</td><td>-</td><td>1</td><td>92.78</td><td>92.63</td><td>92.21</td></tr><tr><td>ru</td><td>uk</td><td>In-Family In-Branch</td><td>60.65</td><td>76.74</td><td>61.48</td><td>79.02</td><td>80.76</td></tr><tr><td>hi</td><td>uk</td><td>In-Family Cross-Branch</td><td>1</td><td>-</td><td>61.48</td><td>72.73</td><td>73.84</td></tr><tr><td>ar</td><td>uk</td><td>Cross-Family Cross-Branch</td><td>-</td><td>1</td><td>61.48</td><td>71.55</td><td>72.24</td></tr><tr><td>ru</td><td>uk-high</td><td>In-Family In-Branch</td><td>87.39</td><td>87.42</td><td>93.29</td><td>93.62</td><td>93.51</td></tr><tr><td>ar</td><td>uk-high</td><td>Cross-Family Cross-Branch</td><td>-1</td><td>-</td><td>93.29</td><td>92.83</td><td>92.42</td></tr></table>",
+        "bbox": [
+            199,
+            251,
+            799,
+            443
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/f72145ff1803baccf438290560a949df8356f92a886dcdb22b498b0c0e817679.jpg",
+        "image_caption": [
+            "Figure 2: Comparison with Different Target Data Ratio, where AT stands for adversarial training, F(P)- Transfer denotes the DATNet-F(P) without AT. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            212,
+            482,
+            784,
+            689
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.4 TRANSFER LEARNING PERFORMANCE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            758,
+            478,
+            772
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this section, we investigate on improvements with transfer learning under multiple low-resource settings with partial target data. To simulate a low-resource setting, we randomly select subsets of target data with varying data ratio at 0.05, 0.1, 0.2, 0.4, 0.6, and 1.0. For example, 20,748 training tokens are sampled from the training set under a data ratio of $r ~ = ~ 0 . 1$ for the dataset CoNLL-2002 Spanish NER (Cf. Table 1). The results for cross-language and cross-domain transfer are shown in Fig. 2(a) and 2(b), respectively, where we compare the results with each part of DATNet under various data ratios. From those figures, we have the following observations: 1) both adversarial training and adversarial discriminator in DATNet consistently contribute to the performance improvement; 2) the transfer learning component in the DATNet consistently improve over the base model results and the improvement margin is more substantial when the target data ratio is lower. For example, when the data ratio is 0.05, DATNet-P model outperforms the base model by more than $4 \\%$ absolutely in F1-score on Spanish NER and DATNet-F model improves around $13 \\%$ absolutely in F1-score compared to base model on WNUT-2016 NER. ",
+        "bbox": [
+            173,
+            785,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/dad44cdf103cebd336b9a09e2d103ee0bc772e982dda6352266c537654a2fe06.jpg",
+        "table_caption": [
+            "Table 5: Experiments on Extremely Low Resource (F1-score). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">Tasks</td><td colspan=\"5\">CoNLL-2002 2Spanish NER</td><td colspan=\"5\">WNUT-2016 Twitter NER</td></tr><tr><td>#Target train sentences</td><td>10</td><td>50</td><td>100</td><td>200</td><td>500</td><td>1000</td><td>10</td><td>50</td><td>100</td><td>200 500</td><td>1000</td></tr><tr><td>Base</td><td>21.53</td><td>42.18</td><td>48.35</td><td>63.66</td><td>68.83</td><td>76.69</td><td>3.80 14.07</td><td>17.99</td><td>26.20</td><td>31.78</td><td>36.99</td></tr><tr><td>+ AT</td><td>19.23</td><td>41.01</td><td>50.46</td><td>64.83</td><td>70.85</td><td>77.91</td><td>4.34 16.87</td><td>18.43</td><td>26.32</td><td>35.68</td><td>41.69</td></tr><tr><td>+ P-Transfer</td><td>29.78</td><td>61.09</td><td>64.78</td><td>66.54</td><td>72.94</td><td>78.49</td><td>7.71 16.17</td><td>20.43</td><td>29.20</td><td>34.90</td><td>41.20</td></tr><tr><td>+ F-Transfer</td><td>39.72</td><td>63.00</td><td>63.36</td><td>66.39</td><td>72.88</td><td>78.04</td><td>15.26 20.04</td><td>26.60</td><td>32.22</td><td>38.35</td><td>44.81</td></tr><tr><td>DATNet-P</td><td>39.52</td><td>62.57</td><td>64.05</td><td>68.95</td><td>75.19</td><td>79.46</td><td>9.94 17.09</td><td>25.39</td><td>30.71</td><td>36.05</td><td>42.30</td></tr><tr><td>DATNet-F</td><td>44.52</td><td>63.89</td><td>66.67</td><td>68.35</td><td>74.24</td><td>78.56</td><td>17.14 22.59</td><td>28.41</td><td>32.48</td><td>39.20</td><td>45.25</td></tr></table>",
+        "bbox": [
+            173,
+            127,
+            825,
+            217
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            243,
+            825,
+            285
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In the second experiment, we further investigate DATNet on the extremely low resource cases, e.g., the number of training target sentences is 10, 50, 100, 200, 500 and 1,000. The setting is quite challenging and fewer previous works have studied before. The results are summarized in Table 5. We have two interesting observations 5: 1) DATNet-F outperforms DATNet-P on cross-language transfer when the target resource is extremely low, however, this situation is reversed when the target dataset size is large enough (here for this specific dataset, the threshold is 100 sentences); 2) DATNet-F is always superior to DATNet-P on cross-domain transfer. For the first observation, it is because DATNet-F with more shared hidden units is more efficient to transfer knowledge than DATNet-P when data size is extremely small. For the second observation, because cross-domain transfer are in the same language, more knowledge is common between the source and target domains, requiring more shared hidden features to carry with these knowledge compared to cross-language transfer. Therefore, for cross-language transfer with an extremely low resource and cross-domain transfer, we suggest using DATNet-F model to achieve better performance. As for cross-language transfer with relatively more training data, DATNet-P model is preferred. ",
+        "bbox": [
+            173,
+            292,
+            825,
+            487
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/38bd30d068e4b39c5cd4a5729fc9ffba13a24ca5e60e11bf15adfd7bfc834cd6.jpg",
+        "image_caption": [
+            "Figure 3: The visualization of extracted features from shared bidirectional-LSTM layer. The left, middle, and right figures show the results when no Adversarial Discriminator (AD), AD, and GRAD is performed, respectively. Red points correspond to the source CoNLL-2003 English examples, and blue points correspond to the target CoNLL-2002 Spanish examples. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            212,
+            520,
+            789,
+            669
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.5 ABLATION STUDY OF DATNET ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            762,
+            429,
+            776
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In the proposed DATNet, both GRAD and AT play important roles in low resource NER. In this experiment, we further investigate how GRAD and AT help transfer knowledge across language/domain. In the first experiment6, we used t-SNE (Maaten & Hinton, 2008) to visualize the feature distribution of BiLSTM outputs without AD, with normal AD (GRAD without considering data imbalance), and with the proposed GRAD in Figure 3. From this figure, we can see that the GRAD in DATNet makes the distribution of extracted features from the source and target datasets much more similar by considering the data imbalance, which indicates that the outputs of BiLSTM are resource-invariant. ",
+        "bbox": [
+            173,
+            787,
+            825,
+            872
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/879c87615ce1b3fa60f22a527f9ddcf6bd7aea8e9e18bf9b6d089cd55c78a8db.jpg",
+        "table_caption": [
+            "Table 6: Quantitative Performance Comparison between Models with Different Components. "
+        ],
+        "table_footnote": [
+            "\\* AT: Adversarial Training; P-T: P-Transfer; F-T: F-Transfer; AD: Adversarial Discriminator; GRAD: Generalized Resource-Adversarial Discriminator. "
+        ],
+        "table_body": "<table><tr><td colspan=\"4\">CoNLL-2002 Spanish NER</td><td colspan=\"4\">WNUT-2016TwitterNER</td></tr><tr><td>Model</td><td>F1-score</td><td>Model</td><td>F1-score</td><td>Model</td><td>F1-score</td><td>Model</td><td>F1-score</td></tr><tr><td>Base</td><td>85.35</td><td>+AT</td><td>86.12</td><td>Base</td><td>44.37</td><td>+AT</td><td>47.41</td></tr><tr><td>+P-T (no AD)</td><td>86.15</td><td>+AT +P-T (no AD)</td><td>86.90</td><td>+P-T (no AD)</td><td>47.66</td><td>+AT +P-T (no AD)</td><td>48.44</td></tr><tr><td>+F-T (no AD)</td><td>85.46</td><td>+AT +F-T (no AD)</td><td>86.17</td><td>+F-T (no AD)</td><td>49.79</td><td>+AT +F-T (no AD)</td><td>50.93</td></tr><tr><td>+P-T (AD)</td><td>86.32</td><td>+AT +P-T (AD)</td><td>87.19</td><td>+P-T (AD)</td><td>48.14</td><td>+AT+P-T (AD)</td><td>49.41</td></tr><tr><td>+F-T(AD)</td><td>85.58</td><td>+AT +F-T (AD) +AT +P-T (GRAD)</td><td>86.38</td><td>+F-T(AD)</td><td>50.48</td><td>+AT +F-T (AD)</td><td>51.84</td></tr><tr><td>+P-T (GRAD)</td><td>86.93</td><td>(DATNet-P)</td><td>88.16</td><td>+P-T (GRAD)</td><td>48.91</td><td>+AT+P-T (GRAD) (DATNet-P)</td><td>50.85</td></tr><tr><td>+F-T(GRAD)</td><td>85.91</td><td>+AT+F-T (GRAD) (DATNet-F)</td><td>87.04</td><td>+F-T(GRAD)</td><td>51.31</td><td>+AT +F-T (GRAD) (DATNet-F)</td><td>53.43</td></tr></table>",
+        "bbox": [
+            209,
+            166,
+            789,
+            284
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "To better understand the working mechanism, Table 6 further reports the quantitative performance comparison between models with different components. We observe that GRAD shows the stable superiority over the normal AD regardless of other components. There are no always winner between DATNet-P and DATNet-F on different settings. DATNet-P architecture is more suitable to cross-language transfer while DATNet-F is more suitable to cross-domain transfer. ",
+        "bbox": [
+            173,
+            319,
+            825,
+            388
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/b008a19b7e8bd708e0846846d7a5e4727332b2f74bcb1de9f2500d1cdd018006.jpg",
+        "table_caption": [
+            "Table 7: Analysis of Maximum Perturbation $\\epsilon _ { \\mathbf { w } _ { T } }$ in AT with Varying Data Ratio $\\rho$ (F1-score). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>EwT</td><td>1.0</td><td>3.0</td><td>5.0</td><td>7.0</td><td>9.0</td></tr><tr><td>Ratio</td><td colspan=\"5\">CoNLL-2002 Spanish NER</td></tr><tr><td>p=0.1</td><td>75.90</td><td>76.23</td><td>77.38</td><td>77.77</td><td>78.13</td></tr><tr><td>p=0.2</td><td>81.54</td><td>81.65</td><td>81.32</td><td>81.81</td><td>81.68</td></tr><tr><td>p=0.4</td><td>83.62</td><td>83.83</td><td>83.43</td><td>83.99</td><td>83.40</td></tr><tr><td>p=0.6</td><td>84.44</td><td>84.47</td><td>84.72</td><td>84.04</td><td>84.05</td></tr></table>",
+        "bbox": [
+            352,
+            426,
+            643,
+            501
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "From the previous results, we know that AT helps enhance the overall performance by adding perturbations to inputs with the limit of $\\epsilon = 5$ , i.e., $\\| \\bar { \\boldsymbol { \\eta } } \\| _ { 2 } \\le 5$ . In this experiment, we further investigate how target perturbation $\\epsilon _ { \\mathbf { w } _ { T } }$ with fixed source perturbation ${ \\epsilon _ { { \\bf w } _ { S } } } = 5$ in AT affects knowledge transfer and the results on Spanish NER are summarized in Table 7. The results generally indicate that less training data require a larger $\\epsilon$ to prevent over-fitting, which further validates the necessity of AT in the case of low resource data. ",
+        "bbox": [
+            173,
+            512,
+            825,
+            597
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/66ce326e1f55e4e7567de0a4b932b55e1fa58c164549af21c66b846305090d8c.jpg",
+        "table_caption": [
+            "Table 8: Analysis of Discriminator Weight $\\alpha$ in GRAD with Varying Data Ratio $\\rho$ (F1-score). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>α</td><td>0.1</td><td>0.15</td><td>0.2</td><td>0.25</td><td>0.3</td><td>0.35</td><td>0.4</td><td>0.45</td><td>0.5</td><td>0.55</td><td>0.6</td><td>0.65</td><td>0.7</td><td>0.75</td><td>0.8</td></tr><tr><td>Ratio</td><td></td><td></td><td></td><td></td><td></td><td></td><td>CoNLL-2002 Spanish NER</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>p=0.1</td><td>78.37</td><td>78.63</td><td>78.70</td><td>78.32</td><td>77.96</td><td>77.92</td><td>77.88</td><td>77.78</td><td>77.85</td><td>77.90</td><td>77.65</td><td>77.57</td><td>77.38</td><td>77.49</td><td>77.29</td></tr><tr><td>p=0.2</td><td>80.99</td><td>81.71</td><td>82.18</td><td>81.57</td><td>81.53</td><td>81.55</td><td>81.44</td><td>81.25</td><td>81.32</td><td>81.16</td><td>81.02</td><td>81.16</td><td>80.63</td><td>80.79</td><td>80.54</td></tr><tr><td>p=0.4</td><td>83.76</td><td>83.73</td><td>84.18</td><td>84.48</td><td>84.26</td><td>84.12</td><td>83.54</td><td>83.40</td><td>83.52</td><td>84.18</td><td>83.42</td><td>83.47</td><td>83.28</td><td>83.33</td><td>83.19</td></tr><tr><td>p=0.6</td><td>85.18</td><td>85.24</td><td>85.85</td><td>85.68</td><td>85.84</td><td>86.10</td><td>85.71</td><td>85.74</td><td>85.42</td><td>85.60</td><td>85.20</td><td>85.40</td><td>85.26</td><td>85.24</td><td>84.98</td></tr></table>",
+        "bbox": [
+            173,
+            631,
+            830,
+            707
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Finally, we analyze the discriminator weight $\\alpha$ in GRAD and results are summarized in Table 8. From the results, it is interesting to find that $\\alpha$ is directly proportional to the data ratio $\\rho$ , basically, which means that more target training data requires larger $\\alpha$ (i.e., smaller $1 - \\alpha$ to reduce training emphasis on the target domain) to achieve better performance. ",
+        "bbox": [
+            173,
+            720,
+            825,
+            777
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            795,
+            318,
+            811
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this paper we develop a transfer learning model DATNet for low-resource NER, which aims at addressing two problems remained in existing work, namely representation difference and resource data imbalance. We introduce two variants of DATNet, DATNet-F and DATNet-P, which can be chosen for use according to the cross-language/domain user case and the target dataset size. To improve model generalization, we propose dual adversarial learning strategies, i.e., AT and GRAD. Extensive experiments show the superiority of DATNet over existing models and it achieves new state-of-the-art performance on CoNLL NER and WNUT NER benchmark datasets. ",
+        "bbox": [
+            173,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            287,
+            117
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Oliver Adams, Adam Makarucha, Graham Neubig, Steven Bird, and Trevor Cohn. Cross-lingual word embeddings for low-resource language modeling. In EACL, pp. 937–947. Association for Computational Linguistics, 2017. ",
+        "bbox": [
+            176,
+            126,
+            823,
+            169
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Gustavo Aguilar, Suraj Maharjan, Adrian Pastor Lopez Monroy, and Thamar Solorio. A multi-task ´ approach for named entity recognition in social media data. In Proceedings of the 3rd Workshop on Noisy User-generated Text, pp. 148–153, 2017. ",
+        "bbox": [
+            176,
+            179,
+            823,
+            222
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Rami Al-Rfou’, Vivek Kulkarni, Bryan Perozzi, and Steven Skiena. Polyglot-ner: Massive multilingual named entity recognition. In SDM, 2015. ",
+        "bbox": [
+            173,
+            231,
+            821,
+            261
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dzmitry Bahdanau, KyungHyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. In ICLR, 2015. ",
+        "bbox": [
+            174,
+            270,
+            821,
+            299
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Piotr Bojanowski, Edouard Grave, Armand Joulin, and Tomas Mikolov. Enriching word vectors with subword information. Transactions of the Association for Computational Linguistics, 5:135–146, 2017. ",
+        "bbox": [
+            173,
+            309,
+            825,
+            352
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yufeng Chen, Chengqing Zong, and Keh-Yih Su. On jointly recognizing and aligning bilingual named entities. In ACL, pp. 631–639, 2010. ",
+        "bbox": [
+            174,
+            361,
+            823,
+            392
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jason Chiu and Eric Nichols. Named entity recognition with bidirectional lstm-cnns. Transactions of the Association for Computational Linguistics, 4:357–370, 2016. ",
+        "bbox": [
+            173,
+            400,
+            823,
+            430
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ronan Collobert, Jason Weston, Leon Bottou, Michael Karlen, Koray Kavukcuoglu, and Pavel ´ Kuksa. Natural language processing (almost) from scratch. JMLR, pp. 2493–2537, 2011. ",
+        "bbox": [
+            171,
+            439,
+            823,
+            469
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ryan Cotterell and Kevin Duh. Low-resource named entity recognition with cross-lingual, character-level neural conditional random fields. In Proceedings of the Eighth International Joint Conference on Natural Language Processing (Volume 2: Short Papers), pp. 91–96. Asian Federation of Natural Language Processing, 2017. ",
+        "bbox": [
+            173,
+            478,
+            825,
+            536
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Meng Fang and Trevor Cohn. Model transfer for tagging low-resource languages using a bilingual dictionary. In ACL, pp. 587–593, 2017. ",
+        "bbox": [
+            173,
+            545,
+            823,
+            575
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xiaocheng Feng, Xiachong Feng, Bing Qin, Zhangyin Feng, and Ting Liu. Improving low resource named entity recognition using cross-lingual knowledge transfer. In IJCAI, pp. 4071–4077, 2018. ",
+        "bbox": [
+            173,
+            583,
+            823,
+            613
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dan Gillick, Cliff Brunk, Oriol Vinyals, and Amarnag Subramanya. Multilingual language processing from bytes. In NAACL HLT, pp. 1296–1306, 2016. ",
+        "bbox": [
+            173,
+            622,
+            823,
+            652
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in neural information processing systems, 2014. ",
+        "bbox": [
+            173,
+            661,
+            825,
+            705
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. In ICLR, 2015. ",
+        "bbox": [
+            169,
+            714,
+            823,
+            743
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tao Gui, Qi Zhang, Haoran Huang, Minlong Peng, and Xuanjing Huang. Part-of-speech tagging for twitter with adversarial neural networks. In EMNLP, pp. 2411–2420, 2017. ",
+        "bbox": [
+            173,
+            752,
+            823,
+            784
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kazuma Hashimoto, caiming xiong, Yoshimasa Tsuruoka, and Richard Socher. A joint many-task model: Growing a neural network for multiple nlp tasks. In EMNLP, pp. 1923–1933, 2017. ",
+        "bbox": [
+            171,
+            792,
+            823,
+            821
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 1997. ",
+        "bbox": [
+            174,
+            830,
+            807,
+            847
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zhiheng Huang, Wei Xu, and Kai Yu. Bidirectional lstm-crf models for sequence tagging. CoRR, abs/1508.01991, 2015. ",
+        "bbox": [
+            173,
+            856,
+            823,
+            886
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Joo-Kyung Kim, Young-Bum Kim, Ruhi Sarikaya, and Eric Fosler-Lussier. Cross-lingual transfer learning for pos tagging without cross-lingual resources. In EMNLP, pp. 2832–2838, 2017. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sang Erik F. Tjong Kim. Introduction to the conll-2002 shared task: Language-independent named entity recognition. In COLING-02: The 6th Conference on Natural Language Learning 2002 (CoNLL-2002), 2002. ",
+        "bbox": [
+            173,
+            103,
+            821,
+            146
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sang Erik F. Tjong Kim and Meulder Fien De. Introduction to the conll-2003 shared task: Languageindependent named entity recognition. In NAACL HLT, 2003. ",
+        "bbox": [
+            173,
+            154,
+            823,
+            184
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. CoRR, 2014. ",
+        "bbox": [
+            173,
+            191,
+            800,
+            208
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "John D. Lafferty, Andrew McCallum, and Fernando C. N. Pereira. Conditional random fields: Probabilistic models for segmenting and labeling sequence data. In Proceedings of the Eighteenth International Conference on Machine Learning, ICML ’01, 2001. ",
+        "bbox": [
+            174,
+            214,
+            821,
+            258
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Guillaume Lample, Miguel Ballesteros, Sandeep Subramanian, Kazuya Kawakami, and Chris Dyer. Neural architectures for named entity recognition. In NAACL HLT, pp. 260–270, 2016. ",
+        "bbox": [
+            173,
+            266,
+            823,
+            296
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Qi Li, Haibo Li, Heng Ji, Wen Wang, Jing Zheng, and Fei Huang. Joint bilingual name tagging for parallel corpora. In CIKM ’12, pp. 1727–1731, 2012. ",
+        "bbox": [
+            171,
+            303,
+            823,
+            333
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Nut Limsopatham and Nigel Collier. Bidirectional lstm for named entity recognition in twitter messages. In Proceedings of the 2nd Workshop on Noisy User-generated Text (WNUT), pp. 145– 152, 2016. ",
+        "bbox": [
+            174,
+            340,
+            823,
+            383
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Bill Y. Lin, Frank Xu, Zhiyi Luo, and Kenny Zhu. Multi-channel bilstm-crf model for emerging named entity recognition in social media. In Proceedings of the 3rd Workshop on Noisy Usergenerated Text, pp. 160–165, 2017a. ",
+        "bbox": [
+            174,
+            391,
+            823,
+            435
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "T. Lin, P. Goyal, R. Girshick, K. He, and P. Dollar. Focal loss for dense object detection. In 2017 IEEE International Conference on Computer Vision (ICCV), 2017b. ",
+        "bbox": [
+            171,
+            443,
+            823,
+            472
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ying Lin, Shengqi Yang, Veselin Stoyanov, and Heng Ji. A multi-lingual multi-task architecture for low-resource sequence labeling. In ACL, 2018. ",
+        "bbox": [
+            171,
+            479,
+            823,
+            510
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "L. Liu, J. Shang, F. Xu, X. Ren, H. Gui, J. Peng, and J. Han. Empower sequence labeling with task-aware neural language model. In AAAI, 2018. ",
+        "bbox": [
+            171,
+            517,
+            823,
+            546
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Pengfei Liu, Xipeng Qiu, and Xuanjing Huang. Adversarial multi-task learning for text classification. In ACL, 2017. ",
+        "bbox": [
+            171,
+            554,
+            823,
+            584
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Gang Luo, Xiaojiang Huang, Chin-Yew Lin, and Zaiqing Nie. Joint entity recognition and disambiguation. In EMNLP, pp. 879–888, 2015. ",
+        "bbox": [
+            171,
+            592,
+            823,
+            622
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Minh-Thang Luong, Quoc V. Le, Ilya Sutskever, Oriol Vinyals, and Lukasz Kaiser. Multi-task sequence to sequence learning. In ICLR, 2016. ",
+        "bbox": [
+            171,
+            628,
+            823,
+            660
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Xuezhe Ma and Eduard Hovy. End-to-end sequence labeling via bi-directional lstm-cnns-crf. In ACL, pp. 1064–1074, 2016. ",
+        "bbox": [
+            169,
+            666,
+            823,
+            696
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Laurens van der Maaten and Geoffrey Hinton. Visualizing data using t-sne. JMLR, 9:2579–2605, 2008. ",
+        "bbox": [
+            169,
+            704,
+            825,
+            733
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Monica Marrero, Juli ´ an Urbano, Sonia S ´ anchez-Cuadrado, Jorge Morato, and Juan Miguel G ´ omez- ´ Berb´ıs. Named entity recognition: Fallacies, challenges and opportunities. Computer Standards & Interfaces, (5):482–489, 2013. ",
+        "bbox": [
+            174,
+            741,
+            825,
+            784
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Stephen Mayhew, Chen-Tse Tsai, and Dan Roth. Cheap translation for cross-lingual named entity recognition. In Proceedings of the 2017 Conference on Empirical Methods in Natural Language Processing, pp. 2536–2545. Association for Computational Linguistics, 2017. ",
+        "bbox": [
+            174,
+            792,
+            823,
+            835
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Takeru Miyato, Andrew M Dai, and Ian Goodfellow. Adversarial training methods for semisupervised text classification. In ICLR, 2017. ",
+        "bbox": [
+            173,
+            843,
+            820,
+            873
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jian Ni and Radu Florian. Improving multilingual named entity recognition with wikipedia entity type mapping. In Proceedings of the 2016 Conference on Empirical Methods in Natural Language Processing, pp. 1275–1284, 2016. ",
+        "bbox": [
+            174,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jian Ni, Georgiana Dinu, and Radu Florian. Weakly supervised cross-lingual named entity recognition via effective annotation and representation projection. In ACL, pp. 1470–1480, 2017. ",
+        "bbox": [
+            171,
+            103,
+            821,
+            132
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Xiaoman Pan, Boliang Zhang, Jonathan May, Joel Nothman, Kevin Knight, and Heng Ji. Crosslingual name tagging and linking for 282 languages. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp. 1946–1958. Association for Computational Linguistics, 2017. ",
+        "bbox": [
+            173,
+            140,
+            825,
+            196
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Ioannis Partalas, Cedric Lopez, Nadia Derbas, and Ruslan Kalitvianski. Learning to search for rec-´ ognizing named entities in twitter. In Proceedings of the 2nd Workshop on Noisy User-generated Text (WNUT), pp. 171–177, 2016. ",
+        "bbox": [
+            178,
+            204,
+            823,
+            247
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Alexandre Passos, Vineet Kumar, and Andrew McCallum. Lexicon infused phrase embeddings for named entity resolution. arXiv preprint arXiv:1404.5367, 2014. ",
+        "bbox": [
+            173,
+            255,
+            823,
+            285
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Chen Pin-Yu, Sharma Yash, Zhang Huan, Yi Jinfeng, and Cho-Jui Hsieh. Ead: Elastic-net attacks to deep neural networks via adversarial examples. In AAAI, 2018. ",
+        "bbox": [
+            173,
+            291,
+            823,
+            321
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Lev Ratinov and Dan Roth. Design challenges and misconceptions in named entity recognition. In Proceedings of the Thirteenth Conference on Computational Natural Language Learning, pp. 147–155, 2009. ",
+        "bbox": [
+            174,
+            329,
+            823,
+            372
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Marek Rei. Semi-supervised multitask learning for sequence labeling. In ACL, pp. 2121–2130, 2017. ",
+        "bbox": [
+            171,
+            380,
+            823,
+            409
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Marek Rei and Anders Søgaard. Zero-shot sequence labeling: Transferring knowledge from sentences to tokens. In NAACL HLT, pp. 293–302, 2018. ",
+        "bbox": [
+            173,
+            416,
+            823,
+            446
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Nils Reimers and Iryna Gurevych. Reporting score distributions makes a difference: Performance study of lstm-networks for sequence tagging. In EMNLP, pp. 338–348, 2017. ",
+        "bbox": [
+            171,
+            454,
+            823,
+            483
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: A simple way to prevent neural networks from overfitting. JMLR, pp. 1929–1958, 2014. ",
+        "bbox": [
+            178,
+            491,
+            821,
+            534
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Wojciech Zaremba, Dumitru Erhan Ian Goodfellow Ilya Sutskever, Joan Bruna, and Rob Fergus. Intriguing properties of neural networks. In ICLR, 2014. ",
+        "bbox": [
+            173,
+            541,
+            823,
+            570
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Pius von Daniken and Mark Cieliebak. Transfer learning and sentence level features for named ¨ entity recognition on tweets. In Proceedings of the 3rd Workshop on Noisy User-generated Text, pp. 166–171, 2017. ",
+        "bbox": [
+            174,
+            578,
+            821,
+            621
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Zhilin Yang, Ruslan Salakhutdinov, and William W. Cohen. Multi-task cross-lingual sequence tagging from scratch. CoRR, abs/1603.06270, 2016. ",
+        "bbox": [
+            169,
+            628,
+            823,
+            659
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Zhilin Yang, Ruslan Salakhutdinov, and William W. Cohen. Transfer learning for sequence tagging with hierarchical recurrent networks. In ICLR, 2017. ",
+        "bbox": [
+            169,
+            666,
+            823,
+            695
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "David Yarowsky, Grace Ngai, and Richard Wicentowski. Inducing multilingual text analysis tools via robust projection across aligned corpora. In Proceedings of the first international conference on Human language technology research, pp. 1–8, 2001. ",
+        "bbox": [
+            174,
+            703,
+            823,
+            747
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Michihiro Yasunaga, Jungo Kasai, and Dragomir Radev. Robust multilingual part-of-speech tagging via adversarial training. In NAACL HLT, pp. 976–986, 2018. ",
+        "bbox": [
+            169,
+            753,
+            823,
+            784
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Daniel et al. Zeman. Conll 2017 shared task: Multilingual parsing from raw text to universal dependencies. In Proceedings of the CoNLL 2017 Shared Task: Multilingual Parsing from Raw Text to Universal Dependencies, pp. 1–19, 2017. ",
+        "bbox": [
+            174,
+            791,
+            823,
+            834
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Boliang Zhang, Xiaoman Pan, Tianlu Wang, Ashish Vaswani, Heng Ji, Kevin Knight, and Daniel Marcu. Name tagging for low-resource incident languages based on expectation-driven learning. In NAACL HLT, pp. 249–259, 2016. ",
+        "bbox": [
+            173,
+            842,
+            823,
+            885
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Andrej Zukov Gregoric, Yoram Bachrach, and Sam Coope. Named entity recognition with parallel recurrent neural networks. In ACL, pp. 69–74, 2018. ",
+        "bbox": [
+            169,
+            892,
+            823,
+            921
+        ],
+        "page_idx": 12
+    }
+]

parse/train/IkYEJ5Cps5H/IkYEJ5Cps5H.md

@@ -0,0 +1,227 @@
+# SUCCINCT NETWORK CHANNEL AND SPATIAL PRUNING VIA DISCRETE VARIABLE QCQP
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Reducing the heavy computational cost of large convolutional neural networks is crucial when deploying the networks to resource-constrained environments. In this context, recent works propose channel pruning via greedy channel selection to achieve practical acceleration and memory footprint reduction. We first show this channel-wise approach ignores the inherent quadratic coupling between channels in the neighboring layers and cannot safely remove inactive weights during the pruning procedure. Furthermore, we show that these pruning methods cannot guarantee the given resource constraints are satisfied and cause discrepancy with the true objective. To this end, we formulate a principled optimization framework with discrete variable QCQP, which provably prevents any inactive weights and enables the exact guarantee of meeting the resource constraints in terms of FLOPs and memory. Also, we extend the pruning granularity beyond channels and jointly prune individual 2D convolution filters spatially for greater efficiency. Our experiments show competitive pruning results under the target resource constraints on CIFAR-10 and ImageNet datasets on various network architectures.
+
+# 1 INTRODUCTION
+
+Deep neural networks are the bedrock of artificial intelligence tasks such as object detection, speech recognition, and natural language processing (Redmon & Farhadi, 2018; Chorowski et al., 2015; Devlin et al., 2019). While modern networks have hundreds of millions to billions of parameters to train, it has been recently shown that these parameters are highly redundant and can be pruned without significant loss in accuracy (Han et al., 2015; Guo et al., 2016). This discovery has led practitioners to desire training and running the models on resource-constrained mobile devices, provoking a large body of research on network pruning.
+
+Unstructured pruning, however, does not directly lead to any practical acceleration or memory footprint reduction due to poor data locality (Wen et al., 2016), and this motivated research on structured pruning to achieve practical usage under limited resource budgets. To this end, a line of research on channel pruning considers completely pruning the convolution filters along the input and output channel dimensions, where the resulting pruned model becomes a smaller dense network suited for practical acceleration and memory footprint reduction (Li et al., 2017; Luo et al., 2017; He et al., 2019; Wen et al., 2016; He et al., 2018a).
+
+However, existing channel pruning methods perform the pruning operations with a greedy approach and does not consider the inherent quadratic coupling between channels in the neighboring layers. Although these methods are easy to model and optimize, they cannot safely remove inactive weights during the pruning procedure, suffer from discrepancies with the true objective, and prohibit the strict satisfaction of the required resource constraints during the pruning process.
+
+The ability to specify hard target resource constraints into the pruning optimization process is important since this allows the user to run the pruning and optional finetuning process only once. When the pruning process ignores the target specifications, the users may need to apply multiple rounds of pruning and finetuning until the specifications are eventually met, resulting in an extra computation overhead (Han et al., 2015; He et al., 2018a; Liu et al., 2017).
+
+In this paper, we formulate a principled optimization problem that prunes the network layer channels while respecting the quadratic coupling and exactly satisfying the user-specified FLOPs and memory constraints. This new formulation leads to an interesting discrete variable QCQP (Quadratic Constrained Quadratic Program) optimization problem, which directly maximizes the importance of neurons in the pruned network under the specified resource constraints. Also, we increase the pruning granularity beyond channels and jointly prune individual 2D convolution filters spatially for greater efficiency. Furthermore, we generalize our formulation to cover nonsequential convolution operations, such as skip connections, and propose a principled optimization framework for handling various architectural implementations of skip connections in ResNet (He et al., 2016). Our experiments on CIFAR-10 and ImageNet datasets show the state of the art results compared to other channel pruning methods that start from pretrained networks.
+
+![](images/30607c2e56d734ec141791edf273f5b524a27effd00ad6c64c08ad72be07d27d.jpg)  
+Figure 1: Illustration of a channel pruning procedure that leads to inactive weights. When $j$ -th output channel of $l$ -th convolution weights $W _ { \cdot , j } ^ { ( \bar { l } ) }$ is pruned, i.e. $W _ { \cdot , j } ^ { ( l ) } = 0 _ { C _ { l - 1 } , K _ { l } , K _ { l } }$ , then the $j$ -th feature map of l-th layer X (l)j should also be 0. Consequently, $X _ { j } ^ { ( l ) }$ yields inactive weights $W _ { j } ^ { ( l + 1 ) }$ . Note that we use W (l)·,j to denote the tensor $W _ { \cdot , j , \cdot , \cdot } ^ { ( l ) } .$ , following the indexing rules of NumPy (Van Der Walt et al., 2011).
+
+# 2 MOTIVATION
+
+In this section, we first discuss the motivation of our method concretely. Suppose the weights in a sequential CNN form a sequence of 4-D tensors, $W ^ { ( l ) } \in \mathbb { R } ^ { C _ { l - 1 } \times C _ { l } \times K _ { l } \times K _ { l } } \forall \bar { l } \in [ L ]$ where $C _ { l - 1 } , C _ { l }$ , and $K _ { l }$ represent the number of input channels, the number of output channels, and the filter size of $l$ -th convolution weight tensor, respectively. We denote the feature map after $l$ -th convolution as $X ^ { ( l ) } \in \mathbb { R } ^ { C _ { l } \times H _ { l } \times W _ { l } }$ . Con, ncretely, denotes $X _ { j } ^ { ( \bar { l } ) } = \sigma ( X _ { \cdot } ^ { ( l - 1 ) } \odot W _ { \cdot , j } ^ { ( l ) } ) = \sigma ( \sum _ { i = 1 } ^ { C _ { l - 1 } } \bar { X } _ { i \ \cdot } ^ { ( l - 1 ) } * W _ { i , j } ^ { ( l ) } )$ , where hannel- $\sigma$ isse $^ *$ $\odot$   
+2-D convolutions. Now consider pruning these weights in channel-wise direction. We show that naive channel-wise pruning methods prevent exact specification of the target resource constraints due to unpruned inactive weights and deviate away from the true objective by ignoring quadratic coupling between channels in the neighboring layers.
+
+# 2.1 INACTIVE WEIGHTS
+
+According to Han et al. (2015), network pruning produces dead neurons with zero input or output connections. These dead neurons cause inactive weights1, which do not affect the final output activations of the pruned network. These inactive weights may not be excluded automatically through the standard pruning procedure and require additional post-processing which relies on ad-hoc heuristics. For example, Figure 1 shows a standard channel pruning procedure that deletes weights across the output channel direction but fails to prune the inactive weights. Concretely, deletion of j el of l-th convolution layer leads to W (l)·,j weights on becomes a -th output channead neuron since $W _ { \cdot , j } ^ { ( l ) } = 0 _ { C _ { l - 1 } , K _ { l } , K _ { l } }$ $X _ { j } ^ { ( l ) }$ $\begin{array} { r } { \boldsymbol { X } _ { j } ^ { ( l ) } = \sigma ( \boldsymbol { X } ^ { ( l - 1 ) } \odot \boldsymbol { W } _ { \cdot , j } ^ { ( l ) } ) = \sigma ( \sum _ { i = 1 } ^ { { C } _ { l - 1 } } \boldsymbol { X } _ { i } ^ { ( l - 1 ) } * \boldsymbol { W } _ { i , j } ^ { ( l ) } ) = \boldsymbol { 0 } _ { C _ { l } , H _ { l } , W _ { l } } . } \end{array}$
+
+The convolution operation on the dead neuron results in a trivially zero output, as below:
+
+$$
+X _ { p } ^ { ( l + 1 ) } = \sigma \left( \sum _ { i = 1 } ^ { C _ { l } } X _ { i } ^ { ( l ) } * W _ { i , p } ^ { ( l + 1 ) } \right) = \sigma \left( \sum _ { i = 1 } ^ { C _ { l } } \mathbb { 1 } _ { i \neq j } X _ { i } ^ { ( l ) } * W _ { i , p } ^ { ( l + 1 ) } + \underbrace { X _ { j } ^ { ( l ) } * \underbrace { W _ { j , p } ^ { ( l + 1 ) } } _ { \mathrm { d e a d } } } _ { = \mathbb { 0 } _ { H _ { l + 1 } , W _ { l + 1 } } } \right) .
+$$
+
+Equation (1) shows that the dead neuron X(l)j causes weights W (l+1)j,p , $W _ { j , p } ^ { ( l + 1 ) } , \forall p \in [ C _ { l + 1 } ]$ to be inactive. Such inactive weights do not account for the actual resource usage, even when they remain in the pruned network, which prevents the exact modeling of the user-specified hard resource constraints (FLOPs and network size). Furthermore, inactive weights unpruned during the pruning procedure are a bigger problem for nonsequential convolutional networks due to their skip connections. To address this problem, we introduce a quadratic optimization-based algorithm that provably eliminates all the inactive weights during the pruning procedure.
+
+# 2.2 QUADRATIC COUPLING
+
+![](images/1a7cf02ee11375b60d23ae20a288b50d1f0a3933ed1213db30253f98b7026be9.jpg)  
+Figure 2: A comparison of the greedy channel pruning method and our pruning method. Parallelograms represent feature maps and squares represent 2-D filters of convolution weights. Gray squares are filters which account for the objective. The numbers on each squares represent the absolute sum of weights in the filter.
+
+Existing channel pruning methods remove channels according to their importance. However, measuring a channel’s contribution to the network should also take into account the channels in the neighboring layers, as illustrated in Figure 2. In the example, we define the importance of a channel as the absolute sum of weights in the channel, as in Li et al. (2017), and assume the objective is to maximize the absolute sum of weights in the whole pruned network, excluding the inactive weights. We compare two different channel pruning methods: (a) a standard channel pruning method that greedily prunes each channel independently, and (b) our pruning method that considers the effect of the channels in neighboring layers when pruning. As a result of running each pruning algorithms, (a) will prune the second output channel of the first convolution and the third output channel of the second convolution, and (b) will prune the first output channel of the first convolution, the third output channel of the second convolution, and the first input channel of the second convolution. The objective values for each pruned networks are (a) 18 and (b) 21, respectively.
+
+This shows that the coupling effect of the channels in neighboring layers directly affects the objective values, and finally results in a performance gap between (a) and (b). We call this coupling relationship as the quadratic coupling between the neighboring layers and formulate the contributions to the objective by quadratic terms of neighboring channel activations. To address this quadratic coupling, we propose a channel pruning method based on the QCQP framework with importance evaluation respecting both the input and the output channels.
+
+# 3 METHOD
+
+In this section, we first propose our discrete QCQP formulation of channel pruning for the sequential convolutional neural networks (CNNs). Then, we present an extended version of our formulation for joint channel and shape pruning of 2D convolution filters. The generalization to the nonsequential convolution (skip addition and skip concatenation) is introduced in Supplementary material A.
+
+To capture the importance of weights in $W ^ { ( l ) }$ , we define the importance tensor as $I ^ { ( l ) } \in \Sigma ^ { }$ $\mathbb { R } _ { + } ^ { C _ { l - 1 } \times C _ { l } \times K _ { l } \times K _ { l } }$ . Following the protocol of Han et al. (2015); Guo et al. (2016), we set $I ^ { ( i ) } = \gamma _ { l } | W ^ { ( l ) } |$ where $\gamma _ { l }$ is the $\ell _ { 2 }$ normalizing factor in $l$ -th layer or $\lVert \mathrm { v e c } ( W ^ { ( l ) } ) \rVert ^ { - 1 }$ . Then, we define the binary pruning mask as $A ^ { ( l ) } \in \{ 0 , 1 \} ^ { C _ { l - 1 } \times C _ { l } \times K _ { l } \times K _ { l } }$ . For channel pruning in sequential CNNs, we define channel activation $r ^ { ( l ) } \in \{ 0 , 1 \} ^ { C _ { l } }$ to indicate which indices of channels remain in the $l$ -th layer of the pruned network. Then, the weights in $W _ { i , j } ^ { ( l ) }$ are active if and only if $r _ { i } ^ { ( l - 1 ) } r _ { j } ^ { ( l ) } = 1$ , which leads to A(l)i,j $A _ { i , j } ^ { ( l ) } = r _ { i } ^ { ( l - 1 ) } r _ { j } ^ { ( l ) } J _ { K _ { l } }$ . For example, in Figure 2b, $\boldsymbol { r } ^ { ( l - 1 ) } = [ 1 , 1 , 1 ] ^ { \intercal }$ , $r ^ { ( l ) } = [ 0 , 1 ] ^ { \intercal }$ and $\boldsymbol { r } ^ { ( l + 1 ) } = [ 1 , 1 , 0 ] ^ { \intercal }$ , therefore, $A ^ { ( l ) } = \binom { 0 } { 0 } 1 \Biggr ] \otimes J _ { K _ { l } }$ and $A ^ { ( l + 1 ) } = { \binom { 0 } { 1 } } ^ { 0 } \quad 0 \quad 0 ] \otimes J _ { K _ { l + 1 } } .$
+
+We wish to directly maximize the sum of the importance of active weights after the pruning procedure under given resource constraints $: 1$ ) FLOPs, 2) memory, and 3) network size. Concretely, our optimization problem is 2
+
+$$
+\begin{array} { l } { \displaystyle \operatorname* { m a x i m i z e } _ { r ^ { ( 0 : L ) } } \ \sum _ { l = 1 } ^ { L } \left. I ^ { ( l ) } , A ^ { ( l ) } \right. } \\ { \mathrm { s u b j e c t \ t o } \ \displaystyle \sum _ { l = 0 } ^ { L } a _ { l } \left\| r ^ { ( l ) } \right\| _ { 1 } + \displaystyle \sum _ { l = 1 } ^ { L } b _ { l } \left\| A ^ { ( l ) } \right\| _ { 1 } \leq M } \\ { \displaystyle A ^ { ( l ) } = r ^ { ( l - 1 ) } r ^ { ( l ) \top } \otimes J _ { K _ { l } } \quad \forall l \in [ L ] } \\ { \displaystyle r ^ { ( l ) } \in \{ 0 , 1 \} ^ { C _ { l } } . } \end{array}
+$$
+
+In our formulation, the actual resource usage of the pruned network is exactly computed by specifying the number of channels in the pruned network $( = \bar { \Vert _ { r } ( l ) _ { \Vert _ { 1 } } } )$ and the pruning mask sparsity $\dot { ( } = \| A ^ { ( \dot { l } ) } \| _ { 1 } \dot { ) }$ in each layer. Concretely, the left hand side of the inequality in the first constraint in Equation (2) indicates the actual resource usage. Table 1 shows $a _ { l } , b _ { l }$ terms used for computing usage of each resource. Note that this optimization problem is a discrete nonconvex QCQP of the channel activations $[ r ^ { ( 0 ) } , \dots , r ^ { ( L ) } ]$ , where the objective, which is the same with the objective in Section 2.2, respects the quadratic coupling of channel activations $( = r ^ { ( l ) } )$ . Please refer to Supplementary material E for the details on the standard QCQP form of Equation (2).
+
+# 3.2 FORMULATION OF JOINT CHANNEL AND SPATIAL PRUNING
+
+For further efficiency, we increase the pruning granularity to additionally perform spatial pruning in 2-D convolution filters. Concretely, we prune by each weight vector across the input channel direction instead of each channel to perform channel and spatial pruning processes simultaneously.
+
+<table><tr><td>Resource constraint (M)</td><td>a</td><td>b</td></tr><tr><td>Network size</td><td>0</td><td>1</td></tr><tr><td>Memory</td><td>HW</td><td>1</td></tr><tr><td>FLOPs</td><td>0</td><td>HWt</td></tr></table>
+
+First, we define the shape column W (l)·,j,a by
+
+Table 1: Resource constraints and the corresponding $a _ { l } , b _ { l }$ values.
+
+the vector of weights at spatial position $( a , b )$ of a 2-D convolution filter along the $j$ -th output channel dimension. Then, we define shape column activation $q ^ { ( l ) } \in \{ 0 , 1 \} ^ { C _ { l } \times K _ { l } \times K _ { l } }$ to indicate which shape columns in the $l$ -th convolution layer remain in the pruned network. Figure 3 shows the illustration of each variables.
+
+Note that this definition induces constraints on the channel activation variables. In detail, the $j$ -th output channel activation in $l$ -th layer is set if and only if at least one shape column activation in the $j$ -th output channel is set. Concretely, the new formulation should include the constraints $\begin{array} { r } { r _ { j } ^ { ( l ) } \le \sum _ { a , b } q _ { j , a , b } ^ { ( l ) } } \end{array}$ and $q _ { j , a , b } ^ { ( l ) } \leq r _ { j } ^ { ( l ) } \forall a , b$ .
+
+![](images/3aa112f2df91bd35c67a87050d367e0bb2b1dbaa345bc04d75a26c81aa7782b6.jpg)  
+Figure 3: Input channel activation $\left( = r ^ { ( l - 1 ) } \right)$ , shape column activation $\left( = q ^ { \left( l \right) } \right)$ , and the corresponding mask $\left( = A ^ { ( l ) } \right)$ for $l$ -th convolution layer, where $A ^ { ( l ) } = r ^ { ( l - 1 ) } \otimes q ^ { ( l ) }$ .
+
+We now reformulate the optimization problem to include the shape column activation variables. Again, we aim to maximize the sum of the importance of active weights after pruning under the given resource constraints. Then, our optimization problem for simultaneous channel and spatial pruning is
+
+$$
+\begin{array} { l } { \displaystyle \underset { r ^ { ( s , L ) } , q ^ { ( 1 ; L ) } } { \mathrm { m a x i m i z e } } \ ~ \sum _ { l = 1 } ^ { L } \left. I ^ { ( l ) } , A ^ { ( l ) } \right. } \\ { \mathrm { s u b j e c t ~ t o } \ \displaystyle \sum _ { l = 0 } ^ { L } a _ { l } \left\| r ^ { ( l ) } \right\| _ { 1 } + \displaystyle \sum _ { l = 1 } ^ { L } b _ { l } \left\| A ^ { ( l ) } \right\| _ { 1 } \leq M } \\ { \displaystyle r _ { j } ^ { ( l ) } \leq \sum _ { a , b } q _ { j , a , b } ^ { ( l ) } \quad \mathrm { a n d } \quad q _ { j , a , b } ^ { ( l ) } \leq r _ { j } ^ { ( l ) } \quad \forall l , j , a , b } \\ { \displaystyle A ^ { ( l ) } = r ^ { ( l - 1 ) } \otimes q ^ { ( l ) } \quad \forall l } \\ { \displaystyle r ^ { ( l ) } \in \{ 0 , 1 \} ^ { C } \ a \mathrm { n d } \ q ^ { ( l ) } \in \{ 0 , 1 \} ^ { C } \times K _ { l } \times K _ { l } \quad \forall l \in [ L ] . } \end{array}
+$$
+
+We note that this optimization problem is also a discrete nonconvex QCQP. The details on the standard QCQP form of Equation (3) is provided in Supplementary material E. Furthermore, Proposition 1 below shows that the constraints in Equation (2) and Equation (3) provably eliminate any unpruned inactive weights and accurately model the resource usage as well as the objective of the pruned network. Also, Proposition 1 can be generalized to nonsequential networks with skip addition. The generalization and the proofs are given in Supplementary material D.
+
+Proposition 1. Optimizing over the input and output channel activation variables ${ r ^ { ( 0 : L ) } }$ and shape column activation variables $q ^ { ( 1 : L ) }$ under the constraints in Equation (3) provably removes any inactive weights in the pruned network, guaranteeing exact computation of 1) resource usage and 2) the sum of the importance of active weights in the pruned network.
+
+# 3.3 OPTIMIZATION
+
+Concretely, Equation (2) and Equation (3) fall into the category of binary Mixed Integer Quadratic Constraint Quadratic Programming (MIQCQP). We solve these discrete QCQP problems with the CPLEX library (INC, 1993), which provides MIQCQP solvers based on the branch and cut technique. However, the branch and cut algorithm can lead to exponential search time (Mitchell, 2002) on large problems. Therefore, we provide a practical alternative utilizing a block coordinate descent style optimization method in Supplementary material B.
+
+# 4 RELATED WORKS
+
+Importance of channels Most of the channel pruning methods prune away the least important channels with a simple greedy approach, and the evaluation method for the importance of channels has been the main research problem (Molchanov et al., 2017; 2019; Liu et al., 2019). Channel pruning is divided into two major branches according to the method of evaluating the importance of channels: the trainable-importance method, which evaluates the importance of channels while training the whole network from scratch, and the fixed-importance method, which directly evaluates the importance of channels on the pretrained network. Trainable-importance channel pruning methods include the regularizer-based methods with group sparsity regularizers (Wen et al., 2016; Alvarez & Salzmann, 2016; Yang et al., 2019; Liu et al., 2017; Louizos et al., 2018; Liu et al., 2017; Gordon et al., 2018) and data-driven channel pruning methods (Kang & Han, 2020; You et al., 2019). Fixedimportance channel pruning methods first prune away most of the weights and then finetune the significantly smaller pruned network (Molchanov et al., 2017; 2019; Hu et al., 2016; He et al., 2018a; Li et al., 2017; He et al., 2019; Luo et al., 2017). As a result, fixed-importance methods are much more efficient than the trainable-importance channel pruning methods in terms of computational cost and memory as trainable-importance methods have to train the whole unpruned network. Our framework is on the line of fixed-importance channel pruning works.
+
+Predefined target structure and Automatic target structure Layer-wise channel pruning methods (Li et al., 2017; He et al., 2019), which perform pruning operations per each layer independently, require users to predefine the target pruned structure. Also, LCCL(Dong et al., 2017) exploits a predefined low-cost network to improve inference time. Another line of research finds the appropriate target structure automatically (He et al., 2018b; Yang et al., 2018; Liu et al., 2019; Molchanov et al., 2017). Our method also finds the target structure automatically under the explicit target resource constraints.
+
+Dynamic pruning and static pruning Dynamic pruning has a different network structure depending on the input during inference time, while static pruning has a fixed network structure during inference time. CGNet (Hua et al., 2019) dynamically identifies unnecessary features to reduce the computation, and FBS (Gao et al., 2019) dynamically skip computations on the unimportant channels. Our framework is static pruning and has a fixed network structure during inference time.
+
+Quadratic coupling CCP (Peng et al., 2019) formulates a QP (quadratic formulation) to consider the quadratic coupling between channels in the same layer under layer-wise constraints on the maximum number of channels. On the other hand, our formulation considers the quadratic coupling between channels in the neighboring layers under the target resource constraints.
+
+Channel pruning in nonsequential blocks Many network architectures contain nonsequential convolution operations, such as skip addition (He et al., 2016; Sandler et al., 2018; Tan & Le, 2019) and skip concatenation (Huang et al., 2017). Since these network architectures outperform sequential network architectures, pruning a network with nonsequential convolution operations is crucial. However, most channel pruning methods (Liu et al., 2017; He et al., 2018a; 2019; Molchanov et al., 2017; 2019) do not consider the nonsequential convolution operations and use the same method from the sequential network architecture. However, channel pruning methods ignorant of nonsequential convolution operations may result in the misalignment of feature maps connected by skip connections (You et al., 2019). GBN (You et al., 2019) forces parameters connected by a nonsequential convolution operation to share the same pruning pattern to solve this misalignment problem. In contrast, our formulation does not require strict pattern sharing. This flexibility allows for our methods to delete more channels under given constraints.
+
+Spatial pruning of convolution filters Spatial pruning methods aim to prune convolution filters along the channel dimension for inference efficiency. Spatial pruning methods manually define the spatial patterns of filters (Lebedev & Lempitsky, 2016; Anwar et al., 2017) or optimize spatial patterns of filters with group sparse regularizers (Wen et al., 2016; Lebedev & Lempitsky, 2016). Among these works, Lebedev & Lempitsky (2016) empirically demonstrates that enforcing sparse spatial patterns in 2-D filters along the input channel leads to great speed-up during inference time using group sparse convolution operations (Chellapilla et al., 2006). Our proposed method enforces the spatial patterns in 2-D filters as in Lebedev & Lempitsky (2016) for speed-up in inference.
+
+# 5 EXPERIMENTS
+
+We compare the classification accuracy of the pruned network against several pruning baselines on CIFAR-10 (Krizhevsky et al., 2009) and ImageNet (Russakovsky et al., 2015) datasets using various ResNet architectures (He et al., 2016), DenseNet-40 (Huang et al., 2017), and VGG-16 (Simonyan & Zisserman, 2015). Note that most pruning baselines apply an iterative pruning procedure, which repeatedly alternates between network pruning and finetuning until the target resource constraints are satisfied (Han et al., 2015; He et al., 2018a; Liu et al., 2017; Yang et al., 2018). In contrast, since our methods explicitly include the target resource constraint to the optimization framework, we only need one round of pruning and finetuning.
+
+# 5.1 EXPERIMENTAL SETTINGS
+
+We follow the ‘smaller-norm-less-important’ criterion (Ye et al., 2018; Liu et al., 2017), which evaluates the importance of weights as the absolute value of weight (Han et al., 2015; Guo et al., 2016). We assume the network size and FLOPs reduction are linearly proportional to the sparsity in shape column activations, as empirically shown in Lebedev & Lempitsky (2016). Also, we ignore the extra memory overhead for storing the shape column activations due to its negligible size compared to the total network size. In the experiment tables, FLOPs and the network size of the pruned network are computed according to the resource specifications in Equations (2) and (3). Also, ‘Pruning ratio’ in the tables denotes the ratio of pruned weights among the total weights in baseline networks. ‘ours-c’ and ‘ours-cs’ in the tables denote our method with channel pruning and our method with both the channel and spatial pruning, respectively.
+
+Table 2: Pruned accuracy and accuracy drop from the baseline network at given FLOPs (left) and pruning ratios (right) on various network architectures (ResNet-20,32,56 and DenseNet-40) at CIFAR-10.   
+
+<table><tr><td rowspan="2"></td><td rowspan="2">Method</td><td rowspan="2">Baseline acc</td><td colspan="3">FLOPs</td></tr><tr><td>Pruned acc↑</td><td>Acc drop↓</td><td>FLOPs(%)↓</td></tr><tr><td rowspan="9">ResNet-20</td><td>FPGM (He et al.,2019)</td><td>92.21 (0.18)</td><td>91.26 (0.24)</td><td>0.95</td><td>46.0</td></tr><tr><td>ours-c</td><td>92.21 (0.18)</td><td>90.96 (0.15)</td><td>1.25</td><td>46.0</td></tr><tr><td>ours-cs</td><td>92.21 (0.18)</td><td>91.70 (0.18)</td><td>0.51</td><td>46.0</td></tr><tr><td>LCCL (Dong et al.,2017)</td><td>92.74</td><td>91.68</td><td>1.06</td><td>62.1</td></tr><tr><td>SFP (He et al.,2018a)</td><td>92.20 (0.18)</td><td>90.83 (0.31)</td><td>1.37</td><td>57.8</td></tr><tr><td>FPGM (He et al.,2019)</td><td>92.21 (0.18)</td><td>91.72 (0.20)</td><td>0.49</td><td>57.8</td></tr><tr><td>ours-c</td><td>92.21 (0.18)</td><td>91.74 (0.20)</td><td>0.47</td><td>58.3</td></tr><tr><td>ours-cs</td><td>92.21 (0.18)</td><td>92.26 (0.10)</td><td>-0.05</td><td>57.8</td></tr><tr><td>FPGM(He et al.,2019)</td><td>92.88 (0.86)</td><td>91.96 (0.76)</td><td>0.92</td><td>46.8</td></tr><tr><td rowspan="9">ResNet-32</td><td>ours-c</td><td>92.88 (0.86)</td><td>91.98 (0.42)</td><td>0.90</td><td>46.8</td></tr><tr><td>ours-cs</td><td>92.88 (0.86)</td><td>92.33 (0.41)</td><td>0.55</td><td>47.0</td></tr><tr><td>LCCL (Dong et al.,2017)</td><td>92.33</td><td>90.74</td><td>1.59</td><td>69.0</td></tr><tr><td>SFP (He et al.,2018a)</td><td>92.63 (0.70)</td><td>92.08 (0.08)</td><td>0.55</td><td>58.5</td></tr><tr><td>FPGM (He et al.,2019)</td><td>92.88 (0.86)</td><td>92.51 (0.90)</td><td>0.37</td><td>58.5</td></tr><tr><td>ours-c</td><td>92.88 (0.86)</td><td>92.52 (0.46)</td><td>0.36</td><td>57.2</td></tr><tr><td>ours-cs</td><td>92.88 (0.86)</td><td>92.80 (0.61)</td><td>0.08</td><td>57.9</td></tr><tr><td>SFP (He et al.,2018a)</td><td>93.59 (0.58)</td><td>92.26 (0.31)</td><td>1.33</td><td>47.5</td></tr><tr><td>FPGM (He et al.,2019)</td><td>93.59 (0.58)</td><td>93.49 (0.13)</td><td>0.10</td><td>47.5</td></tr><tr><td rowspan="8"></td><td></td><td>93.50</td><td>93.42</td><td>0.08</td><td>47.4</td></tr><tr><td>CCP (Peng et al.,2019)</td><td>92.8</td><td>91.9</td><td></td><td></td></tr><tr><td>AMC (He et al.,2018b)</td><td></td><td></td><td>0.9</td><td>50.0</td></tr><tr><td>SCP(Kang &amp; Han,2020)</td><td>93.69</td><td>93.23</td><td>0.46</td><td>48.5</td></tr><tr><td>ours-c</td><td>93.59 (0.58)</td><td>93.36 (0.68)</td><td>0.23</td><td>47.4</td></tr><tr><td>ours-cs</td><td>93.59 (0.58)</td><td>93.59 (0.36)</td><td>0.00</td><td>47.4</td></tr><tr><td>SCP(Kang&amp; Han,2020)</td><td>94.39</td><td>93.77</td><td>0.62</td><td>29.2</td></tr><tr><td>ours-c</td><td>95.01</td><td>93.80</td><td>1.21</td><td>29.2</td></tr><tr><td rowspan="8"></td><td>ours-cs</td><td>95.01</td><td>94.25</td><td>0.76</td><td>29.2</td></tr><tr><td>slimming (Liu et al.,2017)</td><td>93.89</td><td>94.35</td><td>-0.46</td><td>45.0</td></tr><tr><td>ours-c</td><td>95.01</td><td>94.38</td><td>0.63</td><td>45.0</td></tr><tr><td>ours-cs</td><td>95.01</td><td>94.85</td><td>0.16</td><td>45.0</td></tr><tr><td>slimming (Liu et al.,2017)</td><td>93.89</td><td>94.81</td><td>-0.92</td><td>71.6</td></tr><tr><td>ours-c</td><td></td><td>94.82</td><td>0.19</td><td>71.0</td></tr><tr><td></td><td>95.01</td><td></td><td></td><td></td></tr><tr><td>ours-cs</td><td>95.01</td><td>95.02</td><td>-0.01</td><td>71.0</td></tr></table>
+
+<table><tr><td colspan="3">Network size</td></tr><tr><td>Pruned acc↑</td><td>Acc drop↓</td><td>Pruning ratio(%)↑</td></tr><tr><td>91.26 (0.24)</td><td>0.95</td><td>54.0</td></tr><tr><td>91.26 (0.18)</td><td>0.95</td><td>54.1</td></tr><tr><td>92.02 (0.10)</td><td>0.19</td><td>54.0</td></tr><tr><td>91.68</td><td>1.06</td><td>33.1</td></tr><tr><td>90.83 (0.31)</td><td>1.37</td><td>42.2</td></tr><tr><td>91.72 (0.20)</td><td>0.49</td><td>42.2</td></tr><tr><td>92.27 (0.17).</td><td>-0.06</td><td>42.3</td></tr><tr><td>92.35 (0.10)</td><td>-0.14</td><td>42.2</td></tr><tr><td>91.96 (0.76)</td><td>0.92</td><td>53.2</td></tr><tr><td>92.22 (1.02)</td><td>0.66</td><td>53.2</td></tr><tr><td>92.78 (0.97)</td><td>0.10</td><td>53.2</td></tr><tr><td>90.74</td><td>1.59</td><td>37.5</td></tr><tr><td>92.08 (0.08)</td><td>0.55</td><td>41.5</td></tr><tr><td>92.51 (0.90)</td><td>0.37</td><td>41.5</td></tr><tr><td>92.42 (0.77)</td><td>0.46</td><td>42.7</td></tr><tr><td>92.83 (0.83)</td><td>0.05</td><td>42.7</td></tr><tr><td>92.26 (0.31)</td><td>1.33</td><td>52.6</td></tr><tr><td>93.49 (0.13)</td><td>0.10</td><td>52.6</td></tr><tr><td>=</td><td>-</td><td>-</td></tr><tr><td></td><td>=</td><td>=</td></tr><tr><td>93.23</td><td>0.46</td><td>51.5</td></tr><tr><td>93.37 (0.96)</td><td>0.22</td><td>52.7</td></tr><tr><td>93.69 (0.69)</td><td>-0.10</td><td>52.6</td></tr><tr><td></td><td></td><td>-</td></tr><tr><td></td><td></td><td>=</td></tr><tr><td></td><td>=</td><td>=</td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr></table>
+
+# 5.2 CIFAR-10
+
+CIFAR-10 dataset has 10 different classes with $5 k$ training images and $1 k$ test images per each class Krizhevsky et al. (2009). In CIFAR-10 experiments, we evaluate our methods on various network architectures: ResNet-20, 32, 56, and DenseNet-40. We provide implementation of the details for the experiments in Supplementary material C. We show the experiment results of pruning under FLOPs constraints in the left column of Table 2 and under final network size constraints in the right column of Table 2.
+
+On the FLOPs experiments in the left column of Table 2, ‘ours-c’ shows comparable results against FPGM, which is the previous state of the art method, on ResNet-20, 32, and 56. Moreover, ‘ours-cs’ significantly outperforms both ‘ours-c’ and FPGM on the same architectures showing the state of the art performance. Also, ‘ours-c’ shows comparable results against slimming (Liu et al., 2017) and SCP (Kang & Han, 2020), while ‘ours-cs’ outperforms existing baselines by a large margin on DenseNet-40.
+
+On the network size experiments in the right column of Table 2, ‘ours-c’ shows results competitive to FPGM and SCP, while ‘ours-cs’ again achieves the state of the art performance on ResNet-20, 32, and 56. Notably, in ResNet-56, ‘ours-cs’ achieves a minimal accuracy drop of $- 0 . 1 0$ with the pruning ratio of $5 2 . 6 \%$ . These results show simultaneous channel and spatial pruning produces more efficient networks with better performance compared to other channel pruning methods on CIFAR-10.
+
+# 5.3 IMAGENET
+
+ILSVRC-2012 (Russakovsky et al., 2015) is a large-scale dataset with 1000 classes that comes with $1 . 2 8 M$ training images and $5 0 k$ validation images. We conduct our methods under the fixed FLOPs constraint on ResNet-18,50, and VGG-16. For more implementation details of the ImageNet experiments, refer to Supplementary material C. Table 3 shows the experiment results on ImageNet. In ResNet-50, ‘ours- $. \mathrm { c } '$ ’ and ‘ours-cs’ achieve results comparable to GBN, a trainable-importance channel pruning method which is the previous state of the art, even though our method is a fixedimportance channel pruning method. In particular, top1 pruned accuracy in ‘ours-cs’ exceeds SFP by $1 . 3 2 \%$ using a similar number of FLOPs. Both ‘ours-cs’ and ‘ours-c’ clearly outperform FPGM in ResNet-50. Also, ‘ours- $\cdot \mathrm { c } '$ and ‘ours-cs’ show significantly better performance than Molchanov et al. (2017) on VGG-16.
+
+Table 3: Top1,5 pruned accuracy and accuracy drop from the baseline network at given FLOPs on various network architectures (ResNet-18,50, and VGG-16) at ImageNet.   
+
+<table><tr><td>Network</td><td>Method</td><td>Top1 Pruned Acc↑</td><td>Topl Acc drop↓</td><td>Top5 Pruned Acc↑</td><td>Top5 Acc drop↓</td><td>FLOPs(%)↓</td></tr><tr><td rowspan="6">ResNet-18</td><td rowspan="6">SFP (He et al.,2018a) FPGM (He et al.,2019) ours-c</td><td>67.10</td><td>3.18</td><td>87.78</td><td>1.85</td><td>58.2</td></tr><tr><td>68.41</td><td>1.87</td><td>88.48</td><td>1.15</td><td>58.2</td></tr><tr><td>67.48</td><td>2.28</td><td>87.78</td><td>1.30</td><td>60.9</td></tr><tr><td>69.59</td><td>0.17</td><td>88.94</td><td>0.14</td><td>58.2</td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td>LCCL (Dong et al.,2017) 66.33 68.65</td><td>3.65 1.11</td><td>86.94 88.69</td><td>2.29 0.39</td><td>65.3 65.9</td></tr><tr><td rowspan="6">ResNet-50</td><td rowspan="6">ours-cs SFP (He et al.,2018a) FPGM (He et al.,2019)</td><td>70.05</td><td>-0.29</td><td>89.24</td><td>-0.16</td><td>65.9</td></tr><tr><td>74.61</td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>1.54</td><td>92.06</td><td>0.81</td><td>58.3</td></tr><tr><td>75.50</td><td>0.65</td><td>92.63</td><td>0.21</td><td>57.8</td></tr><tr><td>75.78</td><td>0.37</td><td>91.86</td><td>1.01</td><td>57.8</td></tr><tr><td>75.93</td><td>0.22</td><td>92.68</td><td>0.19</td><td>57.8</td></tr><tr><td rowspan="6"></td><td>GBN (You et al.,2019) ours-c ours-cs</td><td>76.19 75.89</td><td>-0.31 0.26</td><td>92.83 92.84</td><td>-0.16 0.03</td><td>59.5 61.5</td></tr><tr><td></td><td>76.00</td><td>0.15</td><td>92.76</td><td>0.11</td><td>59.0</td></tr><tr><td>Molchanov et al. (2017)</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>ours-c</td><td>- 65.92</td><td></td><td>84.5</td><td>5.9</td><td>51.7</td></tr><tr><td></td><td></td><td>5.67</td><td>87.20</td><td>3.18</td><td>51.7</td></tr><tr><td>ours-cs</td><td>66.36</td><td>5.23</td><td>87.36</td><td>3.02</td><td>51.7</td></tr></table>
+
+# 6 CONCLUSION
+
+We present a discrete QCQP based optimization framework for jointly pruning channel and spatial filters under various architecture realizations. Since our methods model the inherent quadratic coupling between channels in the neighboring layers to eliminate any inactive weights during the pruning procedure, they allow exact modeling of the user-specified resource constraints and enable the direct optimization of the true objective on the pruned network. The experiments show our proposed method significantly outperforms other fixed-importance channel pruning methods, finding smaller and faster networks with the least drop in accuracy.
+
+# REFERENCES
+
+Jose M Alvarez and Mathieu Salzmann. Learning the number of neurons in deep networks. In NeurIPS, 2016.
+
+Sajid Anwar, Kyuyeon Hwang, and Wonyong Sung. Structured pruning of deep convolutional neural networks. In JETC, 2017.
+
+Kumar Chellapilla, Sidd Puri, and Patrice Simard. High performance convolutional neural networks for document processing. In IWFHR, 2006.
+
+Jan K Chorowski, Dzmitry Bahdanau, Dmitriy Serdyuk, Kyunghyun Cho, and Yoshua Bengio. Attention-based models for speech recognition. In NeurIPS. 2015.
+
+J. Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. In NAACL-HLT, 2019.
+
+Xuanyi Dong, Junshi Huang, Yi Yang, and Shuicheng Yan. More is less: A more complicated network with less inference complexity. In CVPR, 2017.
+
+Xitong Gao, Yiren Zhao, Łukasz Dudziak, Robert Mullins, and Cheng-zhong Xu. Dynamic channel pruning: Feature boosting and suppression. 2019.
+
+Ariel Gordon, Elad Eban, Ofir Nachum, Bo Chen, Hao Wu, Tien-Ju Yang, and Edward Choi. Morphnet: Fast & simple resource-constrained structure learning of deep networks. In CVPR, 2018.
+
+Yiwen Guo, Anbang Yao, and Yurong Chen. Dynamic network surgery for efficient dnns. In NeurIPS, 2016.
+
+Song Han, Jeff Pool, John Tran, and William Dally. Learning both weights and connections for efficient neural network. In NeurIPS, 2015.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016.
+
+Yang He, Guoliang Kang, Xuanyi Dong, Yanwei Fu, and Yi Yang. Soft filter pruning for accelerating deep convolutional neural networks. In IJCAI, 2018a.
+
+Yang He, Ping Liu, Ziwei Wang, Zhilan Hu, and Yi Yang. Filter pruning via geometric median for deep convolutional neural networks acceleration. In CVPR, 2019.
+
+Yihui He, Ji Lin, Zhijian Liu, Hanrui Wang, Li-Jia Li, and Song Han. Amc: Automl for model compression and acceleration on mobile devices. In ECCV, 2018b.
+
+Hengyuan Hu, Rui Peng, Yu-Wing Tai, and Chi-Keung Tang. Network trimming: A data-driven neuron pruning approach towards efficient deep architectures. In arXiv:1607.03250, 2016.
+
+Weizhe Hua, Yuan Zhou, Christopher M De Sa, Zhiru Zhang, and G Edward Suh. Channel gating neural networks. In NIPS, 2019.
+
+Gao Huang, Zhuang Liu, Laurens Van Der Maaten, and Kilian Q Weinberger. Densely connected convolutional networks. In CVPR, 2017.
+
+CPLEX OPTIMIZATION INC. Using the cplex callable library and cplex mixed integer library. In Incline Village, NV, 1993.
+
+Minsoo Kang and Bohyung Han. Operation-aware soft channel pruning using differentiable masks. In ICML, 2020.
+
+Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. In Tech Report, 2009.
+
+Vadim Lebedev and Victor Lempitsky. Fast convnets using group-wise brain damage. In CVPR, 2016.
+
+Hao Li, Asim Kadav, Igor Durdanovic, Hanan Samet, and Hans Peter Graf. Pruning filters for efficient convnets. In ICLR, 2017.
+
+Z. Liu, H. Mu, X. Zhang, Z. Guo, X. Yang, K. Cheng, and J. Sun. Metapruning: Meta learning for automatic neural network channel pruning. In 2019 IEEE/CVF International Conference on Computer Vision (ICCV), 2019.
+
+Zhuang Liu, Jianguo Li, Zhiqiang Shen, Gao Huang, Shoumeng Yan, and Changshui Zhang. Learning efficient convolutional networks through network slimming. In ICCV, 2017.
+
+Zhuang Liu, Mingjie Sun, Tinghui Zhou, Gao Huang, and Trevor Darrell. Rethinking the value of network pruning. In ICLR, 2019.
+
+Christos Louizos, Max Welling, and Diederik P Kingma. Learning sparse neural networks through l_0 regularization. In ICLR, 2018.
+
+Jian-Hao Luo, Jianxin Wu, and Weiyao Lin. Thinet: A filter level pruning method for deep neural network compression. In ICCV, 2017.
+
+John E Mitchell. Branch-and-cut algorithms for combinatorial optimization problems. In Handbook of applied optimization, 2002.
+
+Pavlo Molchanov, Stephen Tyree, Tero Karras, Timo Aila, and Jan Kautz. Pruning convolutional neural networks for resource efficient inference. In ICLR, 2017.
+
+Pavlo Molchanov, Arun Mallya, Stephen Tyree, Iuri Frosio, and Jan Kautz. Importance estimation for neural network pruning. In CVPR, 2019.
+
+Hanyu Peng, Jiaxiang Wu, Shifeng Chen, and Junzhou Huang. Collaborative channel pruning for deep networks. In ICML, 2019.
+
+Joseph Redmon and Ali Farhadi. Yolov3: An incremental improvement. In arXiv:1804.02767, 2018.
+
+Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, et al. Imagenet large scale visual recognition challenge. In IJCV, 2015.
+
+Mark Sandler, Andrew Howard, Menglong Zhu, Andrey Zhmoginov, and Liang-Chieh Chen. Mobilenetv2: Inverted residuals and linear bottlenecks. In CVPR, 2018.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. In ICLR, 2015.
+
+Mingxing Tan and Quoc Le. Efficientnet: Rethinking model scaling for convolutional neural networks. In ICML, 2019.
+
+Stefan Van Der Walt, S Chris Colbert, and Gael Varoquaux. The numpy array: a structure for efficient numerical computation. In CISE, 2011.
+
+Wei Wen, Chunpeng Wu, Yandan Wang, Yiran Chen, and Hai Li. Learning structured sparsity in deep neural networks. In NeurIPS, 2016.
+
+Huanrui Yang, Wei Wen, and Hai Li. Deephoyer: Learning sparser neural network with differentiable scale-invariant sparsity measures. In ICLR, 2019.
+
+Tien-Ju Yang, Andrew Howard, Bo Chen, Xiao Zhang, Alec Go, Mark Sandler, Vivienne Sze, and Hartwig Adam. Netadapt: Platform-aware neural network adaptation for mobile applications. In ECCV, 2018.
+
+Jianbo Ye, Xin Lu, Zhe Lin, and James Z Wang. Rethinking the smaller-norm-less-informative assumption in channel pruning of convolution layers. In ICLR, 2018.
+
+Zhonghui You, Kun Yan, Jinmian Ye, Meng Ma, and Ping Wang. Gate decorator: Global filter pruning method for accelerating deep convolutional neural networks. In NeurIPS, 2019.

parse/train/IkYEJ5Cps5H/IkYEJ5Cps5H_content_list.json

@@ -0,0 +1,1262 @@
+[
+    {
+        "type": "text",
+        "text": "SUCCINCT NETWORK CHANNEL AND SPATIAL PRUNING VIA DISCRETE VARIABLE QCQP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            826,
+            147
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            172,
+            398,
+            200
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            237,
+            544,
+            252
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Reducing the heavy computational cost of large convolutional neural networks is crucial when deploying the networks to resource-constrained environments. In this context, recent works propose channel pruning via greedy channel selection to achieve practical acceleration and memory footprint reduction. We first show this channel-wise approach ignores the inherent quadratic coupling between channels in the neighboring layers and cannot safely remove inactive weights during the pruning procedure. Furthermore, we show that these pruning methods cannot guarantee the given resource constraints are satisfied and cause discrepancy with the true objective. To this end, we formulate a principled optimization framework with discrete variable QCQP, which provably prevents any inactive weights and enables the exact guarantee of meeting the resource constraints in terms of FLOPs and memory. Also, we extend the pruning granularity beyond channels and jointly prune individual 2D convolution filters spatially for greater efficiency. Our experiments show competitive pruning results under the target resource constraints on CIFAR-10 and ImageNet datasets on various network architectures. ",
+        "bbox": [
+            233,
+            268,
+            764,
+            476
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            502,
+            336,
+            517
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep neural networks are the bedrock of artificial intelligence tasks such as object detection, speech recognition, and natural language processing (Redmon & Farhadi, 2018; Chorowski et al., 2015; Devlin et al., 2019). While modern networks have hundreds of millions to billions of parameters to train, it has been recently shown that these parameters are highly redundant and can be pruned without significant loss in accuracy (Han et al., 2015; Guo et al., 2016). This discovery has led practitioners to desire training and running the models on resource-constrained mobile devices, provoking a large body of research on network pruning. ",
+        "bbox": [
+            174,
+            532,
+            825,
+            631
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Unstructured pruning, however, does not directly lead to any practical acceleration or memory footprint reduction due to poor data locality (Wen et al., 2016), and this motivated research on structured pruning to achieve practical usage under limited resource budgets. To this end, a line of research on channel pruning considers completely pruning the convolution filters along the input and output channel dimensions, where the resulting pruned model becomes a smaller dense network suited for practical acceleration and memory footprint reduction (Li et al., 2017; Luo et al., 2017; He et al., 2019; Wen et al., 2016; He et al., 2018a). ",
+        "bbox": [
+            174,
+            637,
+            825,
+            734
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "However, existing channel pruning methods perform the pruning operations with a greedy approach and does not consider the inherent quadratic coupling between channels in the neighboring layers. Although these methods are easy to model and optimize, they cannot safely remove inactive weights during the pruning procedure, suffer from discrepancies with the true objective, and prohibit the strict satisfaction of the required resource constraints during the pruning process. ",
+        "bbox": [
+            174,
+            742,
+            825,
+            811
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The ability to specify hard target resource constraints into the pruning optimization process is important since this allows the user to run the pruning and optional finetuning process only once. When the pruning process ignores the target specifications, the users may need to apply multiple rounds of pruning and finetuning until the specifications are eventually met, resulting in an extra computation overhead (Han et al., 2015; He et al., 2018a; Liu et al., 2017). ",
+        "bbox": [
+            174,
+            819,
+            825,
+            888
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we formulate a principled optimization problem that prunes the network layer channels while respecting the quadratic coupling and exactly satisfying the user-specified FLOPs and memory constraints. This new formulation leads to an interesting discrete variable QCQP (Quadratic Constrained Quadratic Program) optimization problem, which directly maximizes the importance of neurons in the pruned network under the specified resource constraints. Also, we increase the pruning granularity beyond channels and jointly prune individual 2D convolution filters spatially for greater efficiency. Furthermore, we generalize our formulation to cover nonsequential convolution operations, such as skip connections, and propose a principled optimization framework for handling various architectural implementations of skip connections in ResNet (He et al., 2016). Our experiments on CIFAR-10 and ImageNet datasets show the state of the art results compared to other channel pruning methods that start from pretrained networks. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/30607c2e56d734ec141791edf273f5b524a27effd00ad6c64c08ad72be07d27d.jpg",
+        "image_caption": [
+            "Figure 1: Illustration of a channel pruning procedure that leads to inactive weights. When $j$ -th output channel of $l$ -th convolution weights $W _ { \\cdot , j } ^ { ( \\bar { l } ) }$ is pruned, i.e. $W _ { \\cdot , j } ^ { ( l ) } = 0 _ { C _ { l - 1 } , K _ { l } , K _ { l } }$ , then the $j$ -th feature map of l-th layer X (l)j should also be 0. Consequently, $X _ { j } ^ { ( l ) }$ yields inactive weights $W _ { j } ^ { ( l + 1 ) }$ . Note that we use W (l)·,j to denote the tensor $W _ { \\cdot , j , \\cdot , \\cdot } ^ { ( l ) } .$ , following the indexing rules of NumPy (Van Der Walt et al., 2011). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            103,
+            825,
+            246
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            377,
+            825,
+            503
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 MOTIVATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            531,
+            313,
+            547
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this section, we first discuss the motivation of our method concretely. Suppose the weights in a sequential CNN form a sequence of 4-D tensors, $W ^ { ( l ) } \\in \\mathbb { R } ^ { C _ { l - 1 } \\times C _ { l } \\times K _ { l } \\times K _ { l } } \\forall \\bar { l } \\in [ L ]$ where $C _ { l - 1 } , C _ { l }$ , and $K _ { l }$ represent the number of input channels, the number of output channels, and the filter size of $l$ -th convolution weight tensor, respectively. We denote the feature map after $l$ -th convolution as $X ^ { ( l ) } \\in \\mathbb { R } ^ { C _ { l } \\times H _ { l } \\times W _ { l } }$ . Con, ncretely, denotes $X _ { j } ^ { ( \\bar { l } ) } = \\sigma ( X _ { \\cdot } ^ { ( l - 1 ) } \\odot W _ { \\cdot , j } ^ { ( l ) } ) = \\sigma ( \\sum _ { i = 1 } ^ { C _ { l - 1 } } \\bar { X } _ { i \\ \\cdot } ^ { ( l - 1 ) } * W _ { i , j } ^ { ( l ) } )$ , where hannel- $\\sigma$ isse $^ *$ $\\odot$   \n2-D convolutions. Now consider pruning these weights in channel-wise direction. We show that naive channel-wise pruning methods prevent exact specification of the target resource constraints due to unpruned inactive weights and deviate away from the true objective by ignoring quadratic coupling between channels in the neighboring layers. ",
+        "bbox": [
+            173,
+            566,
+            826,
+            712
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 INACTIVE WEIGHTS",
+        "text_level": 1,
+        "bbox": [
+            176,
+            734,
+            351,
+            750
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "According to Han et al. (2015), network pruning produces dead neurons with zero input or output connections. These dead neurons cause inactive weights1, which do not affect the final output activations of the pruned network. These inactive weights may not be excluded automatically through the standard pruning procedure and require additional post-processing which relies on ad-hoc heuristics. For example, Figure 1 shows a standard channel pruning procedure that deletes weights across the output channel direction but fails to prune the inactive weights. Concretely, deletion of j el of l-th convolution layer leads to W (l)·,j weights on becomes a -th output channead neuron since $W _ { \\cdot , j } ^ { ( l ) } = 0 _ { C _ { l - 1 } , K _ { l } , K _ { l } }$ $X _ { j } ^ { ( l ) }$ $\\begin{array} { r } { \\boldsymbol { X } _ { j } ^ { ( l ) } = \\sigma ( \\boldsymbol { X } ^ { ( l - 1 ) } \\odot \\boldsymbol { W } _ { \\cdot , j } ^ { ( l ) } ) = \\sigma ( \\sum _ { i = 1 } ^ { { C } _ { l - 1 } } \\boldsymbol { X } _ { i } ^ { ( l - 1 ) } * \\boldsymbol { W } _ { i , j } ^ { ( l ) } ) = \\boldsymbol { 0 } _ { C _ { l } , H _ { l } , W _ { l } } . } \\end{array}$ ",
+        "bbox": [
+            173,
+            763,
+            825,
+            887
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The convolution operation on the dead neuron results in a trivially zero output, as below: ",
+        "bbox": [
+            171,
+            103,
+            754,
+            118
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ce1b74ef0c59c5f871463e9567add9e1e8d1a9a442b9f10c56eade661e3f59be.jpg",
+        "text": "$$\nX _ { p } ^ { ( l + 1 ) } = \\sigma \\left( \\sum _ { i = 1 } ^ { C _ { l } } X _ { i } ^ { ( l ) } * W _ { i , p } ^ { ( l + 1 ) } \\right) = \\sigma \\left( \\sum _ { i = 1 } ^ { C _ { l } } \\mathbb { 1 } _ { i \\neq j } X _ { i } ^ { ( l ) } * W _ { i , p } ^ { ( l + 1 ) } + \\underbrace { X _ { j } ^ { ( l ) } * \\underbrace { W _ { j , p } ^ { ( l + 1 ) } } _ { \\mathrm { d e a d } } } _ { = \\mathbb { 0 } _ { H _ { l + 1 } , W _ { l + 1 } } } \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            223,
+            125,
+            772,
+            196
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Equation (1) shows that the dead neuron X(l)j causes weights W (l+1)j,p , $W _ { j , p } ^ { ( l + 1 ) } , \\forall p \\in [ C _ { l + 1 } ]$ to be inactive. Such inactive weights do not account for the actual resource usage, even when they remain in the pruned network, which prevents the exact modeling of the user-specified hard resource constraints (FLOPs and network size). Furthermore, inactive weights unpruned during the pruning procedure are a bigger problem for nonsequential convolutional networks due to their skip connections. To address this problem, we introduce a quadratic optimization-based algorithm that provably eliminates all the inactive weights during the pruning procedure. ",
+        "bbox": [
+            173,
+            202,
+            826,
+            304
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 QUADRATIC COUPLING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            320,
+            377,
+            334
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/1a7cf02ee11375b60d23ae20a288b50d1f0a3933ed1213db30253f98b7026be9.jpg",
+        "image_caption": [
+            "Figure 2: A comparison of the greedy channel pruning method and our pruning method. Parallelograms represent feature maps and squares represent 2-D filters of convolution weights. Gray squares are filters which account for the objective. The numbers on each squares represent the absolute sum of weights in the filter. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            223,
+            351,
+            774,
+            477
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Existing channel pruning methods remove channels according to their importance. However, measuring a channel’s contribution to the network should also take into account the channels in the neighboring layers, as illustrated in Figure 2. In the example, we define the importance of a channel as the absolute sum of weights in the channel, as in Li et al. (2017), and assume the objective is to maximize the absolute sum of weights in the whole pruned network, excluding the inactive weights. We compare two different channel pruning methods: (a) a standard channel pruning method that greedily prunes each channel independently, and (b) our pruning method that considers the effect of the channels in neighboring layers when pruning. As a result of running each pruning algorithms, (a) will prune the second output channel of the first convolution and the third output channel of the second convolution, and (b) will prune the first output channel of the first convolution, the third output channel of the second convolution, and the first input channel of the second convolution. The objective values for each pruned networks are (a) 18 and (b) 21, respectively. ",
+        "bbox": [
+            173,
+            558,
+            825,
+            726
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "This shows that the coupling effect of the channels in neighboring layers directly affects the objective values, and finally results in a performance gap between (a) and (b). We call this coupling relationship as the quadratic coupling between the neighboring layers and formulate the contributions to the objective by quadratic terms of neighboring channel activations. To address this quadratic coupling, we propose a channel pruning method based on the QCQP framework with importance evaluation respecting both the input and the output channels. ",
+        "bbox": [
+            174,
+            732,
+            825,
+            816
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 METHOD ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            837,
+            281,
+            852
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we first propose our discrete QCQP formulation of channel pruning for the sequential convolutional neural networks (CNNs). Then, we present an extended version of our formulation for joint channel and shape pruning of 2D convolution filters. The generalization to the nonsequential convolution (skip addition and skip concatenation) is introduced in Supplementary material A. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To capture the importance of weights in $W ^ { ( l ) }$ , we define the importance tensor as $I ^ { ( l ) } \\in \\Sigma ^ { }$ $\\mathbb { R } _ { + } ^ { C _ { l - 1 } \\times C _ { l } \\times K _ { l } \\times K _ { l } }$ . Following the protocol of Han et al. (2015); Guo et al. (2016), we set $I ^ { ( i ) } = \\gamma _ { l } | W ^ { ( l ) } |$ where $\\gamma _ { l }$ is the $\\ell _ { 2 }$ normalizing factor in $l$ -th layer or $\\lVert \\mathrm { v e c } ( W ^ { ( l ) } ) \\rVert ^ { - 1 }$ . Then, we define the binary pruning mask as $A ^ { ( l ) } \\in \\{ 0 , 1 \\} ^ { C _ { l - 1 } \\times C _ { l } \\times K _ { l } \\times K _ { l } }$ . For channel pruning in sequential CNNs, we define channel activation $r ^ { ( l ) } \\in \\{ 0 , 1 \\} ^ { C _ { l } }$ to indicate which indices of channels remain in the $l$ -th layer of the pruned network. Then, the weights in $W _ { i , j } ^ { ( l ) }$ are active if and only if $r _ { i } ^ { ( l - 1 ) } r _ { j } ^ { ( l ) } = 1$ , which leads to A(l)i,j $A _ { i , j } ^ { ( l ) } = r _ { i } ^ { ( l - 1 ) } r _ { j } ^ { ( l ) } J _ { K _ { l } }$ . For example, in Figure 2b, $\\boldsymbol { r } ^ { ( l - 1 ) } = [ 1 , 1 , 1 ] ^ { \\intercal }$ , $r ^ { ( l ) } = [ 0 , 1 ] ^ { \\intercal }$ and $\\boldsymbol { r } ^ { ( l + 1 ) } = [ 1 , 1 , 0 ] ^ { \\intercal }$ , therefore, $A ^ { ( l ) } = \\binom { 0 } { 0 } 1 \\Biggr ] \\otimes J _ { K _ { l } }$ and $A ^ { ( l + 1 ) } = { \\binom { 0 } { 1 } } ^ { 0 } \\quad 0 \\quad 0 ] \\otimes J _ { K _ { l + 1 } } .$ ",
+        "bbox": [
+            173,
+            127,
+            826,
+            299
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We wish to directly maximize the sum of the importance of active weights after the pruning procedure under given resource constraints $: 1$ ) FLOPs, 2) memory, and 3) network size. Concretely, our optimization problem is 2 ",
+        "bbox": [
+            174,
+            305,
+            825,
+            348
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8ea5207739f9d9f22e51f60bc89b20b820245514036702f15dab23b3b048b6a1.jpg",
+        "text": "$$\n\\begin{array} { l } { \\displaystyle \\operatorname* { m a x i m i z e } _ { r ^ { ( 0 : L ) } } \\ \\sum _ { l = 1 } ^ { L } \\left. I ^ { ( l ) } , A ^ { ( l ) } \\right. } \\\\ { \\mathrm { s u b j e c t \\ t o } \\ \\displaystyle \\sum _ { l = 0 } ^ { L } a _ { l } \\left\\| r ^ { ( l ) } \\right\\| _ { 1 } + \\displaystyle \\sum _ { l = 1 } ^ { L } b _ { l } \\left\\| A ^ { ( l ) } \\right\\| _ { 1 } \\leq M } \\\\ { \\displaystyle A ^ { ( l ) } = r ^ { ( l - 1 ) } r ^ { ( l ) \\top } \\otimes J _ { K _ { l } } \\quad \\forall l \\in [ L ] } \\\\ { \\displaystyle r ^ { ( l ) } \\in \\{ 0 , 1 \\} ^ { C _ { l } } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            334,
+            354,
+            665,
+            487
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In our formulation, the actual resource usage of the pruned network is exactly computed by specifying the number of channels in the pruned network $( = \\bar { \\Vert _ { r } ( l ) _ { \\Vert _ { 1 } } } )$ and the pruning mask sparsity $\\dot { ( } = \\| A ^ { ( \\dot { l } ) } \\| _ { 1 } \\dot { ) }$ in each layer. Concretely, the left hand side of the inequality in the first constraint in Equation (2) indicates the actual resource usage. Table 1 shows $a _ { l } , b _ { l }$ terms used for computing usage of each resource. Note that this optimization problem is a discrete nonconvex QCQP of the channel activations $[ r ^ { ( 0 ) } , \\dots , r ^ { ( L ) } ]$ , where the objective, which is the same with the objective in Section 2.2, respects the quadratic coupling of channel activations $( = r ^ { ( l ) } )$ . Please refer to Supplementary material E for the details on the standard QCQP form of Equation (2). ",
+        "bbox": [
+            173,
+            489,
+            826,
+            607
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 FORMULATION OF JOINT CHANNEL AND SPATIAL PRUNING ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            625,
+            620,
+            637
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For further efficiency, we increase the pruning granularity to additionally perform spatial pruning in 2-D convolution filters. Concretely, we prune by each weight vector across the input channel direction instead of each channel to perform channel and spatial pruning processes simultaneously. ",
+        "bbox": [
+            173,
+            648,
+            473,
+            747
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/44c22a863aeba71f8d803bd8b191058e7802062c2ae4360b694251d2ef274dd7.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Resource constraint (M)</td><td>a</td><td>b</td></tr><tr><td>Network size</td><td>0</td><td>1</td></tr><tr><td>Memory</td><td>HW</td><td>1</td></tr><tr><td>FLOPs</td><td>0</td><td>HWt</td></tr></table>",
+        "bbox": [
+            485,
+            666,
+            784,
+            738
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "First, we define the shape column W (l)·,j,a by ",
+        "bbox": [
+            173,
+            752,
+            473,
+            773
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Resource constraints and the corresponding $a _ { l } , b _ { l }$ values. ",
+        "bbox": [
+            485,
+            748,
+            825,
+            775
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "the vector of weights at spatial position $( a , b )$ of a 2-D convolution filter along the $j$ -th output channel dimension. Then, we define shape column activation $q ^ { ( l ) } \\in \\{ 0 , 1 \\} ^ { C _ { l } \\times K _ { l } \\times K _ { l } }$ to indicate which shape columns in the $l$ -th convolution layer remain in the pruned network. Figure 3 shows the illustration of each variables. ",
+        "bbox": [
+            173,
+            775,
+            825,
+            830
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note that this definition induces constraints on the channel activation variables. In detail, the $j$ -th output channel activation in $l$ -th layer is set if and only if at least one shape column activation in the $j$ -th output channel is set. Concretely, the new formulation should include the constraints $\\begin{array} { r } { r _ { j } ^ { ( l ) } \\le \\sum _ { a , b } q _ { j , a , b } ^ { ( l ) } } \\end{array}$ and $q _ { j , a , b } ^ { ( l ) } \\leq r _ { j } ^ { ( l ) } \\forall a , b$ . ",
+        "bbox": [
+            173,
+            837,
+            825,
+            901
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/3aa112f2df91bd35c67a87050d367e0bb2b1dbaa345bc04d75a26c81aa7782b6.jpg",
+        "image_caption": [
+            "Figure 3: Input channel activation $\\left( = r ^ { ( l - 1 ) } \\right)$ , shape column activation $\\left( = q ^ { \\left( l \\right) } \\right)$ , and the corresponding mask $\\left( = A ^ { ( l ) } \\right)$ for $l$ -th convolution layer, where $A ^ { ( l ) } = r ^ { ( l - 1 ) } \\otimes q ^ { ( l ) }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            192,
+            101,
+            816,
+            356
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We now reformulate the optimization problem to include the shape column activation variables. Again, we aim to maximize the sum of the importance of active weights after pruning under the given resource constraints. Then, our optimization problem for simultaneous channel and spatial pruning is ",
+        "bbox": [
+            176,
+            431,
+            826,
+            474
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/848267483c4ec188e6c3fd8c8b1d666c9c643f871dd27af9cb5d6277364a5e4a.jpg",
+        "text": "$$\n\\begin{array} { l } { \\displaystyle \\underset { r ^ { ( s , L ) } , q ^ { ( 1 ; L ) } } { \\mathrm { m a x i m i z e } } \\ ~ \\sum _ { l = 1 } ^ { L } \\left. I ^ { ( l ) } , A ^ { ( l ) } \\right. } \\\\ { \\mathrm { s u b j e c t ~ t o } \\ \\displaystyle \\sum _ { l = 0 } ^ { L } a _ { l } \\left\\| r ^ { ( l ) } \\right\\| _ { 1 } + \\displaystyle \\sum _ { l = 1 } ^ { L } b _ { l } \\left\\| A ^ { ( l ) } \\right\\| _ { 1 } \\leq M } \\\\ { \\displaystyle r _ { j } ^ { ( l ) } \\leq \\sum _ { a , b } q _ { j , a , b } ^ { ( l ) } \\quad \\mathrm { a n d } \\quad q _ { j , a , b } ^ { ( l ) } \\leq r _ { j } ^ { ( l ) } \\quad \\forall l , j , a , b } \\\\ { \\displaystyle A ^ { ( l ) } = r ^ { ( l - 1 ) } \\otimes q ^ { ( l ) } \\quad \\forall l } \\\\ { \\displaystyle r ^ { ( l ) } \\in \\{ 0 , 1 \\} ^ { C } \\ a \\mathrm { n d } \\ q ^ { ( l ) } \\in \\{ 0 , 1 \\} ^ { C } \\times K _ { l } \\times K _ { l } \\quad \\forall l \\in [ L ] . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            272,
+            481,
+            728,
+            648
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We note that this optimization problem is also a discrete nonconvex QCQP. The details on the standard QCQP form of Equation (3) is provided in Supplementary material E. Furthermore, Proposition 1 below shows that the constraints in Equation (2) and Equation (3) provably eliminate any unpruned inactive weights and accurately model the resource usage as well as the objective of the pruned network. Also, Proposition 1 can be generalized to nonsequential networks with skip addition. The generalization and the proofs are given in Supplementary material D. ",
+        "bbox": [
+            173,
+            651,
+            825,
+            736
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Proposition 1. Optimizing over the input and output channel activation variables ${ r ^ { ( 0 : L ) } }$ and shape column activation variables $q ^ { ( 1 : L ) }$ under the constraints in Equation (3) provably removes any inactive weights in the pruned network, guaranteeing exact computation of 1) resource usage and 2) the sum of the importance of active weights in the pruned network. ",
+        "bbox": [
+            174,
+            741,
+            825,
+            797
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 OPTIMIZATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            814,
+            318,
+            829
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Concretely, Equation (2) and Equation (3) fall into the category of binary Mixed Integer Quadratic Constraint Quadratic Programming (MIQCQP). We solve these discrete QCQP problems with the CPLEX library (INC, 1993), which provides MIQCQP solvers based on the branch and cut technique. However, the branch and cut algorithm can lead to exponential search time (Mitchell, 2002) on large problems. Therefore, we provide a practical alternative utilizing a block coordinate descent style optimization method in Supplementary material B. ",
+        "bbox": [
+            174,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 RELATED WORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            349,
+            117
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Importance of channels Most of the channel pruning methods prune away the least important channels with a simple greedy approach, and the evaluation method for the importance of channels has been the main research problem (Molchanov et al., 2017; 2019; Liu et al., 2019). Channel pruning is divided into two major branches according to the method of evaluating the importance of channels: the trainable-importance method, which evaluates the importance of channels while training the whole network from scratch, and the fixed-importance method, which directly evaluates the importance of channels on the pretrained network. Trainable-importance channel pruning methods include the regularizer-based methods with group sparsity regularizers (Wen et al., 2016; Alvarez & Salzmann, 2016; Yang et al., 2019; Liu et al., 2017; Louizos et al., 2018; Liu et al., 2017; Gordon et al., 2018) and data-driven channel pruning methods (Kang & Han, 2020; You et al., 2019). Fixedimportance channel pruning methods first prune away most of the weights and then finetune the significantly smaller pruned network (Molchanov et al., 2017; 2019; Hu et al., 2016; He et al., 2018a; Li et al., 2017; He et al., 2019; Luo et al., 2017). As a result, fixed-importance methods are much more efficient than the trainable-importance channel pruning methods in terms of computational cost and memory as trainable-importance methods have to train the whole unpruned network. Our framework is on the line of fixed-importance channel pruning works. ",
+        "bbox": [
+            174,
+            136,
+            825,
+            357
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Predefined target structure and Automatic target structure Layer-wise channel pruning methods (Li et al., 2017; He et al., 2019), which perform pruning operations per each layer independently, require users to predefine the target pruned structure. Also, LCCL(Dong et al., 2017) exploits a predefined low-cost network to improve inference time. Another line of research finds the appropriate target structure automatically (He et al., 2018b; Yang et al., 2018; Liu et al., 2019; Molchanov et al., 2017). Our method also finds the target structure automatically under the explicit target resource constraints. ",
+        "bbox": [
+            174,
+            376,
+            825,
+            473
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Dynamic pruning and static pruning Dynamic pruning has a different network structure depending on the input during inference time, while static pruning has a fixed network structure during inference time. CGNet (Hua et al., 2019) dynamically identifies unnecessary features to reduce the computation, and FBS (Gao et al., 2019) dynamically skip computations on the unimportant channels. Our framework is static pruning and has a fixed network structure during inference time. ",
+        "bbox": [
+            174,
+            492,
+            825,
+            561
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Quadratic coupling CCP (Peng et al., 2019) formulates a QP (quadratic formulation) to consider the quadratic coupling between channels in the same layer under layer-wise constraints on the maximum number of channels. On the other hand, our formulation considers the quadratic coupling between channels in the neighboring layers under the target resource constraints. ",
+        "bbox": [
+            174,
+            580,
+            825,
+            636
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Channel pruning in nonsequential blocks Many network architectures contain nonsequential convolution operations, such as skip addition (He et al., 2016; Sandler et al., 2018; Tan & Le, 2019) and skip concatenation (Huang et al., 2017). Since these network architectures outperform sequential network architectures, pruning a network with nonsequential convolution operations is crucial. However, most channel pruning methods (Liu et al., 2017; He et al., 2018a; 2019; Molchanov et al., 2017; 2019) do not consider the nonsequential convolution operations and use the same method from the sequential network architecture. However, channel pruning methods ignorant of nonsequential convolution operations may result in the misalignment of feature maps connected by skip connections (You et al., 2019). GBN (You et al., 2019) forces parameters connected by a nonsequential convolution operation to share the same pruning pattern to solve this misalignment problem. In contrast, our formulation does not require strict pattern sharing. This flexibility allows for our methods to delete more channels under given constraints. ",
+        "bbox": [
+            174,
+            655,
+            825,
+            821
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Spatial pruning of convolution filters Spatial pruning methods aim to prune convolution filters along the channel dimension for inference efficiency. Spatial pruning methods manually define the spatial patterns of filters (Lebedev & Lempitsky, 2016; Anwar et al., 2017) or optimize spatial patterns of filters with group sparse regularizers (Wen et al., 2016; Lebedev & Lempitsky, 2016). Among these works, Lebedev & Lempitsky (2016) empirically demonstrates that enforcing sparse spatial patterns in 2-D filters along the input channel leads to great speed-up during inference time using group sparse convolution operations (Chellapilla et al., 2006). Our proposed method enforces the spatial patterns in 2-D filters as in Lebedev & Lempitsky (2016) for speed-up in inference. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            152,
+            326,
+            167
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We compare the classification accuracy of the pruned network against several pruning baselines on CIFAR-10 (Krizhevsky et al., 2009) and ImageNet (Russakovsky et al., 2015) datasets using various ResNet architectures (He et al., 2016), DenseNet-40 (Huang et al., 2017), and VGG-16 (Simonyan & Zisserman, 2015). Note that most pruning baselines apply an iterative pruning procedure, which repeatedly alternates between network pruning and finetuning until the target resource constraints are satisfied (Han et al., 2015; He et al., 2018a; Liu et al., 2017; Yang et al., 2018). In contrast, since our methods explicitly include the target resource constraint to the optimization framework, we only need one round of pruning and finetuning. ",
+        "bbox": [
+            174,
+            184,
+            825,
+            296
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 EXPERIMENTAL SETTINGS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            313,
+            397,
+            327
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We follow the ‘smaller-norm-less-important’ criterion (Ye et al., 2018; Liu et al., 2017), which evaluates the importance of weights as the absolute value of weight (Han et al., 2015; Guo et al., 2016). We assume the network size and FLOPs reduction are linearly proportional to the sparsity in shape column activations, as empirically shown in Lebedev & Lempitsky (2016). Also, we ignore the extra memory overhead for storing the shape column activations due to its negligible size compared to the total network size. In the experiment tables, FLOPs and the network size of the pruned network are computed according to the resource specifications in Equations (2) and (3). Also, ‘Pruning ratio’ in the tables denotes the ratio of pruned weights among the total weights in baseline networks. ‘ours-c’ and ‘ours-cs’ in the tables denote our method with channel pruning and our method with both the channel and spatial pruning, respectively. ",
+        "bbox": [
+            173,
+            338,
+            825,
+            478
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/8ed482cb7e51d2ec9d8fd6dcf4ef3bc1c09db2e774bdc67bb82df5bc3183593c.jpg",
+        "table_caption": [
+            "Table 2: Pruned accuracy and accuracy drop from the baseline network at given FLOPs (left) and pruning ratios (right) on various network architectures (ResNet-20,32,56 and DenseNet-40) at CIFAR-10. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td rowspan=\"2\">Method</td><td rowspan=\"2\">Baseline acc</td><td colspan=\"3\">FLOPs</td></tr><tr><td>Pruned acc↑</td><td>Acc drop↓</td><td>FLOPs(%)↓</td></tr><tr><td rowspan=\"9\">ResNet-20</td><td>FPGM (He et al.,2019)</td><td>92.21 (0.18)</td><td>91.26 (0.24)</td><td>0.95</td><td>46.0</td></tr><tr><td>ours-c</td><td>92.21 (0.18)</td><td>90.96 (0.15)</td><td>1.25</td><td>46.0</td></tr><tr><td>ours-cs</td><td>92.21 (0.18)</td><td>91.70 (0.18)</td><td>0.51</td><td>46.0</td></tr><tr><td>LCCL (Dong et al.,2017)</td><td>92.74</td><td>91.68</td><td>1.06</td><td>62.1</td></tr><tr><td>SFP (He et al.,2018a)</td><td>92.20 (0.18)</td><td>90.83 (0.31)</td><td>1.37</td><td>57.8</td></tr><tr><td>FPGM (He et al.,2019)</td><td>92.21 (0.18)</td><td>91.72 (0.20)</td><td>0.49</td><td>57.8</td></tr><tr><td>ours-c</td><td>92.21 (0.18)</td><td>91.74 (0.20)</td><td>0.47</td><td>58.3</td></tr><tr><td>ours-cs</td><td>92.21 (0.18)</td><td>92.26 (0.10)</td><td>-0.05</td><td>57.8</td></tr><tr><td>FPGM(He et al.,2019)</td><td>92.88 (0.86)</td><td>91.96 (0.76)</td><td>0.92</td><td>46.8</td></tr><tr><td rowspan=\"9\">ResNet-32</td><td>ours-c</td><td>92.88 (0.86)</td><td>91.98 (0.42)</td><td>0.90</td><td>46.8</td></tr><tr><td>ours-cs</td><td>92.88 (0.86)</td><td>92.33 (0.41)</td><td>0.55</td><td>47.0</td></tr><tr><td>LCCL (Dong et al.,2017)</td><td>92.33</td><td>90.74</td><td>1.59</td><td>69.0</td></tr><tr><td>SFP (He et al.,2018a)</td><td>92.63 (0.70)</td><td>92.08 (0.08)</td><td>0.55</td><td>58.5</td></tr><tr><td>FPGM (He et al.,2019)</td><td>92.88 (0.86)</td><td>92.51 (0.90)</td><td>0.37</td><td>58.5</td></tr><tr><td>ours-c</td><td>92.88 (0.86)</td><td>92.52 (0.46)</td><td>0.36</td><td>57.2</td></tr><tr><td>ours-cs</td><td>92.88 (0.86)</td><td>92.80 (0.61)</td><td>0.08</td><td>57.9</td></tr><tr><td>SFP (He et al.,2018a)</td><td>93.59 (0.58)</td><td>92.26 (0.31)</td><td>1.33</td><td>47.5</td></tr><tr><td>FPGM (He et al.,2019)</td><td>93.59 (0.58)</td><td>93.49 (0.13)</td><td>0.10</td><td>47.5</td></tr><tr><td rowspan=\"8\"></td><td></td><td>93.50</td><td>93.42</td><td>0.08</td><td>47.4</td></tr><tr><td>CCP (Peng et al.,2019)</td><td>92.8</td><td>91.9</td><td></td><td></td></tr><tr><td>AMC (He et al.,2018b)</td><td></td><td></td><td>0.9</td><td>50.0</td></tr><tr><td>SCP(Kang &amp; Han,2020)</td><td>93.69</td><td>93.23</td><td>0.46</td><td>48.5</td></tr><tr><td>ours-c</td><td>93.59 (0.58)</td><td>93.36 (0.68)</td><td>0.23</td><td>47.4</td></tr><tr><td>ours-cs</td><td>93.59 (0.58)</td><td>93.59 (0.36)</td><td>0.00</td><td>47.4</td></tr><tr><td>SCP(Kang&amp; Han,2020)</td><td>94.39</td><td>93.77</td><td>0.62</td><td>29.2</td></tr><tr><td>ours-c</td><td>95.01</td><td>93.80</td><td>1.21</td><td>29.2</td></tr><tr><td rowspan=\"8\"></td><td>ours-cs</td><td>95.01</td><td>94.25</td><td>0.76</td><td>29.2</td></tr><tr><td>slimming (Liu et al.,2017)</td><td>93.89</td><td>94.35</td><td>-0.46</td><td>45.0</td></tr><tr><td>ours-c</td><td>95.01</td><td>94.38</td><td>0.63</td><td>45.0</td></tr><tr><td>ours-cs</td><td>95.01</td><td>94.85</td><td>0.16</td><td>45.0</td></tr><tr><td>slimming (Liu et al.,2017)</td><td>93.89</td><td>94.81</td><td>-0.92</td><td>71.6</td></tr><tr><td>ours-c</td><td></td><td>94.82</td><td>0.19</td><td>71.0</td></tr><tr><td></td><td>95.01</td><td></td><td></td><td></td></tr><tr><td>ours-cs</td><td>95.01</td><td>95.02</td><td>-0.01</td><td>71.0</td></tr></table>",
+        "bbox": [
+            176,
+            492,
+            622,
+            857
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/23e4242ce6cd82cce786b1bc2ad11338cd04b65912bd144c36189cf4e35b9def.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"3\">Network size</td></tr><tr><td>Pruned acc↑</td><td>Acc drop↓</td><td>Pruning ratio(%)↑</td></tr><tr><td>91.26 (0.24)</td><td>0.95</td><td>54.0</td></tr><tr><td>91.26 (0.18)</td><td>0.95</td><td>54.1</td></tr><tr><td>92.02 (0.10)</td><td>0.19</td><td>54.0</td></tr><tr><td>91.68</td><td>1.06</td><td>33.1</td></tr><tr><td>90.83 (0.31)</td><td>1.37</td><td>42.2</td></tr><tr><td>91.72 (0.20)</td><td>0.49</td><td>42.2</td></tr><tr><td>92.27 (0.17).</td><td>-0.06</td><td>42.3</td></tr><tr><td>92.35 (0.10)</td><td>-0.14</td><td>42.2</td></tr><tr><td>91.96 (0.76)</td><td>0.92</td><td>53.2</td></tr><tr><td>92.22 (1.02)</td><td>0.66</td><td>53.2</td></tr><tr><td>92.78 (0.97)</td><td>0.10</td><td>53.2</td></tr><tr><td>90.74</td><td>1.59</td><td>37.5</td></tr><tr><td>92.08 (0.08)</td><td>0.55</td><td>41.5</td></tr><tr><td>92.51 (0.90)</td><td>0.37</td><td>41.5</td></tr><tr><td>92.42 (0.77)</td><td>0.46</td><td>42.7</td></tr><tr><td>92.83 (0.83)</td><td>0.05</td><td>42.7</td></tr><tr><td>92.26 (0.31)</td><td>1.33</td><td>52.6</td></tr><tr><td>93.49 (0.13)</td><td>0.10</td><td>52.6</td></tr><tr><td>=</td><td>-</td><td>-</td></tr><tr><td></td><td>=</td><td>=</td></tr><tr><td>93.23</td><td>0.46</td><td>51.5</td></tr><tr><td>93.37 (0.96)</td><td>0.22</td><td>52.7</td></tr><tr><td>93.69 (0.69)</td><td>-0.10</td><td>52.6</td></tr><tr><td></td><td></td><td>-</td></tr><tr><td></td><td></td><td>=</td></tr><tr><td></td><td>=</td><td>=</td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr></table>",
+        "bbox": [
+            635,
+            492,
+            820,
+            857
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 CIFAR-10 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            290,
+            117
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "CIFAR-10 dataset has 10 different classes with $5 k$ training images and $1 k$ test images per each class Krizhevsky et al. (2009). In CIFAR-10 experiments, we evaluate our methods on various network architectures: ResNet-20, 32, 56, and DenseNet-40. We provide implementation of the details for the experiments in Supplementary material C. We show the experiment results of pruning under FLOPs constraints in the left column of Table 2 and under final network size constraints in the right column of Table 2. ",
+        "bbox": [
+            174,
+            128,
+            825,
+            213
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "On the FLOPs experiments in the left column of Table 2, ‘ours-c’ shows comparable results against FPGM, which is the previous state of the art method, on ResNet-20, 32, and 56. Moreover, ‘ours-cs’ significantly outperforms both ‘ours-c’ and FPGM on the same architectures showing the state of the art performance. Also, ‘ours-c’ shows comparable results against slimming (Liu et al., 2017) and SCP (Kang & Han, 2020), while ‘ours-cs’ outperforms existing baselines by a large margin on DenseNet-40. ",
+        "bbox": [
+            174,
+            219,
+            825,
+            303
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "On the network size experiments in the right column of Table 2, ‘ours-c’ shows results competitive to FPGM and SCP, while ‘ours-cs’ again achieves the state of the art performance on ResNet-20, 32, and 56. Notably, in ResNet-56, ‘ours-cs’ achieves a minimal accuracy drop of $- 0 . 1 0$ with the pruning ratio of $5 2 . 6 \\%$ . These results show simultaneous channel and spatial pruning produces more efficient networks with better performance compared to other channel pruning methods on CIFAR-10. ",
+        "bbox": [
+            174,
+            310,
+            825,
+            381
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.3 IMAGENET ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            397,
+            292,
+            411
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "ILSVRC-2012 (Russakovsky et al., 2015) is a large-scale dataset with 1000 classes that comes with $1 . 2 8 M$ training images and $5 0 k$ validation images. We conduct our methods under the fixed FLOPs constraint on ResNet-18,50, and VGG-16. For more implementation details of the ImageNet experiments, refer to Supplementary material C. Table 3 shows the experiment results on ImageNet. In ResNet-50, ‘ours- $. \\mathrm { c } '$ ’ and ‘ours-cs’ achieve results comparable to GBN, a trainable-importance channel pruning method which is the previous state of the art, even though our method is a fixedimportance channel pruning method. In particular, top1 pruned accuracy in ‘ours-cs’ exceeds SFP by $1 . 3 2 \\%$ using a similar number of FLOPs. Both ‘ours-cs’ and ‘ours-c’ clearly outperform FPGM in ResNet-50. Also, ‘ours- $\\cdot \\mathrm { c } '$ and ‘ours-cs’ show significantly better performance than Molchanov et al. (2017) on VGG-16. ",
+        "bbox": [
+            173,
+            422,
+            825,
+            563
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/ab65cd639c68c4b5ab992d57c24660308420e3ed2516ebe267b4d271c23c74af.jpg",
+        "table_caption": [
+            "Table 3: Top1,5 pruned accuracy and accuracy drop from the baseline network at given FLOPs on various network architectures (ResNet-18,50, and VGG-16) at ImageNet. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Network</td><td>Method</td><td>Top1 Pruned Acc↑</td><td>Topl Acc drop↓</td><td>Top5 Pruned Acc↑</td><td>Top5 Acc drop↓</td><td>FLOPs(%)↓</td></tr><tr><td rowspan=\"6\">ResNet-18</td><td rowspan=\"6\">SFP (He et al.,2018a) FPGM (He et al.,2019) ours-c</td><td>67.10</td><td>3.18</td><td>87.78</td><td>1.85</td><td>58.2</td></tr><tr><td>68.41</td><td>1.87</td><td>88.48</td><td>1.15</td><td>58.2</td></tr><tr><td>67.48</td><td>2.28</td><td>87.78</td><td>1.30</td><td>60.9</td></tr><tr><td>69.59</td><td>0.17</td><td>88.94</td><td>0.14</td><td>58.2</td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td>LCCL (Dong et al.,2017) 66.33 68.65</td><td>3.65 1.11</td><td>86.94 88.69</td><td>2.29 0.39</td><td>65.3 65.9</td></tr><tr><td rowspan=\"6\">ResNet-50</td><td rowspan=\"6\">ours-cs SFP (He et al.,2018a) FPGM (He et al.,2019)</td><td>70.05</td><td>-0.29</td><td>89.24</td><td>-0.16</td><td>65.9</td></tr><tr><td>74.61</td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>1.54</td><td>92.06</td><td>0.81</td><td>58.3</td></tr><tr><td>75.50</td><td>0.65</td><td>92.63</td><td>0.21</td><td>57.8</td></tr><tr><td>75.78</td><td>0.37</td><td>91.86</td><td>1.01</td><td>57.8</td></tr><tr><td>75.93</td><td>0.22</td><td>92.68</td><td>0.19</td><td>57.8</td></tr><tr><td rowspan=\"6\"></td><td>GBN (You et al.,2019) ours-c ours-cs</td><td>76.19 75.89</td><td>-0.31 0.26</td><td>92.83 92.84</td><td>-0.16 0.03</td><td>59.5 61.5</td></tr><tr><td></td><td>76.00</td><td>0.15</td><td>92.76</td><td>0.11</td><td>59.0</td></tr><tr><td>Molchanov et al. (2017)</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>ours-c</td><td>- 65.92</td><td></td><td>84.5</td><td>5.9</td><td>51.7</td></tr><tr><td></td><td></td><td>5.67</td><td>87.20</td><td>3.18</td><td>51.7</td></tr><tr><td>ours-cs</td><td>66.36</td><td>5.23</td><td>87.36</td><td>3.02</td><td>51.7</td></tr></table>",
+        "bbox": [
+            173,
+            574,
+            825,
+            782
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            849,
+            318,
+            866
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We present a discrete QCQP based optimization framework for jointly pruning channel and spatial filters under various architecture realizations. Since our methods model the inherent quadratic coupling between channels in the neighboring layers to eliminate any inactive weights during the pruning procedure, they allow exact modeling of the user-specified resource constraints and enable the direct optimization of the true objective on the pruned network. The experiments show our proposed method significantly outperforms other fixed-importance channel pruning methods, finding smaller and faster networks with the least drop in accuracy. ",
+        "bbox": [
+            174,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            181,
+            285,
+            195
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jose M Alvarez and Mathieu Salzmann. Learning the number of neurons in deep networks. In NeurIPS, 2016. ",
+        "bbox": [
+            171,
+            204,
+            825,
+            233
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sajid Anwar, Kyuyeon Hwang, and Wonyong Sung. Structured pruning of deep convolutional neural networks. In JETC, 2017. ",
+        "bbox": [
+            174,
+            241,
+            823,
+            270
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kumar Chellapilla, Sidd Puri, and Patrice Simard. High performance convolutional neural networks for document processing. In IWFHR, 2006. ",
+        "bbox": [
+            173,
+            279,
+            825,
+            308
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jan K Chorowski, Dzmitry Bahdanau, Dmitriy Serdyuk, Kyunghyun Cho, and Yoshua Bengio. Attention-based models for speech recognition. In NeurIPS. 2015. ",
+        "bbox": [
+            169,
+            315,
+            825,
+            345
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "J. Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. In NAACL-HLT, 2019. ",
+        "bbox": [
+            171,
+            354,
+            823,
+            383
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Xuanyi Dong, Junshi Huang, Yi Yang, and Shuicheng Yan. More is less: A more complicated network with less inference complexity. In CVPR, 2017. ",
+        "bbox": [
+            173,
+            392,
+            823,
+            421
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Xitong Gao, Yiren Zhao, Łukasz Dudziak, Robert Mullins, and Cheng-zhong Xu. Dynamic channel pruning: Feature boosting and suppression. 2019. ",
+        "bbox": [
+            171,
+            429,
+            825,
+            458
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ariel Gordon, Elad Eban, Ofir Nachum, Bo Chen, Hao Wu, Tien-Ju Yang, and Edward Choi. Morphnet: Fast & simple resource-constrained structure learning of deep networks. In CVPR, 2018. ",
+        "bbox": [
+            176,
+            467,
+            825,
+            510
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yiwen Guo, Anbang Yao, and Yurong Chen. Dynamic network surgery for efficient dnns. In NeurIPS, 2016. ",
+        "bbox": [
+            174,
+            518,
+            823,
+            547
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Song Han, Jeff Pool, John Tran, and William Dally. Learning both weights and connections for efficient neural network. In NeurIPS, 2015. ",
+        "bbox": [
+            176,
+            555,
+            823,
+            585
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016. ",
+        "bbox": [
+            173,
+            593,
+            823,
+            623
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yang He, Guoliang Kang, Xuanyi Dong, Yanwei Fu, and Yi Yang. Soft filter pruning for accelerating deep convolutional neural networks. In IJCAI, 2018a. ",
+        "bbox": [
+            174,
+            631,
+            821,
+            661
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yang He, Ping Liu, Ziwei Wang, Zhilan Hu, and Yi Yang. Filter pruning via geometric median for deep convolutional neural networks acceleration. In CVPR, 2019. ",
+        "bbox": [
+            176,
+            669,
+            821,
+            698
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yihui He, Ji Lin, Zhijian Liu, Hanrui Wang, Li-Jia Li, and Song Han. Amc: Automl for model compression and acceleration on mobile devices. In ECCV, 2018b. ",
+        "bbox": [
+            174,
+            707,
+            821,
+            736
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Hengyuan Hu, Rui Peng, Yu-Wing Tai, and Chi-Keung Tang. Network trimming: A data-driven neuron pruning approach towards efficient deep architectures. In arXiv:1607.03250, 2016. ",
+        "bbox": [
+            173,
+            744,
+            821,
+            773
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Weizhe Hua, Yuan Zhou, Christopher M De Sa, Zhiru Zhang, and G Edward Suh. Channel gating neural networks. In NIPS, 2019. ",
+        "bbox": [
+            176,
+            781,
+            823,
+            810
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Gao Huang, Zhuang Liu, Laurens Van Der Maaten, and Kilian Q Weinberger. Densely connected convolutional networks. In CVPR, 2017. ",
+        "bbox": [
+            176,
+            819,
+            821,
+            849
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "CPLEX OPTIMIZATION INC. Using the cplex callable library and cplex mixed integer library. In Incline Village, NV, 1993. ",
+        "bbox": [
+            174,
+            857,
+            821,
+            887
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Minsoo Kang and Bohyung Han. Operation-aware soft channel pruning using differentiable masks. In ICML, 2020. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. In Tech Report, 2009. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Vadim Lebedev and Victor Lempitsky. Fast convnets using group-wise brain damage. In CVPR, 2016. ",
+        "bbox": [
+            173,
+            141,
+            825,
+            171
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hao Li, Asim Kadav, Igor Durdanovic, Hanan Samet, and Hans Peter Graf. Pruning filters for efficient convnets. In ICLR, 2017. ",
+        "bbox": [
+            171,
+            179,
+            823,
+            209
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Z. Liu, H. Mu, X. Zhang, Z. Guo, X. Yang, K. Cheng, and J. Sun. Metapruning: Meta learning for automatic neural network channel pruning. In 2019 IEEE/CVF International Conference on Computer Vision (ICCV), 2019. ",
+        "bbox": [
+            176,
+            217,
+            823,
+            261
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zhuang Liu, Jianguo Li, Zhiqiang Shen, Gao Huang, Shoumeng Yan, and Changshui Zhang. Learning efficient convolutional networks through network slimming. In ICCV, 2017. ",
+        "bbox": [
+            173,
+            270,
+            821,
+            299
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zhuang Liu, Mingjie Sun, Tinghui Zhou, Gao Huang, and Trevor Darrell. Rethinking the value of network pruning. In ICLR, 2019. ",
+        "bbox": [
+            173,
+            308,
+            821,
+            337
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Christos Louizos, Max Welling, and Diederik P Kingma. Learning sparse neural networks through l_0 regularization. In ICLR, 2018. ",
+        "bbox": [
+            173,
+            345,
+            823,
+            376
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jian-Hao Luo, Jianxin Wu, and Weiyao Lin. Thinet: A filter level pruning method for deep neural network compression. In ICCV, 2017. ",
+        "bbox": [
+            171,
+            383,
+            823,
+            414
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "John E Mitchell. Branch-and-cut algorithms for combinatorial optimization problems. In Handbook of applied optimization, 2002. ",
+        "bbox": [
+            173,
+            422,
+            823,
+            452
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Pavlo Molchanov, Stephen Tyree, Tero Karras, Timo Aila, and Jan Kautz. Pruning convolutional neural networks for resource efficient inference. In ICLR, 2017. ",
+        "bbox": [
+            173,
+            460,
+            823,
+            489
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Pavlo Molchanov, Arun Mallya, Stephen Tyree, Iuri Frosio, and Jan Kautz. Importance estimation for neural network pruning. In CVPR, 2019. ",
+        "bbox": [
+            174,
+            498,
+            823,
+            529
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hanyu Peng, Jiaxiang Wu, Shifeng Chen, and Junzhou Huang. Collaborative channel pruning for deep networks. In ICML, 2019. ",
+        "bbox": [
+            174,
+            536,
+            823,
+            566
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Joseph Redmon and Ali Farhadi. Yolov3: An incremental improvement. In arXiv:1804.02767, 2018. ",
+        "bbox": [
+            173,
+            574,
+            823,
+            592
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, et al. Imagenet large scale visual recognition challenge. In IJCV, 2015. ",
+        "bbox": [
+            176,
+            599,
+            823,
+            642
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mark Sandler, Andrew Howard, Menglong Zhu, Andrey Zhmoginov, and Liang-Chieh Chen. Mobilenetv2: Inverted residuals and linear bottlenecks. In CVPR, 2018. ",
+        "bbox": [
+            169,
+            651,
+            825,
+            681
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. In ICLR, 2015. ",
+        "bbox": [
+            171,
+            689,
+            825,
+            719
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mingxing Tan and Quoc Le. Efficientnet: Rethinking model scaling for convolutional neural networks. In ICML, 2019. ",
+        "bbox": [
+            171,
+            728,
+            825,
+            757
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Stefan Van Der Walt, S Chris Colbert, and Gael Varoquaux. The numpy array: a structure for efficient numerical computation. In CISE, 2011. ",
+        "bbox": [
+            171,
+            766,
+            825,
+            796
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Wei Wen, Chunpeng Wu, Yandan Wang, Yiran Chen, and Hai Li. Learning structured sparsity in deep neural networks. In NeurIPS, 2016. ",
+        "bbox": [
+            173,
+            804,
+            825,
+            834
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Huanrui Yang, Wei Wen, and Hai Li. Deephoyer: Learning sparser neural network with differentiable scale-invariant sparsity measures. In ICLR, 2019. ",
+        "bbox": [
+            169,
+            843,
+            823,
+            872
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tien-Ju Yang, Andrew Howard, Bo Chen, Xiao Zhang, Alec Go, Mark Sandler, Vivienne Sze, and Hartwig Adam. Netadapt: Platform-aware neural network adaptation for mobile applications. In ECCV, 2018. ",
+        "bbox": [
+            176,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jianbo Ye, Xin Lu, Zhe Lin, and James Z Wang. Rethinking the smaller-norm-less-informative assumption in channel pruning of convolution layers. In ICLR, 2018. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zhonghui You, Kun Yan, Jinmian Ye, Meng Ma, and Ping Wang. Gate decorator: Global filter pruning method for accelerating deep convolutional neural networks. In NeurIPS, 2019. ",
+        "bbox": [
+            176,
+            141,
+            823,
+            170
+        ],
+        "page_idx": 10
+    }
+]

parse/train/vrCiOrqgl3B/vrCiOrqgl3B.md

@@ -0,0 +1,683 @@
+# OUTLIER-ROBUST OPTIMAL TRANSPORT
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Optimal transport (OT) provides a way of measuring distances between distributions that depends on the geometry of the sample space. In light of recent advances in solving the OT problem, OT distances are widely used as loss functions in minimum distance estimation. Despite its prevalence and advantages, however, OT is extremely sensitive to outliers. A single adversarially-picked outlier can increase OT distance arbitrarily. To address this issue, in this work we propose an outlier-robust OT formulation. Our formulation is convex but challenging to scale at a first glance. We proceed by deriving an equivalent formulation based on cost truncation that is easy to incorporate into modern stochastic algorithms for regularized OT. We demonstrate our model applied to mean estimation under the Huber contamination model in simulation as well as outlier detection on real data.
+
+# 1 INTRODUCTION
+
+Optimal transport is a fundamental problem in applied mathematics. In its original form (Monge, 1781), the problem entails finding the minimum cost way to transport mass from a prescribed probability distribution $\mu$ on $\mathcal { X }$ to another prescribed distribution $\nu$ on $\mathcal { X }$ . Kantorovich (1942) relaxed Monge’s formulation of the optimal transport problem to obtain the Kantorovich formulation:
+
+$$
+{ \mathrm { O T } } ( \mu , \nu ) \triangleq \operatorname* { m i n } _ { \Pi \in { \mathcal { F } } ( \mu , \nu ) } \mathbb { E } _ { ( X _ { 1 } , X _ { 2 } ) \sim \Pi } { \big [ } c ( X _ { 1 } , X _ { 2 } ) { \big ] } ,
+$$
+
+where $\mathcal { F } ( \mu , \nu )$ is the set of couplings between $\mu$ and $\nu$ (probability distributions on $\mathcal { X } \times \mathcal { X }$ whose marginals are $\mu$ and $\nu$ ) and $c$ is a cost function, where we typically assume $c ( x , y ) ~ \geq ~ 0$ and $c ( x , x ) = 0$ . Compared to other notions of distance between probability distributions, optimal transport uniquely depends on the geometry of the sample space.
+
+Recent advancements in optimization for optimal transport (Cuturi, 2013; Solomon et al., 2015; Genevay et al., 2016; Seguy et al., 2018) enabled its broad adaptation in machine learning applications where geometry of the data is important. See (Peyre & Cuturi, 2018) for a survey. Optimal ´ transport has found applications in natural language processing (Kusner et al., 2015; Huang et al., 2016; Alvarez-Melis & Jaakkola, 2018; Yurochkin et al., 2019), generative modeling (Arjovsky et al., 2017), clustering (Ho et al., 2017), domain adaptation (Courty et al., 2014; 2017), large-scale Bayesian modeling (Srivastava et al., 2018), and many other domains.
+
+Many applications use OT as a loss in an optimization problem of the form:
+
+$$
+\theta \in { \mathrm { a r g } } \operatorname* { m i n } _ { \theta \in \Theta } \mathrm { O T } ( \mu _ { n } , \nu _ { \theta } ) ,
+$$
+
+where $\{ \nu _ { \theta } \} _ { \theta \in \Theta }$ is a collection of parametric models, $\mu _ { n }$ is the empirical distribution of the samples. Such estimators are called minimum Kantorovich estimators $( M K E )$ (Bassetti et al., 2006). They are popular alternatives to likelihood-based estimators, especially in generative modeling. For example, when $\operatorname { O T } ( \cdot , \cdot )$ is the Wasserstein-1 distance and $\nu _ { \theta }$ is a generator parameterized by a neural network with weights $\theta$ , equation 1.2 corresponds to the Wasserstein GAN (Arjovsky et al., 2017).
+
+One drawback of optimal transport is its sensitivity to outliers. Because all the mass in $\mu$ must be transported to $\nu$ , a small fraction of outliers can have an outsized impact on the optimal transport problem. For statistics and machine learning applications in which the data is corrupted or noisy, this is a major issue. For example, the poor performance of Wasserstein GANs in the presence of outliers was noted in the recent works on outlier-robust generative learning with $f$ -divergence GANs (Chao et al., 2018; Wu et al., 2020). The problem of outlier-robustness in MKE has not been studied, with the exception of two concurrent works (Staerman et al., 2020; Balaji et al., 2020).
+
+In this paper, we propose a modification of OT to address its sensitivity to outliers. Our formulation can be used as a loss in equation 1.2 so that it is robust to a small fraction of outliers in the data. To keep things simple, we consider the $\epsilon$ -contamination model (Huber & Ronchetti, 2009). Let $\nu _ { \theta _ { 0 } }$ be a member of a parametric model $\{ \nu _ { \theta } : \theta \in \Theta \}$ and let
+
+$$
+\mu = ( 1 - \epsilon ) \nu _ { \theta _ { 0 } } + \epsilon \tilde { \nu } ,
+$$
+
+where $\mu$ is the data-generating distribution, $\epsilon > 0$ is the fraction of outliers, and $\tilde { \nu }$ is the distribution of the outliers. Although the fraction of outliers is capped at $\epsilon$ , the value of the outliers is arbitrary, so the outliers may have an arbitrarily large impact on the optimal transport problem. Our goal is to modify the optimal transport problem so that it is more robust to outliers. We have in mind the downstream application of learning $\theta _ { 0 }$ from (samples from) $\mu$ in the $\epsilon$ -contamination model. Our main contributions are as follows:
+
+1. We propose a robust OT formulation that is suitable for statistical estimation in the $\epsilon$ - contamination model using MKE. 2. We show that our formulation is equivalent to the original OT problem with a clipped transport cost. This connection enables us to leverage the voluminous literature on computational optimal transport to develop efficient algorithm to perform MKE robust to outliers. 3. Our formulation enables a new application of optimal transport: outlier detection in data.
+
+# 2 PROBLEM FORMULATION
+
+# 2.1 ROBUST OT FOR MKE
+
+To promote outlier-robustness in MKE, we need to allow the corresponding OT problem to ignore the outliers in the data distribution $\mu$ . The $\epsilon$ -contamination model imposes a cap on the fraction of outliers, so it is not hard to see that $\| \mu - \nu _ { \theta _ { 0 } } \| _ { \mathsf { T V } } \leq \epsilon$ , where $\| \cdot \| _ { \mathsf { T V } }$ is the total-variation norm defined as $\begin{array} { r } { \| \mu \| _ { \mathrm { I V } } = \int \frac { 1 } { 2 } | \mu ( \mathrm { d } x ) | } \end{array}$ . This suggests we solve a TV-constrained/regularized version of equation 1.2. The constrained version
+
+$$
+\begin{array} { l l } { \displaystyle \operatorname* { m i n } _ { \theta \in \Theta , \tilde { \mu } } } & { \mathrm { O T } ( \tilde { \mu } , \nu _ { \theta } ) } \\ { \mathsf { s u b j e c t } \mathrm { t o } } & { \| \mu - \tilde { \mu } \| _ { \mathsf { T V } } \leq \epsilon } \end{array}
+$$
+
+suffers from identification issues. In particular, it cannot distinguish between “clean” distributions within TV distance $\epsilon$ of $\nu _ { \theta _ { 0 } }$ . This makes it unsuitable as a loss function for statistical estimation, because it cannot lead to a consistent estimator. However, its regularized counterpart
+
+$$
+\operatorname* { m i n } _ { \theta \in \Theta , s } \mathrm { O T } ( \mu + s , \nu _ { \theta } ) + \lambda \| s \| _ { \mathsf { T V } } ,
+$$
+
+where $\lambda > 0$ is a regularization parameter, does not suffer from this issue. In the rest of this paper, we work with the TV-regularized formulation equation 2.1.
+
+The main idea of our formulation is to allow for modifications of $\mu$ , while penalizing their magnitude and ensuring that the modified $\mu$ is still a probability measure. Below we formulate this intuition in an optimization problem titled ROBOT (ROBust Optimal Transport):
+
+# Formulation 1:
+
+$$
+\begin{array} { r } { \mathrm { R O B O T } ( \mu , \nu ) = \left\{ \begin{array} { l l } { \operatorname* { m i n } _ { \Pi \in \mathcal { F } ^ { + } ( \mathbb { R } ^ { d } \times \mathbb { R } ^ { d } ) } } & { \displaystyle \int C ( x , y ) \Pi ( \mathrm { d } x , \mathrm { d } y ) + \lambda \| s \| _ { \mathbb { T } \mathbb { V } } } \\ { \displaystyle s \epsilon \mathcal { F } ( \mathbb { R } ^ { d } ) } & { \displaystyle \int _ { B \times \mathbb { R } ^ { d } } \Pi ( \mathrm { d } x , \mathrm { d } y ) = \int _ { B } ( \mu ( \mathrm { d } x ) + s ( \mathrm { d } x ) ) \geq 0 } \\ & { ~ \forall B \in \mathcal { B } ( \mathbb { R } ^ { d } ) \mathrm { ~ ( B o r e ~ } | \sigma - \mathrm { a } | \mathrm { g e b r a } ) } \\ & { ~ \displaystyle \int _ { \mathbb { R } ^ { d } \times \mathcal { C } } \Pi ( \mathrm { d } x , \mathrm { d } y ) = \int _ { C } \nu ( \mathrm { d } y ) ~ \forall C \in \mathcal { B } ( \mathbb { R } ^ { d } ) } \\ & { ~ \displaystyle \int _ { s ( \mathrm { d } x ) = 0 } s ( \mathrm { d } x ) = 0 . } \end{array} \right. } \end{array}
+$$
+
+Here ${ \mathcal { F } } ( \mathbb { R } ^ { d } )$ denotes the set of all signed measures with finite total variation on $\mathbb { R } ^ { d }$ , $\mathcal { F } ^ { + } ( \mathbb { R } ^ { d } \times \mathbb { R } ^ { d } )$ is the set of all measures with finite total variation on $\mathbb { R } ^ { d } \times \mathbb { R } ^ { d }$ .
+
+The first and the last constraints ensure that $\mu + s$ is a valid probability measure, while $\lambda \| s \| _ { \mathrm { T V } }$ penalizes the amount of modifications in $\mu$ . It is worth noting that we can identify exact locations of outliers in $\mu$ by inspecting $\mu + s$ , i.e. if $\dot { \mu ( x ) } + s ( x ) = 0$ , then $x$ got eliminated and is an outlier.
+
+ROBOT, unlike classical OT, guarantees that an adversarially picked outliers can not increase the distance arbitrarily. Let $\tilde { \mu } = ( 1 - \epsilon ) \mu + \epsilon \mu _ { c }$ , i.e. $\tilde { \mu }$ is $\mu$ contaminated with outliers from $\mu _ { c }$ , and let $\nu$ be an arbitrary measure (in MKE, $\tilde { \mu }$ is the contaminated data and $\nu$ is the model we learn). Adversary can arbitrarily increase $\operatorname { O T } ( \tilde { \mu } , \nu )$ by manipulating the outlier distribution $\mu _ { c }$ . For ROBOT we have the following bound:
+
+Theorem 2.1. Let $\tilde { \mu } = ( 1 - \epsilon ) \mu + \epsilon \mu _ { c }$ for some $\epsilon \in [ 0 , 1 )$ , then
+
+$$
+\mathrm { R O B O T } ( \tilde { \mu } , \nu ) \leq ( \mathrm { O T } ( \mu , \nu ) + \lambda \epsilon \| \mu - \mu _ { c } \| _ { \mathrm { T V } } ) \wedge \lambda \| \tilde { \mu } - \nu \| _ { \mathrm { T V } } \wedge \mathrm { O T } ( \tilde { \mu } , \nu ) .
+$$
+
+This bound has two key takeaways: since TV norm of any two distributions is bounded by 1, adversary can not increase $\mathrm { R O B O T } ( \tilde { \mu } , \nu )$ arbitrarily; in the absence of outliers, ROBOT is bounded by classical OT. See Appendix C for the proof.
+
+Related work We note connection between equation 2.2 and unbalanced OT (UOT) (Chizat., 2017; Chizat et al., 2018). UOT is typically formulated by replacing TV norm with $\operatorname { K L } ( \mu + s | \mu )$ and adding an analogous term for $\nu$ . Chizat et al. (2018) studied entropy regularized UOT with various divergences penalizing marginal violations. Optimization problems similar to equation 2.2 have also been considered outside of the ML literature (Piccoli & Rossi, 2014; Liero et al., 2018). We are unaware of prior applications of UOT to outlier-robustness, but it was studied in the concurrent work of Balaji et al. (2020). Another relevant variation of OT is partial OT (Figalli, 2010; Caffarelli & McCann, 2010). It may also be considered for outlier-robustness, but it has a drawback of forcing mass destruction rather than adjusting marginals to ignore outliers when they are present. A concurrent work by Staerman et al. (2020) took a different path: they replaced the expectation in the Wasserstein-1 dual with a median-of-means to promote robustness. It is unclear what is the corresponding primal, making it hard to interpret as an optimal transport problem.
+
+A major challenge with the aforementioned methods, including our Formulation 1, is the difficulty of the optimization problem. This is especially the case for MKEs, where a transport problem has to be solved in every iteration to obtain the gradient of the model parameters. Chizat et al. (2018) proposed a Sinkhorn-like algorithm for entropy regularized UOT, but it is not amenable to stochastic optimization. Balaji et al. (2020) proposed a stochastic optimization algorithm based on the UOT dual, but it requires two additional neural networks (total of four including dual potentials) to parameterize modified marginal distributions (i.e., $\mu + s$ and analogous one for $\nu$ ). Optimizing with a median-of-means in the objective function as in (Staerman et al., 2020) is also challenging. The key contribution of our work is a formulation equivalent to equation 2.2, which is easily compatible with the large body of classical OT optimization techniques (Cuturi, 2013; Solomon et al., 2015; Genevay et al., 2016; Seguy et al., 2018).
+
+More efficient equivalent formulation At a first glance, there are two issues with equation 2.2: it appears asymmetric and it is unclear if it can be optimized efficiently. Below we present an equivalent formulation that is free of these issues:
+
+# Formulation 2:
+
+$$
+\mathrm { R O B O T } ( \mu , \nu ) = \left\{ \begin{array} { l l } { \operatorname* { m i n } _ { \Pi \in \mathcal { F } ^ { + } ( \mathbb { R } ^ { d } \times \mathbb { R } ^ { d } ) } } & { \displaystyle \int C _ { \lambda } ( x , y ) \Pi ( \mathrm { d } x , \mathrm { d } y ) } \\ { \mathrm { s u b j e c t ~ t o } } & { \displaystyle \int _ { B \times \mathbb { R } ^ { d } } \Pi ( \mathrm { d } x , \mathrm { d } y ) = \int _ { B } \mu ( \mathrm { d } x ) \vee B \in \mathcal { B } ( \mathbb { R } ^ { d } ) } \\ & { \displaystyle \int _ { \mathbb { R } ^ { d } \times C } \Pi ( \mathrm { d } x , \mathrm { d } y ) = \int _ { C } \nu ( \mathrm { d } y ) \ \forall C \in \mathcal { B } ( \mathbb { R } ^ { d } ) , } \end{array} \right.
+$$
+
+where $C _ { \lambda }$ is the truncated cost function defined as $C _ { \lambda } ( x , y ) = C ( x , y ) \wedge 2 \lambda$ . Looking at equation 2.4, it is not apparent that it adds robustness to MKE, but it is symmetric, easy to combine with entropic regularization by simply truncating the cost, and benefits from stochastic optimization algorithms (Genevay et al., 2016; Seguy et al., 2018). This formulation also has a distant relation to the idea of loss truncation for achieving robustness (Shen & Sanghavi, 2019). Pele & Werman (2009) considered the Earth Mover Distance (discrete OT) with truncated cost to achieve computational improvements; they also mentioned its potential to promote robustness against outlier noise but did not explore this direction.
+
+In Section 3, we establish equivalence between the two ROBOT formulations, equation 2.2 and equation 2.4. This equivalence allows us to obtain an efficient algorithm based on equation 2.4 for robust MKE. We also provide a simple procedure for computing optimal $s$ in equation 2.2 from the solution of equation 2.4, enabling a new OT application: outlier detection. We verify the effectiveness of robust MKE and outlier detection in our experiments in Section 4. Before presenting the equivalence proof, we formulate the discrete analogs of the two ROBOT formulations for their practical value.
+
+# 2.2 DISCRETE ROBOT FORMULATIONS
+
+In practice we typically encounter samples from the distributions, rather then the distributions themselves. Sampling is also built into stochastic optimization. In this subsection, we present the discrete versions of the ROBOT formulations. The key detail is that, in equation 2.2, $\mu , \nu$ and $s$ are all supported on $\mathbb { R } ^ { d }$ , while in the discrete case the empirical measures $\mu _ { n } \in \Delta ^ { n - 1 }$ and $\nu _ { m } \in \Delta ^ { m \bar { - } 1 }$ are supported on a set of points ( $\Delta ^ { r }$ is the unit probability simplex in $\mathbb { R } ^ { r }$ ). As a result, to formulate a discrete version of equation 2.2, we need to augment $\mu _ { n }$ and $\nu _ { m }$ with each others’ supports. To be precise, let $\mathrm { s u p } \bar { \mathrm { p } } ( \mu _ { n } ) = \{ X _ { 1 } , \ldots , X _ { n } \}$ and $\operatorname { s u p p } ( \nu _ { m } ) = \{ Y _ { 1 } , . . . , Y _ { m } \}$ . Define $\mathcal { C } = \{ Z _ { 1 } , Z _ { 2 } , \ldots , Z _ { m + n } \} = \{ X _ { 1 } , \ldots , X _ { n } , Y _ { 1 } , \ldots , Y _ { m } \}$ . Then discrete analog of equation 2.2 is
+
+# Formulation 1 (discrete):
+
+$$
+\begin{array} { r } { \mathbf { R O B O T } ( \mu _ { n } , \nu _ { m } ) = \left\{ \begin{array} { l l } { \operatorname* { m i n } _ { \Pi \in \mathbb { R } ^ { ( m + n ) \times ( m + n ) } } } & { \langle C _ { a u g } , \Pi \rangle + \lambda [ \| s _ { 1 } \| _ { 1 } + \| t _ { 1 } \| _ { 1 } ] } \\ { \mathrm { s t R } \mathrm { ~ e x t e } ^ { m + n } } & \\ { \mathrm { s u b j e c t ~ t o } } & { \Pi \mathrm { l } _ { m + n } = \left[ \begin{array} { l } { \mu _ { n } + s _ { 1 } } \\ { t _ { 1 } } \end{array} \right] , } & { \Pi ^ { \top } \mathrm { 1 } _ { m + n } = \left[ \begin{array} { l } { 0 } \\ { \nu _ { m } } \end{array} \right] } \\ & { \Pi \succeq 0 , ~ 1 _ { m + n } ^ { \top } \mathrm { s } = 0 , } \end{array} \right. } \end{array}
+$$
+
+where $C _ { a u g } \in \mathbb { R } ^ { ( m + n ) \times ( m + n ) }$ is the augmented cost function $C _ { a u g , i , j } = c ( Z _ { i } , Z _ { j } )$ ( $c$ is the ground cost, e.g., squared Euclidean distance), $\mathbf { s } = ( s _ { 1 } , t _ { 1 } )$ and $1 _ { r }$ is the vector all ones in $\mathbb { R } ^ { r }$ . The TV norm got replaced with its discrete analog, the $L _ { 1 }$ norm. Similarly to its continuous counterpart, the optimization problem is harder than the typical OT due to additional constraint optimization variable s and increased cost matrix size.
+
+The discrete analog of equation 2.4 is straightforward:
+
+# Formulation 2 (discrete):
+
+$$
+\mathrm { R O B O T } ( \mu _ { n } , \nu _ { m } ) = \left\{ \begin{array} { l l } { \operatorname* { m i n } _ { \Pi \in \mathbb { R } ^ { n \times m } } } & { \langle C _ { \lambda } , \Pi \rangle } \\ { \mathrm { s u b j e c t ~ t o } } & { \Pi 1 _ { n } = \mu _ { n } , \Pi ^ { \top } 1 _ { m } = \nu _ { m } , \Pi \succeq 0 , } \end{array} \right.
+$$
+
+where $C _ { \lambda , i , j } = c ( X _ { i } , Y _ { j } ) { \wedge } 2 { \lambda }$ . As in the continuous case, it is easy to adapt modern (regularized) OT solvers without any computational overhead. As in the continuous case, formulations of equation 2.5 and equation 2.6 are equivalent. It is also possible to recover s of equation 2.5 from the solution of equation 2.6 to perform outlier detection.
+
+Two-sided formulation So far we have assumed that one of the input distributions does not have outliers, which is the setting of MKE, where the clean distribution corresponds to the model we learn. In some applications, both distributions may be corrupted. To address this case, we provide an equivalent two-sided formulation, analogous to UOT with TV norm:
+
+# Formulation 3 (two-sided):
+
+$$
+\begin{array} { r } { \small \mathrm { 3 O B O T } ( \mu _ { n } , \nu _ { m } ) = \left\{ \begin{array} { l l } { \operatorname* { m i n } _ { \mathrm { \Pi } \in \mathbb { R } ^ { ( m + n ) \times ( m + n ) } } } & { \langle C _ { a u g } , \Pi \rangle + \lambda [ \| s _ { 1 } \| _ { 1 } + \| t _ { 1 } \| _ { 1 } + \| s _ { 2 } \| _ { 1 } + \| t _ { 2 } \| _ { 1 } ] } \\ { \mathrm { s } _ { 1 } \in \mathbb { R } ^ { m + n } , \mathrm { s } _ { 2 } \in \mathbb { R } ^ { m + n } } \\ { \mathrm { s u b j e c t ~ t o } } & { \Pi \mathrm { 1 } _ { m + n } = \left[ { \mu _ { n } + s _ { 1 } } \right] , \quad \Pi ^ { \top } \mathrm { 1 } _ { m + n } = \left[ { \nu _ { m } + t _ { 2 } } \right] } \\ & { \Pi \succeq 0 , \quad \Pi _ { m + n } ^ { \top } \mathrm { s } _ { 1 } = 0 , \quad \lambda _ { m + n } ^ { \top } \mathrm { s } _ { 2 } = 0 . } \end{array} \right. } \end{array}
+$$
+
+where $\mathbf { s } _ { 1 } = ( s _ { 1 } ^ { \top } , t _ { 1 } ^ { \top } ) ^ { \top }$ and $\mathbf { s } _ { 2 } = ( s _ { 2 } ^ { \top } , t _ { 2 } ^ { \top } ) ^ { \top }$ .
+
+# 3 EQUIVALENCE OF THE ROBOT FORMULATIONS
+
+In this section we present our main theorem, which demonstrates the equivalence between two formulations of the robust optimal transport:
+
+Theorem 3.1. For any two measures $\mu$ and $\nu$ , $R O B O T ( \mu , \nu )$ has same value for both the formulations, i.e., Formulation 1 is equivalent to Formulation 2 both for continuous and discrete case. Moreover, we can recover optimal coupling of one formulation from the other.
+
+Below we sketch the proof of this theorem and highlight some important techniques used in the proof. We focus on the discrete case as it is more intuitive and has concrete practical implications in our experiments. A complete proof can be found in Appendix A. Please also see Appendix A.2 for the proof of equivalence between Formulations 1, 2 and 3 in the discrete case.
+
+# 3.1 PROOF SKETCH
+
+In the remainder of this section we consider the discrete case, i.e., equation 2.5 for Formulation 1 (F1) and equation 2.6 for Formulation 2 (F2). Suppose $\Pi _ { 2 } ^ { * }$ is an optimal solution of F2. Then we construct a feasible solution $\Pi _ { 1 } ^ { * }$ , $\mathbf { s } _ { 1 } ^ { * } = ( s _ { 1 } ^ { * } , t _ { 1 } ^ { * } )$ of F1 based on $\Pi _ { 2 } ^ { * }$ with the same value of the objective function as F2 and claim that $( \Pi _ { 1 } ^ { * } , \mathbf { s } _ { 1 } ^ { * } )$ is an optimal solution. We prove the claim by contradiction: if $( \Pi _ { 1 } ^ { * } , \mathbf { s } _ { 1 } ^ { * } )$ is not optimal, then there exists another pair $( \tilde { \Pi } _ { 1 } , \tilde { \bf s } _ { 1 } )$ which is optimal for F1 with strictly 1 1less objective value. We then construct another feasible solution $\Pi _ { 2 , n e w } ^ { * }$ of Formulation 2 which has the same objective value as of $( \tilde { \Pi } _ { 1 } , \tilde { \bf s } _ { 1 } )$ for F1. This implies $\Pi _ { 2 , n e w } ^ { * }$ has strictly less objective value for F2 than $\Pi _ { 2 } ^ { * }$ , which is a contradiction.
+
+The two main pillars of this proof are (1) to construct a feasible solution of F1 starting from a feasible solution of F2 and (2) to show that the solution constructed is indeed optimal for F1. Hence step (1) gives a recipe to construct an optimal solution of F1 starting from an optimal solution of F2. We elaborate the first point in the next subsection, which has practical implications for outlier detection. The other point is more technical; interested readers may go through the proof in Appendix A.1.
+
+# Algorithm 1 Generating optimal solution of F1 from F2
+
+1: Start with $\Pi _ { 2 } ^ { * } \in \mathbb { R } ^ { n \times m }$ , an optimal solution of Formulation 2.   
+2: Create an augmented matrix $\mathbf { \bar { I } } \mathbf { I } \in \mathbb { R } ^ { m + n \times m + n }$ with all 0. Divide $\Pi$ into four blocks:
+
+$$
+\Pi = \left[ \underbrace { \Pi _ { 1 1 } } _ { n \times n } \underbrace { \Pi _ { 1 2 } } _ { n \times m } \right]
+$$
+
+3: Set $\Pi _ { 1 2 }  \Pi _ { 2 } ^ { * }$ and collect all the indices $\mathcal { T } = \{ ( i , j ) : C _ { i , j } > 2 \lambda \}$ .   
+4: Set $\Pi _ { 1 2 } ( i , j )  0$ for $( i , j ) \in \mathcal { T }$ .   
+5: Set $\begin{array} { r } { \Pi _ { 2 2 } ( j , j )  \sum _ { i = 1 } ^ { n } \Pi _ { 2 } ^ { * } ( i , j ) \mathtt { 1 } _ { ( i , j ) \in \mathcal { I } } } \end{array}$ for all $1 \leq j \leq m$ and set $\Pi _ { 1 } ^ { * }  \Pi$ .   
+6: Set $\begin{array} { r } { s _ { 1 } ^ { * } ( i ) \leq \sum _ { j = 1 } ^ { m } \Pi _ { 2 } ^ { * } ( i , j ) \mathbb { 1 } _ { ( i , j ) \in \mathcal { I } } } \end{array}$ for all $1 \leq i \leq n$ .   
+7: Set $t _ { 1 } ^ { * } ( j ) = \Pi _ { 2 2 } ( j , j )$ for all $1 \leq j \leq m$ .   
+8: return $\Pi _ { 1 } ^ { * } , s _ { 1 } ^ { * } , t _ { 1 } ^ { * }$ .
+
+# 3.2 GOING FROM FORMULATION 2 TO FORMULATION 1
+
+Let $\Pi _ { 2 } ^ { * }$ (respectively $\Pi _ { 1 } ^ { * }$ ) be an optimal solution of F2 (respectively F1). Recall that $\Pi _ { 1 } ^ { * }$ has dimension $( m + n ) \times ( m + n )$ . From the column sum constraint in F1, we need to take the first $n$ columns of $\Pi _ { 1 } ^ { * }$ to be exactly 0, whereas the last $m$ columns must sum up to $\nu _ { m }$ . For any matrix $A$ , we denote by $\mathbf { \bar { \xi } } A [ ( a : b ) \times ( c : d ) ]$ the submatrix consisting of rows from $a$ to $b$ and columns from $c$ to $d$ . Our main idea is to put a modified version of $\Pi _ { 2 } ^ { * }$ in $\bar { \Pi } _ { 1 } ^ { * } [ ( 1 : n ) \times ( n + 1 : m + n ) ]$ and make $\Pi _ { 1 } ^ { * } [ ( n + 1 : m + n ) \times ( n + 1 : m + n ) ]$ diagonal. First we describe how to modify $\Pi _ { 2 } ^ { * }$ . Observe that, if for some $\left( i , j \right) C _ { i , j } > 2 \lambda$ , we expect $X _ { i } \in \mathrm { s u p p } ( \mu _ { n } )$ to be an outlier resulting in high transportation cost, which is why we truncate the cost in F2. Therefore, to get an optimal solution of F1, we make the corresponding value of optimal plan 0 and dump the mass into the corresponding slack variable $t _ { 1 } ^ { * }$ in the diagonal of the bottom right submatrix. This changes the row sum, which is taken care of by $s _ { 1 } ^ { * }$ . But, as we are not moving this mass outside the corresponding column, the column sum of $\bar { \Pi } _ { 1 } ^ { * } [ ( \bar { 1 } : ( m + n ) ) : ( ( n + 1 ) : \bar { ( m + n ) } ) ]$ remains same as column sum of $\Pi _ { 2 } ^ { * }$ , which is $\nu _ { n }$ . We summarize this procedure in Algorithm 1.
+
+![](images/c63186a4c907aef0f031f3b9da4ca9b1bb1c94a15e2c5ec83f796a52810ed728.jpg)  
+Figure 1: Constructing optimal solution of Formulation 1 from optimal solution of Formulation 2.
+
+Example. In Figure 1, we provide an example to visualize the construction. On the left, we have $\Pi _ { 2 } ^ { * }$ , an optimal solution of Formulation 2. The blue triangles denote the positions where the corresponding cost value is $\leq 2 \lambda$ , and light-green squares denote the positions where the corresponding value of the cost matrix is $> 2 \lambda$ . To construct an optimal solution $\Pi _ { 1 } ^ { * }$ of Formulation 1 from this $\Pi _ { 2 } ^ { * }$ , we first create an augmented matrix of size $6 \times 6$ . We keep all the entries of of left $6 \times 3$ sub-matrix as 0 (in this picture blank elements indicate 0). On the right submatrix, we put $\Pi _ { 2 } ^ { * }$ into the top-right block, but remove the masses from light-green squares, i.e. where cost value is $> 2 \lambda$ , and put it in the diagonal entries of the bottom right block as shown in Figure 1. This mass contributes to the slack variables $s _ { 1 }$ and $t _ { 1 }$ , and this augmented matrix along with $s _ { 1 } , t _ { 1 }$ give us an optimal solution of Formulation 1.
+
+# 3.3 OUTLIER DETECTION WITH ROBOT
+
+Our construction algorithm has practical consequences for outlier detection. Suppose we have two datasets, a clean dataset $\nu _ { m }$ (i.e., has no outliers) and an outlier-contaminated dataset $\mu _ { n }$ . We can detect the outliers in $\mu _ { n }$ without directly solving costly Formulation 1 by following Algorithm 2. In this algorithm, $\lambda$ is a regularization parameter that can be chosen via cross-validation or heuristically (see Section 4.2 for an example). In Section 4.2, we use this algorithm to perform outlier detection on image data.
+
+# Algorithm 2 Outlier detection in contaminated data
+
+<table><tr><td>Algorithm2 Outlierdetectionincontaminateddata</td></tr><tr><td>1: Start with μn (contaminted data) and Vm (clean data).</td></tr><tr><td>2:Solve Formulation 2 and obtain II* using a suitable value of 入.</td></tr><tr><td>3: Use Algorithm 1 to obtain II*,s*,t* from II*.</td></tr><tr><td>4: Find I,the set of all the indices where μn + s* = 0.</td></tr><tr><td> 5: Return I as the indices of outliers in μn·</td></tr></table>
+
+Table 1: Robust mean estimation with GANs using different distribution divergences. True mean is $\eta _ { 0 } = \mathbf { 0 } _ { 5 }$ ; sample size $n = 1 0 0 0$ ; contamination proportion $\epsilon = 0 . 2$ . We report results over 30 experiment restarts.   
+
+<table><tr><td>Contamination</td><td> JS Loss</td><td>SH Loss</td><td>RKL Loss</td><td>ROBOT</td><td>UOT</td></tr><tr><td>N(0.1·15, I5)</td><td>0.09 ± 0.03</td><td>0.11 ± 0.03</td><td>0.115±0.03</td><td>0.1 ± 0.03</td><td>0.1 ± 0.04</td></tr><tr><td>N(0.5·15,I5)</td><td>0.23 ± 0.04</td><td>0.24 ± 0.05</td><td>0.24 ± 0.05</td><td>0.117±0.03</td><td>0.2 ± 0.04</td></tr><tr><td>N(1·15,I5)</td><td>0.43 ± 0.05</td><td>0.43 ± 0.06</td><td>0.43±0.06</td><td>0.261±0.06</td><td>0.25 ± 0.05</td></tr><tr><td>N(2·15,15)</td><td>0.67 ± 0.07</td><td>0.67 ± 0.08</td><td>0.67 ± 0.08</td><td>0.106 ± 0.03</td><td>0.1 ± 0.03</td></tr></table>
+
+![](images/26b94f3699d1eb10d32fe9f34ceece19a417b4f2e5c261479ed85d987c42dc22.jpg)  
+Figure 2: Empirical study of regularization hyperparameter $\lambda$ sensitivity
+
+# 4 EMPIRICAL STUDIES
+
+To evaluate effectiveness of ROBOT, we consider the task of robust mean estimation under the Huber contamination model. The data is generated from $( 1 - \epsilon ) \mathcal { N } ( \eta _ { 0 } , I _ { d } ) + \epsilon \mathcal { N } ( \eta _ { 1 } , I _ { d } )$ and the goal is to estimate $\eta _ { 0 }$ . Prior work has advocated for using $f$ -divergence GANs (Chao et al., 2018; Wu et al., 2020) for this problem and pointed out inefficiencies of Wasserstein GAN in the presence of outliers. We show that our robust OT formulation allows us to estimate the uncontaminated mean $\eta _ { 0 }$ comparably or better than a variety of $f$ -divergence GANs. We also use this simulated setup to study sensitivity to the regularization hyperparameter $\lambda$ .
+
+In our second experiment, we present a new application of optimal transport enabled by ROBOT. Suppose we have collected a curated dataset $\nu _ { m }$ (i.e., we know that it has no outliers)—such data collection is expensive, and we want to benefit from it to automate subsequent data collection. Let $\mu _ { n }$ be a second dataset collected “in the wild,” i.e., it may or may not have outliers. We demonstrate how ROBOT can be used to identify outliers in $\mu _ { n }$ using the curated dataset $\nu _ { m }$ .
+
+# 4.1 ROBUST MEAN ESTIMATION
+
+Following Wu et al. (2020), we consider a simple generator of the form $g _ { \theta } ( x ) = x + \theta ,$ $x \sim$ $\mathcal { N } ( 0 , I _ { d } )$ , $d$ is the data dimension. The basic idea of robust mean estimation with GANs is to minimize various distributional divergences between samples from $g _ { \theta }$ and observed data simulated from $( 1 - \epsilon ) \mathcal { N } ( \eta _ { 0 } , I _ { d } ) + \epsilon \mathcal { N } ( \eta _ { 1 } , I _ { d } )$ . The goal is to estimate $\eta _ { 0 }$ with $\theta$ . To efficiently implement ROBOT GAN, we use a standard min-max optimization approach: solve the inner max (ROBOT) and use gradient descent for the outer min parameter. To solve ROBOT, it is straightforward to adopt any of the prior stochastic regularized OT solvers: the only modification is the truncation of the cost entries as in equation 2.6. We use the stochastic algorithm for semi-discrete regularized OT from (Genevay et al., 2016, Algorithm 2). We summarize ROBOT GAN in Algorithm 3. Line 5 - Line 10 perform the inner optimization where we solve entropy regularized OT dual with truncated cost and Line 11 - Line 12 perform gradient update of $\theta$ .
+
+# Algorithm 3 ROBOT GAN
+
+1: Input: robustness regularizion $\lambda$ , entropic regularization $\alpha$ , data distribution $\mu _ { n } \in \Delta ^ { n - 1 }$ ,   
+$s u p p ( \mu _ { n } ) = \mathcal { X } = [ X _ { 1 } , \ldots , X _ { n } ]$ , steps sizes $\tau$ and $\gamma$   
+2: Initialize: Initialize $\theta = \theta _ { i n i t }$ , set number of iterations $M$ and $L$ , $i = 0$ , ${ \bf v } = \tilde { \bf v } = { \bf 0 }$ .   
+3: for $j = 1 , \dots , M$ do   
+4: Generate $\tilde { z } \sim \mathcal { N } ( 0 , I _ { d } )$ and set $z = \tilde { z } + \theta$ .   
+5: Set the cost vector $\mathbf { c } \in \mathbb { R } ^ { n }$ as $\mathbf { c } ( k ) = c ( X _ { k } , z ) \wedge 2 \lambda$ for $k = 1 , \dots , n$ .   
+6: for $i = 1 , \ldots , L$ do $\triangleright$ solve entropy regularized OT dual   
+7: Set $\mathbf { h }  { \frac { \tilde { \mathbf { v } } - \mathbf { c } } { \alpha } }$ and do the normalized exponential transformation $\mathbf { \bar { u } } \gets \frac { e ^ { \mathbf { h } } } { \langle \mathbf { 1 } , e ^ { \mathbf { h } } \rangle }$ .   
+8: Calculate the gradient $\nabla \tilde { \mathbf { v } }  \mu _ { n } - \mathbf { u }$ .   
+9: Update $\tilde { \mathbf { v } }  \tilde { \mathbf { v } } + \gamma \nabla \tilde { \mathbf { v } }$ and $\mathbf { v }  ( 1 / ( j + i ) ) \tilde { \mathbf { v } } + ( j + i - 1 / ( j + i ) ) \mathbf { v } .$ .   
+10: Do the same transformation of $\mathbf { v }$ as in Step 7, i.e. set $\mathbf { h }  { \frac { \mathbf { v } - \mathbf { c } } { \alpha } }$ and set $\begin{array} { r } { \bar { \Pi }  \frac { e ^ { \mathbf { h } } } { \langle \mathbf { 1 } , e ^ { \mathbf { h } } \rangle } } \end{array}$ .   
+11: Set $\Pi ( k ) = 0$ for $k$ such that $C ( X _ { k } , z ) > 2 \lambda$ for $k = 1 , \dots , n$ .   
+12: Calculate gradient with respect to $\theta$ as $\begin{array} { r } { \nabla \theta = 2 \left[ z \sum _ { k } \Pi ( k ) - \mathcal { X } ^ { \top } \Pi \right] } \end{array}$   
+13: Update $\theta  \theta - \tau \nabla \theta$ .
+
+14: Ouput: $\theta$
+
+For the $f$ -divergence GANs (Nowozin et al., 2016) we use the code of Wu et al. (2020) for GANs with Jensen-Shannon (JS) loss, squared Hellinger (SH) loss and Reverse Kullback-Leibler (RKL) loss. For the exact expression of these divergences see Table 1 of $\mathbf { W } \mathbf { u }$ et al. (2020). We report estimation error measured by the Euclidean distance between true uncontaminated mean $\eta _ { 0 }$ and estimated mean $\theta$ for various contamination distributions in Table 1. ROBOT GAN performs well across all considered contamination distributions. As the difference between true mean $\eta _ { 0 }$ and contamination mean $\eta _ { 1 }$ increases, the estimation error of all methods tends to increase. However, when it becomes easier to distinguish outliers from clean samples, i.e., $\eta _ { 1 } = 2 \cdot { \bf 1 _ { 5 } }$ , performance of ROBOT noticeably improves.
+
+We also compared to the Sinkhorn-based UOT algorithm (Chizat et al., 2018) available in the Python Optimal Transport (POT) library (Flamary & Courty, 2017); to obtain a UOT GAN, we modified steps 5-11 of Algorithm 3 for computing Π. Unsurprisingly, both ROBOT and UOT perform similarly: recall equivalence to Formulation 3, which is similar to UOT with TV norm. The key insight of our work is the equivalence to classical OT with truncated cost, that greatly simplifies optimization and allows to use existing stochastic OT algorithms. In this experiment, the sample size $n = 1 0 0 0$ is sufficiently small for the Sinkhorn-based UOT POT implementation to be effective, but it breaks in the experiment we present in Section 4.2. We also tried the code of Balaji et al. (2020) based on CVXPY (Diamond & Boyd, 2016), but it is too slow even for the $n = 1 0 0 0$ sample size.
+
+In the previous experiment, we set $\lambda = 0 . 5$ . Now we demonstrate empirically that there is a broad range of $\lambda$ values performing well. In Figure 2a, we study sensitivity of $\lambda$ under various contamination proportions $\epsilon$ holding $\eta _ { 0 } = \mathbf { 1 } _ { 5 }$ and $\eta _ { 1 } = 5 \cdot { \bf 1 } _ { 5 }$ fixed. Horizontal lines correspond to $\lambda = \infty$ , i.e., vanilla OT. The key observations are: there is a wide range of $\lambda$ efficient at all contamination proportions, and ROBOT is always at least as good as vanilla OT (even when there is no contamination $\epsilon = 0$ ). In Figure 2b, we present a similar study varying the mean of the contamination distribution and holding $\epsilon = 0 . 2$ fixed. We see that as the contamination distribution gets closer to the true distribution, it becomes harder to pick a good $\lambda$ , but the performance is always at least as good as the vanilla OT (horizontal lines).
+
+# 4.2 OUTLIER DETECTION FOR DATA COLLECTION
+
+Our robust OT formulation equation 2.5 enables outlier identification. Let $\nu _ { m }$ be a clean dataset and $\mu _ { n }$ potentially contaminated with outliers. Recall that ROBOT allows modification of one of the input distributions to eliminate potential outliers. We can identify outliers in $\mu _ { n }$ as follows: if $\mu _ { n } ( i ) \mathbf { \bar { + } } s _ { 1 } ^ { * } ( i ) = 0$ , then $X _ { i }$ , the $i$ th point in $\mu _ { n }$ , is an outlier. Instead of directly solving equation 2.5, which may be inefficient, we use our equivalence results and solve an easier optimization problem equation 2.6, followed by recovering s to find outliers via Algorithm 2.
+
+![](images/d2f240dabc86fe45b9a765fa087cbe4853c08a2ee161d10c811ab2f710a11a5a.jpg)  
+Figure 3: Random sample of outliers detected by ROBOT from a dataset of MNIST digits contaminated with Fashion MNIST images.
+
+Let $\nu _ { m }$ be a clean dataset consisting of 10k MNIST digits and $\mu _ { n }$ be a dataset collected “in the wild” consisting of (different) 8k MNIST digits and 2k Fashion MNIST images. We compute $\mathrm { R O B O T } ( \mu _ { n } , \nu _ { m } )$ to identify outlier Fashion MNIST images in $\mu _ { n }$ . For each point in $\mu _ { n }$ we obtain a prediction, outlier or clean, which allows us to evaluate accuracy. ROBOT outlier detection is $90 \%$ accurate in this experiment. We also comment on $\lambda$ selection: since we know that $\nu _ { m }$ is clean, we can subsample two datasets from it, compute vanilla OT to obtain transportation plan $\Pi$ and set $\lambda$ to be half the maximum distance between matched elements, i.e. $2 \lambda = \mathrm { \bar { m a x } } _ { i , j } \{ C _ { i j } ^ { - } : \Pi _ { i j } > 0 \}$ , where $C$ is the cost matrix for the two subsampled datasets. This procedure is essentially estimating maximum distance between matched clean samples. We also present a random sample of outliers identified by our method in Figure 3. All of the sampled outliers are Fashion MNIST images, although $90 \%$ accuracy suggests that some of the outliers were not identified. Decreasing $\lambda$ can help to find more outliers, but may result in some clean samples being mistaken for outliers. We conclude that ROBOT can be used to assist in data collection once an initial set of clean data has been acquired. As we mentioned previously, the Sinkhorn-based UOT POT implementation is too expensive for this experiment due to larger sample size, yielding memory errors on a personal laptop with 16GB RAM.
+
+For comparison, we also consider a heuristic distance-based approach for identifying outliers. We estimate diameter $\tau$ of the set of clean dataset $\nu _ { m }$ by taking the 99th percentile of the pairwise distance matrix of samples in $\nu _ { m }$ . If outliers and clean data have disjoint support, we can adopt a simple heuristic: for each sample in the potentially contaminated $\mu _ { n }$ compute an average distance to the clean samples in $\nu _ { m }$ and declare a sample as an outlier if this average distance is greater than the diameter $\tau$ of the clean data. The accuracy of this procedure is $8 5 . 4 \%$ , inferior to the ROBOT accuracy of $90 \%$ . The disjoint support assumption justifying the distance-based heuristic might be too strong in practice. ROBOT continues to be effective even when the supports of clean and outlier distributions are not easily separable.
+
+# 5 SUMMARY AND DISCUSSION
+
+We proposed and studied ROBOT, a robust formulation of optimal transport. We showed that although the problem is seemingly asymmetric and challenging to optimize, there is an equivalent formulation based on cost truncation that is symmetric and compatible with modern stochastic optimization methods for OT.
+
+ROBOT closely resembles unbalanced optimal transport (UOT). In our formulation, we added a TV regularizer to the vanilla optimal transport problem. This is motivated by the $\epsilon$ -contamination model. In UOT, the TV regularizer is typically replaced with a KL divergence. Other choices of the regularizer may lead to new properties and applications. Studying equivalent, simpler formulations of UOT with different divergences may be a fruitful future work direction.
+
+From the practical perspective, in our experiments we observed no degradation of ROBOT GAN in comparison to OT GAN, even when there were no outliers. It is possible that replacing OT with ROBOT may be beneficial for various machine learning applications of OT. Data encountered in practice may not be explicitly contaminated with outliers, but it often has errors and other deficiencies, suggesting that a “no-harm” robustness is desirable.
+
+# REFERENCES
+
+David Alvarez-Melis and Tommi S Jaakkola. Gromov-Wasserstein alignment of word embedding spaces. arXiv:1809.00013, 2018.
+
+Martin Arjovsky, Soumith Chintala, and Leon Bottou. Wasserstein GAN. ´ arXiv:1701.07875 [cs, stat], January 2017.
+
+Yogesh Balaji, Rama Chellappa, and Soheil Feizi. Robust optimal transport with applications in generative modeling and domain adaptation. Advances in Neural Information Processing Systems, 33, 2020.
+
+Federico Bassetti, Antonella Bodini, and Eugenio Regazzini. On minimum Kantorovich distance estimators. Statistics & Probability Letters, 76(12):1298–1302, 2006.
+
+Luis A Caffarelli and Robert J McCann. Free boundaries in optimal transport and Monge-Ampere obstacle problems. Annals of Mathematics, pp. 673–730, 2010.
+
+Gao Chao, Yao Yuan, and Zhu Weizhi. Robust estimation via generative adversarial networks. In International Conference on Learning Representations, 2018.
+
+Lenaic Chizat, Gabriel Peyre, Bernhard Schmitzer, and Franc¸ois-Xavier Vialard. Scaling algorithms ´ for unbalanced optimal transport problems. Mathematics of Computation, 87(314):2563–2609, 2018.
+
+Lena¨ıc Chizat. Unbalanced optimal transport: Models, numerical methods, applications. Numerical Analysis [math.NA]. Universite Paris sciences et lettres ´ , 2017.
+
+Nicolas Courty, Remi Flamary, and Devis Tuia. Domain adaptation with regularized optimal´ transport. In Joint European Conference on Machine Learning and Knowledge Discovery in Databases, pp. 274–289. Springer, 2014.
+
+Nicolas Courty, Remi Flamary, Amaury Habrard, and Alain Rakotomamonjy. Joint distribution ´ optimal transportation for domain adaptation. In Advances in Neural Information Processing Systems, pp. 3730–3739, 2017.
+
+Marco Cuturi. Sinkhorn Distances: Lightspeed Computation of Optimal Transport. In C. J. C. Burges, L. Bottou, M. Welling, Z. Ghahramani, and K. Q. Weinberger (eds.), Advances in Neural Information Processing Systems 26, pp. 2292–2300. Curran Associates, Inc., 2013.
+
+Steven Diamond and Stephen Boyd. CVXPY: A Python-embedded modeling language for convex optimization. Journal of Machine Learning Research, 17(83):1–5, 2016.
+
+Alessio Figalli. The optimal partial transport problem. Archive for Rational Mechanics and Analysis, 195(2):533–560, 2010.
+
+Remi Flamary and Nicolas Courty. POT Python optimal transport library, 2017. URL ´ https: //pythonot.github.io/.
+
+Aude Genevay, Marco Cuturi, Gabriel Peyre, and Francis Bach. Stochastic optimization for large- ´ scale optimal transport. In Advances in Neural Information Processing Systems, pp. 3440–3448, 2016.
+
+Nhat Ho, XuanLong Nguyen, Mikhail Yurochkin, Hung Hai Bui, Viet Huynh, and Dinh Phung. Multilevel clustering via Wasserstein means. In International Conference on Machine Learning, pp. 1501–1509, 2017.
+
+Gao Huang, Chuan Guo, Matt J Kusner, Yu Sun, Fei Sha, and Kilian Q Weinberger. Supervised word mover’s distance. In Advances in Neural Information Processing Systems, pp. 4862–4870, 2016.
+
+Peter J. Huber and Elvezio Ronchetti. Robust Statistics. Wiley Series in Probability and Statistics. Wiley, Hoboken, N.J, 2nd ed edition, 2009. ISBN 978-0-470-12990-6.
+
+Leonid Vitalievich Kantorovich. On the translocation of masses. In Dokl. Akad. Nauk. USSR (NS), volume 37, pp. 199–201, 1942.
+
+Matt Kusner, Yu Sun, Nicholas Kolkin, and Kilian Weinberger. From Word Embeddings To Document Distances. In International Conference on Machine Learning, pp. 957–966, June 2015.
+
+Matthias Liero, Alexander Mielke, and Giuseppe Savare. Optimal entropy-transport problems and a ´ new Hellinger–Kantorovich distance between positive measures. Inventiones Mathematicae, 211 (3):969–1117, 2018.
+
+Gaspard Monge. Memoire sur la th ´ eorie des d ´ eblais et des remblais ´ . De l’Imprimerie Royale, 1781.
+
+Sebastian Nowozin, Botond Cseke, and Ryota Tomioka. f-GAN: Training generative neural samplers using variational divergence minimization. In Advances in Neural Information Processing Systems, pp. 271–279, 2016.
+
+Ofir Pele and Michael Werman. Fast and robust earth mover’s distances. In 2009 IEEE 12th International Conference on Computer Vision, pp. 460–467. IEEE, 2009.
+
+Gabriel Peyre and Marco Cuturi. Computational Optimal Transport. ´ arXiv:1803.00567 [stat], March 2018.
+
+Benedetto Piccoli and Francesco Rossi. Generalized Wasserstein distance and its application to transport equations with source. Archive for Rational Mechanics and Analysis, 211(1):335–358, 2014.
+
+Vivien Seguy, Bharath Bhushan Damodaran, Remi Flamary, Nicolas Courty, Antoine Rolet, and ´ Mathieu Blondel. Large-Scale Optimal Transport and Mapping Estimation. arXiv:1711.02283 [stat], February 2018.
+
+Yanyao Shen and Sujay Sanghavi. Learning with bad training data via iterative trimmed loss minimization. In International Conference on Machine Learning, pp. 5739–5748. PMLR, 2019.
+
+Justin Solomon, Fernando De Goes, Gabriel Peyre, Marco Cuturi, Adrian Butscher, Andy Nguyen, ´ Tao Du, and Leonidas Guibas. Convolutional Wasserstein distances: Efficient optimal transportation on geometric domains. ACM Transactions on Graphics (TOG), 34(4):1–11, 2015.
+
+Sanvesh Srivastava, Cheng Li, and David B. Dunson. Scalable Bayes via Barycenter in Wasserstein Space. arXiv:1508.05880 [stat], June 2018.
+
+Guillaume Staerman, Pierre Laforgue, Pavlo Mozharovskyi, and Florence d’Alche Buc. When OT´ meets MOM: Robust estimation of Wasserstein distance. arXiv:2006.10325, 2020.
+
+C. Villani. Optimal Transport: Old and New. Grundlehren der Mathematischen Wissenschaften [Fundamental Principles of Mathemtical Sciences]. Springer, Berlin, 2009.
+
+Kaiwen Wu, Gavin Weiguang Ding, Ruitong Huang, and Yaoliang Yu. On Minimax Optimality of GANs for Robust Mean Estimation. In International Conference on Artificial Intelligence and Statistics, pp. 4541–4551, June 2020.
+
+Mikhail Yurochkin, Sebastian Claici, Edward Chien, Farzaneh Mirzazadeh, and Justin Solomon. Hierarchical Optimal Transport for Document Representation. arXiv:1906.10827 [cs, stat], June 2019.
+
+# A PROOF OF THEOREM 3.1
+
+A.1 PROOF OF DISCRETE VERSION
+
+Proof. Define a matrix $\Pi$ as:
+
+$$
+\Pi ( i , j ) = { \left\{ \begin{array} { l l } { 0 , } & { { \mathrm { i f ~ } } C ( i , j ) > 2 \lambda } \\ { \Pi _ { 2 } ^ { * } ( i , j ) , } & { { \mathrm { o t h e r w i s e } } } \end{array} \right. }
+$$
+
+Also define $s \in \mathbb { R } ^ { n }$ and $t \in \mathbb { R } ^ { m }$ as:
+
+$$
+s _ { 1 } ^ { * } ( i ) = - \sum _ { j = 1 } ^ { m } \Pi _ { 2 } ^ { * } ( i , j ) \mathbb { 1 } _ { C ( i , j ) > 2 \lambda }
+$$
+
+and similarly define:
+
+$$
+t _ { 1 } ^ { * } ( j ) = \sum _ { i = 1 } ^ { n } \Pi _ { 2 } ^ { * } ( i , j ) \mathbb { 1 } _ { C ( i , j ) > 2 \lambda }
+$$
+
+These vectors corresponds to the row sums and the column sums of the elements of the optimal transport plan of Formulation 2, where the cost function exceeds $2 \lambda$ . Note that, these co-ordinates of the optimal transport plan corresponding to those co-ordinates of cost matrix, where the cost is greater than $2 \lambda$ and contribute to the objective value via their sum only, hence any different arrangement of these transition probabilities with same sum gives the same objective value.
+
+Now based on this $\Pi$ obtained we construct a feasible solution of Formulation 1 following Algorithm 1:
+
+$$
+\Pi _ { 1 } ^ { * } = \left[ \mathbf { 0 } \atop \mathbf { 0 } \quad \mathbf { d i a g } ( t _ { 1 } ^ { * } ) \right]
+$$
+
+The row sums of $\Pi _ { 1 } ^ { * }$ is:
+
+$$
+\Pi _ { 1 } ^ { * } \mathbf { 1 } = \left[ { \mu _ { n } + s _ { 1 } ^ { * } } \right]
+$$
+
+and it is immediate from the construction that the column sums of $\Pi _ { 1 } ^ { * }$ is $\nu _ { m }$ . Also as:
+
+$$
+\sum _ { i = 1 } ^ { n } s _ { 1 } ^ { * } ( i ) = \sum _ { j = 1 } ^ { m } t _ { 1 } ^ { * } ( j ) = \sum _ { ( i , j ) : C _ { i , j } > 2 \lambda } \Pi _ { 2 } ^ { * } ( i , j ) \nonumber
+$$
+
+and $s _ { 1 } ^ { * } \preceq 0 , t _ { 1 } ^ { * } \succeq 0$ , we have:
+
+$$
+\mathbf { 1 } ^ { \top } ( \mu _ { n } + s _ { 1 } ^ { * } + t _ { 1 } ^ { * } ) = \mathbf { 1 } ^ { \top } p = 1 .
+$$
+
+Therefore, we have $( \Pi _ { 1 } ^ { * } , s _ { 1 } ^ { * } , t _ { 1 } ^ { * } )$ is a feasible solution of Formulation 1. Now suppose this is not an optimal solution. Pick an optimal solution $\tilde { \Pi } , \tilde { s } , \tilde { t }$ of Formulation 1 so that:
+
+$$
+\langle C _ { a u g } , \tilde { \Pi } \rangle + \lambda \left[ \lVert \tilde { s } \rVert _ { 1 } + \lVert \tilde { t } \rVert _ { 1 } \right] < \langle C _ { a u g } , \Pi _ { 1 } ^ { * } \rangle + \lambda \left[ \lVert s _ { 1 } ^ { * } \rVert _ { 1 } + \lVert t _ { 1 } ^ { * } \rVert _ { 1 } \right]
+$$
+
+The following two lemmas provide some structural properties of any optimal solution of Formulation 1:
+
+Lemma A.1. Suppose $\Pi _ { 1 } ^ { * } , s _ { 1 } ^ { * } , t _ { 1 } ^ { * }$ are optimal solution for Formulation $^ { l }$ . Divide $\Pi _ { 1 } ^ { * }$ into four parts corresponding to augmentation as in algorithm $I$ :
+
+$$
+\Pi _ { 1 } ^ { * } = \left[ \begin{array} { c c } { { \Pi _ { 1 , 1 1 } ^ { * } } } & { { \Pi _ { 1 , 1 2 } ^ { * } } } \\ { { \Pi _ { 1 , 2 1 } ^ { * } } } & { { \Pi _ { 1 , 2 2 } ^ { * } } } \end{array} \right]
+$$
+
+Then we have $\Pi _ { 1 , 1 1 } ^ { * } = \Pi _ { 1 , 2 1 } ^ { * } = \mathbf { 0 }$ and $\Pi _ { 1 , 2 2 } ^ { * }$ is a diagonal matrix.
+
+Lemma A.2. $H \Pi _ { 1 } ^ { * } , s _ { 1 } ^ { * } , t _ { 1 } ^ { * }$ is an optimal solution of Formulation $^ { l }$ then:
+
+1. If $C _ { i , j } > 2 \lambda$ then $\Pi _ { 1 } ^ { * } ( i , j ) = 0$ .   
+2. If $C _ { i , j } < 2 \lambda$ for some i and for all $1 \leq j \leq n$ , then $s _ { 1 } ^ { * } ( i ) = 0$ .   
+3. If $C _ { i , j } < 2 \lambda$ for some $j$ and for all $1 \leq i \leq m$ , then $t _ { 1 } ^ { * } ( j ) = 0$   
+4. If $C _ { i , j } < 2 \lambda$ then $s _ { 1 } ^ { * } ( i ) t _ { 1 } ^ { * } ( j ) = 0$ .
+
+We provide the proofs in the next subsection. By Lemma A.1 we can assume without loss of generality:
+
+$$
+\tilde { \Pi } = \left[ \begin{array} { c c } { \mathbf { 0 } } & { \tilde { \Pi } _ { 1 2 } } \\ { \mathbf { 0 } } & { \mathsf { d i a g } ( \tilde { t } ) } \end{array} \right]
+$$
+
+Now based on $\Big ( \tilde { \Pi } , \tilde { s } , \tilde { t } \Big )$ we create a feasible solution namely $\Pi _ { 2 , n e w } ^ { * }$ of Formulation 2 as follows: Define the set of indices $\{ i _ { 1 } , \cdots , i _ { k } \}$ and $\{ j _ { 1 } , \ldots , j _ { l } \}$ as:
+
+$$
+\begin{array} { r } { \tilde { s } _ { i _ { 1 } } , \tilde { s } _ { i _ { 2 } } , \ldots , \tilde { s } _ { i _ { k } } > 0 \quad \mathrm { a n d } \quad \tilde { t } _ { j _ { 1 } } , \tilde { t } _ { j _ { 2 } } , \ldots , \tilde { t } _ { j _ { l } } > 0 . } \end{array}
+$$
+
+Then by part (4) of Lemma A.2 we have $C _ { i _ { \alpha } , j _ { \beta } } > 2 \lambda$ for $\alpha \in \{ 1 , \ldots , k \}$ and $\beta \in \{ 1 , \ldots , l \}$ . Also by part (2) of Lemma A.2 the value of transport plan at these co-ordinates is 0. Now distribute the mass of slack variables in these co-ordinates such that the marginals of new transport plan becomes exactly $\mu _ { n }$ and $\nu _ { m }$ . This new transport plan is our $\Pi _ { 2 , n e w } ^ { * }$ . Recall that, $\| \tilde { s } \| _ { 1 } = \widetilde { \| \dot { t } \| _ { 1 } }$ . Hence, here the regularizer value decreases by $2 \lambda \| \tilde { s } \| _ { 1 }$ and the cost value increased by exactly $2 \lambda \| \tilde { s } \| _ { 1 }$ as we are truncating the cost. Hence we have:
+
+$$
+\begin{array} { r l } & { \langle C _ { \lambda } , \Pi _ { 2 , n e w } ^ { * } \rangle = \langle C _ { a u g } , \tilde { \Pi } \rangle + \lambda \left[ \Vert \tilde { s } \Vert _ { 1 } + \Vert \tilde { t } \Vert _ { 1 } \right] } \\ & { \qquad < \langle C _ { a u g } , \Pi _ { 1 } ^ { * } \rangle + \lambda \left[ \Vert s _ { 1 } ^ { * } \Vert _ { 1 } + \Vert t _ { 1 } ^ { * } \Vert _ { 1 } \right] } \\ & { \qquad = \langle C _ { \lambda } , \Pi _ { 2 } ^ { * } \rangle } \end{array}
+$$
+
+which is contradiction as $\Pi _ { 2 } ^ { * }$ is the optimal solution of Formulation 2. This completes the proof for the discrete part.
+
+# A.2 PROOF OF EQUIVALENCE FOR TWO SIDED FORMULATION
+
+Here we prove that our two sided formulation, i.e. Formulation 3 (equation 2.7) is equivalent to Formulation 1 (equation 2.5) for the discrete case. Towards that end, we introduce another auxiliary formulation and show that both Formulation 1 and Formulation 3 are equivalent to the following auxiliary formulation of the problem.
+
+# Formulation 4:
+
+$$
+W _ { \mathbf { R } , \mathbf { L } , 4 } ( p , q ) = \left\{ \begin{array} { l l } { \operatorname* { m i n } _ { \Pi \in \mathbb { R } ^ { m \times n } , s _ { 1 } \in \mathbb { R } ^ { m } , s _ { 2 } \in \mathbb { R } ^ { n } } } & { \langle C , \Pi \rangle + \lambda [ \| s _ { 1 } \| _ { 1 } + \| s _ { 2 } \| _ { 1 } ] } \\ { \mathrm { s u b j e c t ~ t o } } & { \Pi 1 _ { n } = p + s _ { 1 } } \\ & { \Pi ^ { T } 1 _ { m } = q + s _ { 2 } } \\ & { \Pi \succeq 0 } \end{array} \right.
+$$
+
+First we show that Formulation 1 and Formulation 4 are equivalent in a sense that they have the same optimal objective value.
+
+Theorem A.3. Suppose $C$ is a cost function such that $C ( x , x ) = 0$ . Then Formulation $^ { l }$ and Formulation $^ { 4 }$ has same optimal objective value.
+
+Proof. Towards that end, we show that given one optimal variables of one formulation we can get optimal variables of other formulation with the same objective value. Before going into details we need the following lemma whose proof is provided in Appendix B:
+
+Lemma A.4. Suppose $\Pi _ { 4 } ^ { * }$ $\boldsymbol { \cdot } , s _ { 4 , 1 } ^ { * } , s _ { 4 , 2 } ^ { * }$ are the optimal variables of Formulation 4. Then $s _ { 4 , 1 } ^ { * } \preceq 0$ and $s _ { 4 , 2 } ^ { * } \preceq 0$ .
+
+Now we prove that optimal value of Formulation 1 and Formulation 4 are same. Let $( \Pi _ { 1 } ^ { * } , s _ { 1 , 1 } ^ { * } , t _ { 1 , 1 } ^ { * } )$ is an optimal solution of Formulation 1. Then we claim that $( \Pi _ { 1 } ^ { * } , s _ { 1 , 1 } ^ { * } , t _ { 1 , 1 } ^ { * } )$ is also an optimal solution of Formulation 4. Clearly it is feasible solution of Formulation 4. Suppose it is not optimal, i.e. there exists another optimal solution $( \tilde { \Pi } _ { 4 } , \tilde { s } _ { 4 , 1 } , \tilde { s } _ { 4 , 2 } )$ such that:
+
+$$
+\langle C , \tilde { \Pi } _ { 4 } \rangle + \lambda ( \lVert \tilde { s } _ { 4 , 1 } \rVert _ { 1 } + \lVert \tilde { s } _ { 4 , 2 } \rVert _ { 2 } ) < \langle C , \Pi _ { 1 , 1 2 } ^ { * } \rangle + \lambda ( \lVert s _ { 1 , 1 } ^ { * } \rVert _ { 1 } + \lVert t _ { 1 , 1 } ^ { * } \rVert _ { 1 } )
+$$
+
+Now based on $( \tilde { \Pi } _ { 4 } , \tilde { s } _ { 4 , 1 } , \tilde { s } _ { 4 , 2 } )$ we construct a feasible solution of Formulation 1 as follows:
+
+$$
+\tilde { \Pi } _ { 1 } = \left[ \begin{array} { c c } { { { \bf 0 } } } & { { \tilde { \Pi } _ { 4 } } } \\ { { { \bf 0 } } } & { { - { \bf d i a g } ( \tilde { s } _ { 4 , 2 } ) } } \end{array} \right]
+$$
+
+Note that we proved in Lemma A. $. 4 \ \tilde { s } _ { 4 , 2 } \preceq 0$ , hence we have $\tilde { \Pi } _ { 1 } \succeq 0$ . Now as the column sums of $\tilde { \Pi } _ { 4 }$ is $q + \tilde { s } _ { 4 , 2 }$ , we have column sums of $\tilde { \Pi } _ { 1 } = [ \mathbf { 0 } \mathbf { \Lambda } \boldsymbol { q } ^ { \top } ] ^ { \top }$ and the row sums are $[ ( p + \tilde { s } _ { 4 , 1 } ) ^ { \top } \quad \tilde { s } _ { 4 , 2 } ^ { \top } ] ^ { \top }$ . Hence we take $\tilde { s } _ { 1 , 1 } = \tilde { s } _ { 4 , 1 }$ and $\tilde { s } _ { 1 , 2 } = \tilde { s } _ { 4 , 2 }$ . Then it follows:
+
+$$
+\begin{array} { r l r } & { } & { \langle C _ { a u g } , \tilde { \Pi } _ { 1 } \rangle + \lambda [ \| \tilde { s } _ { 1 , 1 } \| _ { 1 } + \| \tilde { s } _ { 1 , 2 } \| _ { 1 } ] = \langle C , \tilde { \Pi } _ { 4 } \rangle + \lambda [ \| \tilde { s } _ { 4 , 1 } \| _ { 1 } + \| \tilde { s } _ { 4 , 2 } \| _ { 1 } ] \qquad } \\ & { } & { < \langle C , \Pi _ { 1 , 1 2 } ^ { * } \rangle + \lambda \left[ \| s _ { 1 , 1 } ^ { * } \| _ { 1 } + \| t _ { 1 , 1 } ^ { * } \| _ { 1 } \right] } \\ & { } & { = \langle C _ { a u g } , \Pi _ { 1 } ^ { * } \rangle + \lambda \left[ \| s _ { 1 , 1 } ^ { * } \| _ { 1 } + \| t _ { 1 , 1 } ^ { * } \| _ { 1 } \right] } \end{array}
+$$
+
+This is contradiction as we assumed $( \Pi _ { 1 } ^ { * } , s _ { 1 , 1 } ^ { * } , t _ { 1 , 2 } ^ { * } )$ is an optimal solution of Formulation 1. Therefore we conclude $( \Pi _ { 1 } ^ { * } , s _ { 1 , 1 } ^ { * } , t _ { 1 , 1 } ^ { * } )$ is also an optimal solution of Formulation 4 which further concludes Formulation 1 and Formulation 4 have same optimal values. This completes the proof of the theorem. □
+
+Theorem A.5. The optimal objective value of Formulation 3 and Formulation 4 are same.
+
+Proof. Like in the proof of Theorem A.3 we also prove couple of lemmas.
+
+Lemma A.6. Any optimal transport plan $\Pi _ { 3 } ^ { * }$ of Formulation 3 has the following structure: If we write,
+
+$$
+\Pi _ { 3 } ^ { * } = \left[ \begin{array} { c c } { { \Pi _ { 3 , 1 1 } ^ { * } } } & { { \Pi _ { 3 , 1 2 } ^ { * } } } \\ { { \Pi _ { 3 , 2 1 } ^ { * } } } & { { \Pi _ { 3 , 2 2 } ^ { * } } } \end{array} \right]
+$$
+
+then $\Pi _ { 3 , 1 1 } ^ { * }$ and $\Pi _ { 3 , 2 2 } ^ { * }$ are diagonal matrices and $\Pi _ { 3 , 2 1 } ^ { * } = \mathbf { 0 }$
+
+. If and $s _ { 3 , 1 } ^ { * } , t _ { 3 , 1 } ^ { * } , s _ { 3 , 2 } ^ { * } , t _ { 3 , 2 } ^ { * }$ are four optimal slack variables in Formulation 3, then $s _ { 3 , 1 } ^ { * } , t _ { 3 , 1 } ^ { * } \preceq 0$ $s _ { 3 , 2 } ^ { * } , t _ { 3 , 2 } ^ { * } \succeq 0$
+
+Proof. The line of argument is same as in proof of Lemma A.4.
+
+Next we establish equivalence. Suppose $( \Pi _ { 3 } ^ { * } , s _ { 3 , 1 } ^ { * } , t _ { 3 , 1 } ^ { * } , s _ { 3 , 2 } ^ { * } , t _ { 3 , 2 } ^ { * } )$ are optimal values of Formulation 3. We claim that $( \Pi _ { 3 , 1 2 } ^ { * } , s _ { 3 , 1 } ^ { * } - s _ { 3 , 2 } ^ { * } , t _ { 3 , 1 } ^ { * } - t _ { 3 , 2 } ^ { * } )$ forms an optimal solution of Formulation 4. The objective value will then also be same as $s _ { 3 , 1 } ^ { * } \preceq 0 , s _ { 3 , 2 } ^ { * } \succeq 0$ (Lemma A.7) implies $\| s _ { 3 , 1 } ^ { * } - s _ { 3 , 2 } ^ { * } \| _ { 1 } =$ $\lVert s _ { 3 , 1 } ^ { * } \rVert _ { 1 } + \lVert s _ { 3 , 2 } ^ { * } \rVert _ { 1 }$ and similarly $t _ { 3 , 1 . } ^ { * } \preceq 0 , t _ { 3 , 2 } ^ { * } \succeq 0$ implies $\lVert t _ { 3 , 1 } ^ { * } - t _ { 3 , 2 } ^ { * } \rVert _ { 1 } = \lVert t _ { 3 , 1 } ^ { * } \rVert _ { 1 } + \lVert t _ { 3 , 2 } ^ { * } \rVert _ { 1 }$ . Feasibility is immediate. Now for optimality, we again prove by contradiction. Suppose they are not optimal. Then lets say $\tilde { \Pi } _ { 4 } , \tilde { s } _ { 4 , 1 } , \tilde { s } _ { 4 , 2 }$ are an optimal triplet of Formulation 4. Now construct another feasible solution of Formulation 3 as follows: Set $\tilde { s } _ { 3 , 2 } = \tilde { t } _ { 3 , 2 } = 0 , \tilde { s } _ { 3 , 1 } = \tilde { s } _ { 4 , 1 }$ and $\tilde { t } _ { 3 , 1 } = \tilde { s } _ { 4 , 2 }$ . Set the matrix as:
+
+$$
+\tilde { \Pi } _ { 3 } = \left[ \begin{array} { c c } { { { \bf 0 } } } & { { \tilde { \Pi } _ { 4 } } } \\ { { { \bf 0 } } } & { { - { \bf d i a g } ( \tilde { s } _ { 4 , 2 } ) } } \end{array} \right]
+$$
+
+Then it follows that $\left( \tilde { \Pi } _ { 3 } , \tilde { s } _ { 3 , 1 } , \tilde { s } _ { 3 , 2 } , \tilde { t } _ { 3 , 1 } , \tilde { t } _ { 3 , 2 } \right)$ is a feasible solution of Formulation 3. Finally we have:
+
+$$
+\begin{array} { r l } & { \langle C _ { a u g } , \tilde { \Pi } _ { 3 } \rangle + \lambda \left[ \| \tilde { s } _ { 3 , 1 } \| _ { 1 } + \| \tilde { s } _ { 3 , 2 } \| _ { 1 } + \| \tilde { t } _ { 3 , 1 } \| _ { 1 } + \| \tilde { t } _ { 3 , 2 } \| _ { 1 } \right] } \\ & { = \langle C _ { a u g } , \tilde { \Pi } _ { 3 } \rangle + \lambda \left[ \| \tilde { s } _ { 4 , 1 } \| _ { 1 } + \| \tilde { s } _ { 4 , 2 } \| _ { 1 } \right] } \\ & { = \langle C , \tilde { \Pi } _ { 4 } \rangle + \lambda \left[ \| \tilde { s } _ { 4 , 1 } \| _ { 1 } + \| \tilde { s } _ { 4 , 2 } \| _ { 1 } \right] } \\ & { < \langle C , \Pi _ { 3 , 1 2 } ^ { * } \rangle + \lambda \left[ \| s _ { 3 , 1 } ^ { * } - s _ { 3 , 2 } ^ { * } \| _ { 1 } + \| t _ { 3 , 1 } ^ { * } - t _ { 3 , 2 } ^ { * } \| _ { 1 } \right] } \\ & { = \langle C _ { a u g } , \Pi _ { 3 } ^ { * } \rangle + \lambda \left[ \| s _ { 3 , 1 } ^ { * } \| _ { 1 } + \| s _ { 3 , 2 } ^ { * } \| _ { 1 } + \| t _ { 3 , 1 } ^ { * } \| _ { 1 } + \| t _ { 3 , 2 } ^ { * } \| _ { 1 } \right] } \end{array}
+$$
+
+This contradicts the optimality of $( \Pi _ { 3 } ^ { * } , s _ { 3 , 1 } ^ { * } , s _ { 3 , 2 } ^ { * } , t _ { 3 , 1 } ^ { * } , t _ { 3 , 2 } ^ { * } )$ . This completes the proof.
+
+# A.3 PROOF OF CONTINUOUS VERSION
+
+Proof. In this proof we denote by $F _ { 1 }$ the optimization problem of equation equation 2.2 and by $F _ { 2 }$ the optimization problem equation equation 2.4. Assume that $\mu _ { n }$ and $\nu _ { m }$ denote the respective empirical measures relative to $\mu , \nu$ . From Villani (2009), we know that $\mu _ { n } , \nu _ { n }$ converge weakly to $\mu$ and $\nu$ respectively. Therefore, $R O B O T _ { 2 } ( \mu _ { n } , \mu )  0$ . Similary for $\nu _ { n }$ and $\nu$ . Thus, by triangle inequality,
+
+$$
+\operatorname* { l i m } _ { n \to \infty } | F _ { 2 } ( \mu _ { n } , \nu _ { n } ) - F _ { 2 } ( \mu , \nu ) | = 0 .
+$$
+
+But $R O B O T _ { 2 } ( \mu _ { n } , \nu _ { n } ) = R O B O T _ { 1 } ( \mu _ { n } , \nu _ { n } )$ . Therefore, our proof is complete if we can show that
+
+$$
+\operatorname* { l i m } _ { n , m \to \infty } \left| F _ { 1 } ( \mu _ { n } , \nu _ { m } ) - F _ { 1 } ( \mu , \nu ) \right| \to 0 .
+$$
+
+Let $\mathcal { S } = \{ s$ signed measure : $\mu + s$ is a probability measure in $\mathbb { R } ^ { d } \}$ . For $s \in \mathcal S$ , define
+
+$$
+\begin{array} { r } { V ( \mu + S , \nu ) = \left\{ \begin{array} { l l } { \displaystyle \operatorname* { m i n } _ { \Pi \in \mathcal { F } ( \mathbb { R } ^ { d } \times \mathbb { R } ^ { d } ) } } & { \displaystyle \int C ( x , y ) \ \Pi ( \mathrm { d } x , \mathrm { d } y ) + \lambda \| s \| _ { T V } } \\ { \displaystyle \mathrm { s u b j e c t ~ t o } } & { \displaystyle \int _ { A } \Pi ( \mathrm { d } x , \mathrm { d } y ) \geq 0 \forall A \in \mathcal { B } ( \mathbb { R } ^ { d } \times \mathbb { R } ^ { d } ) } \\ { \displaystyle \mu ( \mathrm { d } x ) + s ( \mathrm { d } x ) ) \geq 0 } & { \displaystyle \forall B \in \mathcal { B } ( \mathbb { R } ^ { d } ) } \\ & { \displaystyle \int _ { \mathbb { R } ^ { d } \times C } \Pi ( \mathrm { d } x , \mathrm { d } y ) = \int _ { C } \nu ( \mathrm { d } y ) \ \forall C \in \mathcal { B } ( \mathbb { R } ^ { d } ) . } \end{array} \right. } \end{array}
+$$
+
+By Lemma A.8, ∃ $s \in \mathcal S$ such that $R O B O T _ { \cdot } ( \mu , \nu ) = W ( \mu + s , \nu ) + \lambda \| s \| _ { T V }$ . Let $s = s ^ { + } - s ^ { - }$ where $s ^ { + }$ and $s ^ { - }$ are positive measures on $\mathbb { R } ^ { d }$ . Let $\| s \| _ { T V } = \gamma$ . Then, $\| s ^ { - } \| _ { T V } = \| s ^ { + } \| _ { T V } = \gamma / 2$
+
+Then consider $X _ { 1 } , \dots , X _ { n } \sim ( P - s ^ { - } ) / ( 1 - \gamma ) , Y _ { 1 } , \dots , Y _ { n } \sim s ^ { - } / \gamma , Z _ { 1 } , \dots , Z _ { n } \sim s ^ { + } / \gamma .$ Then for any bounded continuous function $f$ ,
+
+$$
+\begin{array} { r c l } { \displaystyle \underset { n \to \infty } { \operatorname* { l i m } } \displaystyle \sum _ { i } f ( X _ { i } ) / n } & { = } & { \displaystyle \int f ( x ) \frac { \left( P - s ^ { - } \right) } { ( 1 - \gamma ) } ( \mathrm { d } x ) } \\ { \displaystyle \underset { n \to \infty } { \operatorname* { l i m } } \displaystyle \sum _ { i } f ( Z _ { i } ) / n } & { = } & { \displaystyle \int f ( x ) \frac { s ^ { + } } { \gamma } ( \mathrm { d } x ) } \end{array}
+$$
+
+Therefore, the distribution given by $( P + s ) _ { n } = \frac { ( 1 - \gamma ) } { n } \sum _ { i } \delta _ { X _ { i } } + \frac { \gamma } { n } \sum _ { i } \delta _ { Z _ { i } }$ satisfies, $( P + s ) _ { n } \stackrel { \mathcal { L } } {  }$ $P + s$ , and therefore from (Villani, 2009), $\begin{array} { r } { \operatorname* { l i m } _ { n \to \infty } \tilde { W } _ { C } ( ( P + S ) _ { n } , \bar { \nu } _ { n } ) \to W ( P + S , Q ) } \end{array}$ . Here $\delta _ { x }$ is the Dirac mass at $x$ . Moreover, $\| s _ { n } \| = \| s \|$ , where $s _ { n }$ satisfies $s _ { n } = \frac { \gamma } { n } ( \sum _ { i } \delta _ { Z _ { i } } - \sum _ { i } \delta _ { Y _ { i } } )$ .
+
+Also, $R O B O T ( \mu _ { n } , \nu _ { n } ) ~ \le ~ W ( ( P ~ + ~ s ) _ { n } , \nu _ { n } ) ~ + ~ \lambda \| s \| _ { T V }$ , and therefore $R O B O T _ { 2 } ( \mu , \nu ) ) \ =$ lim $\begin{array} { r } { \gimel \operatorname* { s u p } _ { n \to \infty } R O B O T ( \mu _ { n } , \nu _ { n } ) \leq R O B O T ( \mu , \nu ) } \end{array}$ .
+
+Now, let $\tilde { s } _ { n }$ satisfy $W _ { 1 } ( \mu _ { n } + \tilde { s } _ { n } , \nu _ { n } ) + \lambda \| \tilde { s } _ { n } \| _ { T V } = R O B O T ( \mu _ { n } , \nu _ { n } )$ . Such an ${ \tilde { s } } _ { n }$ exists by the proof of the discrete part because $\mu _ { n } , \nu _ { n }$ are discrete measures.
+
+Then, similar to the Step 1 in the proof of Lemma A.8, there exists a probability measure $\mu \oplus s$ and a subsequence $\{ n _ { k } \} _ { k \ge 1 }$ such that $\mu _ { n _ { k } } + s _ { n _ { k } }$ almost surely converges weakly to $\mu \oplus s$ .
+
+Moreover, similar to Step 2 of Lemma A.8 $W _ { 1 } ( \mu _ { n _ { k } } + s _ { n _ { k } } , \mu \oplus s ) \to 0$ as well as $\| s _ { n _ { k } } \| _ { T V } $ $\| \mu \oplus s - \mu \| _ { T V }$ . Thus, $W _ { 1 } ( \mu _ { n _ { k } } + s _ { n _ { k } } , \nu _ { n _ { k } } ) + \lambda \| s _ { n _ { k } } \| _ { T V }  W _ { 1 } ( \mu \oplus s , \nu ) + \lambda \| \mu \oplus s - \mu \| _ { T V } .$ But by the proof of the discrete part $R O B O T ( \mu _ { n _ { k } } , \nu _ { n _ { k } } ) = R O B O T _ { 2 } ( \mu _ { n _ { k } } , \nu _ { n _ { k } } )  .$ ROBOT2(µ, ν). Therefore, with $s = \mu \oplus s - \mu$ , $W _ { 1 } ( \mu + s , \nu ) + \lambda \| s \| _ { T V } = R O B O T _ { 2 } ( \mu , \nu )$ .
+
+Therefore, $R O B O T _ { 2 } ( \mu , \nu ) = \operatorname* { l i m } \operatorname* { s u p } _ { n \to \infty } R O B O T ( \mu _ { n } , \nu _ { n } ) \geq R O B O T ( \mu , \nu )$ . Thus the equality holds.
+
+Lemma A.8. Assume that $\mu , \nu$ is such that $\begin{array} { r } { \int \| \boldsymbol { x } \| \mathrm { d } \mu , \ \int \| \boldsymbol { x } \| \mathrm { d } \nu < \infty } \end{array}$ . Moreover, assume that $C ( x , y )$ in equation 2.2 is the $l _ { 1 }$ norm, i.e., $C ( \dot { x } , y ) = \| x - y \|$ . Then, there exists s with $\mu + s$ being a probability measure such that
+
+$$
+W _ { 1 } ( \mu + s , \nu ) + \lambda \| s \| _ { T V } = R O B O T ( \mu , \nu ) ,
+$$
+
+where $W _ { 1 }$ is the Wasserstein-1 norm with the cost function $C ( \cdot , \cdot )$ as mentioned above.
+
+Proof. Let $\mu _ { n } , \nu _ { m }$ be the empirical measures relative to $\mu , \nu$ respectively. We know that since $\mu _ { n } , \nu _ { m }$ are discrete, there exists $s _ { n }$ satisfying $W _ { 1 } ( \mu _ { n } + s _ { n } , \nu _ { m } ) = R O B O T ( \mu _ { n } , \nu _ { m } )$ . We provide the proof in the following steps.
+
+Step 1: Almost surely $\mu \times \nu$ , there exists a subsequence $\{ n _ { k } \} _ { k \ge 1 }$ such that $\{ \mu _ { n } + s _ { n } \} _ { n }$ and $\{ \nu _ { n } \} _ { n }$ is relatively compact.
+
+$\mu$ and $\nu$ are probability measures on $\mathbb { R } ^ { d }$ and are therefore tight.   
+Let $K _ { \epsilon }$ be such that $\dot { P _ { \mu } } ( X \notin K _ { \epsilon } ) , P _ { \nu } ( Y \notin K _ { \epsilon } ) \le \epsilon / 4$ .
+
+Consider the empirical distributions $\nu _ { n } = \textstyle \sum _ { i } \delta _ { Y _ { i } } / n , \mu _ { n } \textstyle \sum _ { i } \delta _ { X _ { i } } / n$ of $\nu , \mu$ respectively. Here, $X _ { i } \sim$ $\mu$ and $Y _ { i } \sim _ { \nu }$ .
+
+Fix an $\omega$ . Then $\{ X _ { 1 } , . . . , X _ { n } , Y _ { 1 } , . . . , Y _ { n } \}$ is fixed. Now by the construction for the discrete case, $s _ { n }$ has support in $\{ X _ { 1 } , . . . , X _ { n } , Y _ { 1 } , . . . , Y _ { n } \}$ .
+
+Let $T _ { n }$ be the optimal transport map from $\mu _ { n }$ to $\nu _ { n }$ . Then, for every $i \leq n$ , there exists a unique $j \ \leq \ n$ , such that $T _ { n } ( X _ { i } ) ~ = ~ Y _ { j }$ . Define $\tau _ { n } : \{ 1 , \dots , n \} \to \{ 1 , \dots , n \}$ such that $\tau _ { n } ( i ) = j$ if $T _ { n } ( X _ { i } ) = Y _ { j }$ .Then $\mu _ { n } + s _ { n } = \sum _ { i } \delta _ { Z _ { i } } / n$ , where $Z _ { i } = X _ { i }$ or $Y _ { \tau _ { n } ( i ) }$ and $\delta _ { x }$ is the Dirac delta mass at $x$ .
+
+Then, let $Z \sim \mu _ { n } + s _ { n }$
+
+$$
+P _ { \omega } ( Z \notin K _ { \epsilon } | \mu _ { n } + s _ { n } ) \le \sum _ { i } \mathbb { 1 } _ { ( X _ { i } \notin K _ { \epsilon } ) } / n + \sum _ { i } \mathbb { 1 } _ { ( Y _ { i } \notin K _ { \epsilon } ) } / n
+$$
+
+Therefore, $\mathbb { E } ( P _ { \omega } ( Z \notin K _ { \epsilon } | \mu _ { n } + s _ { n } ) ) \le \epsilon / 2$ . Moreover, ${ \cal V } a r ( P _ { \omega } ( Z \not \in K _ { \epsilon } | \mu _ { n } + s _ { n } ) ) = o ( n ^ { - 1 } ) \to 0$ . Therefore, $\begin{array} { r } { \operatorname* { l i m } _ { n  \infty } P _ { \mu ^ { n } \times \nu ^ { n } } \big ( P _ { \omega } ( Z \notin K _ { \epsilon } | \mu _ { n } + s _ { n } ) \le \epsilon \big )  1 } \end{array}$ . Therefore $\mu _ { n } + s _ { n }$ is almost surely tight and thus by Prokhorov’s Theorem also relatively compact.
+
+Step 2: Therefore, for $\omega$ almost surely, there exists a subsequence $\{ n _ { k } \} _ { k \ge 1 }$ such that $\mu _ { n _ { k } } + s _ { n _ { k } }$ converges weakly to a limit (dependent on $\omega$ ) $\mu \oplus s$ which is a probability measure. Moreover, $\textstyle \int \| x \| \bar { \mathrm { d } } ( \mu _ { n _ { k } } + s _ { n _ { k } } ) < \infty$ almost surely. By Bolzano-Weierstrass Theorem, there exists a further subsequence $\{ n _ { k _ { l } } \} _ { l }$ such that $\begin{array} { r } { \int \| x \| \mathrm { d } ( \mu _ { n _ { k _ { l } } } + s _ { n _ { k _ { l } } } )  \int \| x \| \mathrm { d } ( \mu + s ) } \end{array}$ almost surely. For the sake of convenience, without loss of generality, we will replace the sub-subsequence $\{ n _ { k _ { l } } \} _ { l }$ with $\{ n _ { k } \} _ { k \ge 1 }$ henceforth.
+
+Thus, by Theorem 6.9 of (Villani, 2009) , $W _ { 1 } ( \mu _ { n _ { k } } + s _ { n _ { k } } , \mu \oplus s ) \to 0$ almost surely. Moreover, $W _ { 1 } ( \mu _ { n _ { k } } , \mu ) \to 0$ almost surely. Therefore $\| s _ { n _ { k } } \| _ { T V } \to \| \mu \oplus s - \mu \| _ { T V }$ almost surely.
+
+Step 3: Consider an arbitrary $S = S ^ { + } - S ^ { - }$ , such that $S ^ { + }$ and $S ^ { - }$ are positive measures on $\mathbb { R } ^ { d }$ , and $\mu + S$ is a probability measure. Let $\| S \| _ { T V } = \gamma$ . Then, $\| S ^ { - } \| _ { T V } = \| S ^ { + } \| _ { T V } = \gamma / 2$ .
+
+Then consider $X _ { 1 } , \dots , X _ { n } \sim ( \mu - S ^ { - } ) / ( 1 - \gamma ) , Y _ { 1 } , \dots , Y _ { n } \sim S ^ { - } / \gamma , Z _ { 1 } , \dots , Z _ { n } \sim S ^ { + } / \gamma$ . Then for any bounded continuous function $f$ ,
+
+$$
+\begin{array} { r c l } { { \displaystyle \operatorname* { l i m } _ { n \to \infty } \sum _ { i } f ( X _ { i } ) / n } } & { { = } } & { { \displaystyle \int f ( x ) \frac { \left( P - s ^ { - } \right) } { ( 1 - \gamma ) } ( \mathrm { d } x ) } } \\ { { \displaystyle \operatorname* { l i m } _ { n \to \infty } \sum _ { i } f ( Z _ { i } ) / n } } & { { = } } & { { \displaystyle \int f ( x ) \frac { s ^ { + } } { \gamma } ( \mathrm { d } x ) } } \end{array}
+$$
+
+Therefore, the distribution given by $\begin{array} { r } { ( \mu + S ) _ { n } ( A ) = ( 1 - \gamma ) \sum _ { i } \mathbb { 1 } _ { X _ { i } \in A } + ( \gamma ) \sum _ { i } \mathbb { 1 } _ { Z _ { i } \in A } } \end{array}$ satisfies, $( \mu + S ) _ { n } \stackrel { \mathcal { L } } { \to } \mu + S$ , and therefore from (Villani, 2009), $\begin{array} { r } { \operatorname* { l i m } _ { n \to \infty } W _ { 1 } ( ( \mu + S ) _ { n } , \nu _ { n } ) \to W _ { 1 } ( \mu + S , \nu ) } \end{array}$ . Moreover, $\| S _ { n } \| _ { T V } = \| S \| _ { T V }$ , where $S _ { n }$ satisfies $S _ { n } ( A ) = { \frac { \gamma } { n } } \sum _ { i } \mathbb { 1 } _ { Z _ { i } \in A } - \sum _ { i } \mathbb { 1 } _ { Y _ { i } \in A }$ .
+
+But, $W _ { 1 } ( \mu _ { n _ { k } } + s _ { n _ { k } } , \nu _ { n _ { k } } ) + \lambda \| s _ { n _ { k } } \| _ { T V } \leq W _ { 1 } ( ( \mu + S ) _ { n _ { k } } , \nu _ { n _ { k } } ) + \lambda \| S _ { n _ { k } } \| _ { T V }$ . Therefore, taking limits, $W _ { 1 } ( \mu \oplus s , \nu ) + \lambda \| \mu \oplus s - \mu \| _ { T V } \leq W _ { 1 } ( \mu + S , \nu ) + \lambda \| S \| _ { T V }$ , and thus the proof holds with $s = \mu \oplus s - \mu$ .
+
+# B PROOF OF ADDITIONAL LEMMAS
+
+# B.1 PROOF OF LEMMA A.1
+
+Proof. The fact that $\Pi _ { 1 , 1 1 } ^ { * } = \Pi _ { 1 , 2 1 } ^ { * } = \mathbf { 0 }$ follows from the fact that $\Pi _ { 1 } ^ { * } \succeq 0$ and $\Pi _ { 1 } ^ { * } \mathbf { 1 } = \mathbf { Q }$ . To prove that $\Pi _ { 1 , 2 2 } ^ { * }$ is diagonal, we use the fact that the any diagonal entry the cost matrix is 0. Now suppose $\Pi _ { 1 , 2 2 } ^ { * }$ is not diagonal. Then define a matrix $\hat { \Pi }$ as following: set $\hat { \Pi } _ { 1 1 } = \hat { \Pi } _ { 2 1 } = \mathbf { 0 }$ , $\hat { \Pi } _ { 1 2 } = \Pi _ { 1 , 1 2 } ^ { * }$ and:
+
+$$
+\hat { \Pi } _ { 2 2 } ( i , j ) = \left\{ \begin{array} { l l } { \sum _ { k = 1 } ^ { m } \Pi _ { 1 , 2 2 } ^ { * } ( k , i ) , } & { \mathrm { i f ~ } j = i } \\ { 0 , } & { \mathrm { i f ~ } j \ne i } \end{array} \right.
+$$
+
+Also define $\hat { s } = s _ { 1 } ^ { * }$ and $\hat { t }$ as $\hat { t } ( i ) = \hat { \Pi } _ { 2 2 } ( i , i )$ . Then clearly $( \hat { \Pi } , \hat { s } , \hat { t } )$ is a feasible solution of Formulation 1. Note that:
+
+$$
+\Vert \hat { t } \Vert _ { 1 } = 1 ^ { \top } \hat { \Pi } _ { 2 2 } 1 = 1 ^ { \top } \Pi _ { 1 , 2 2 } ^ { * } 1 = \Vert t _ { 1 } ^ { * } \Vert _ { 1 }
+$$
+
+and by our construction $\left. C _ { a u g } , \hat { \Pi } \right. < \left. C _ { a u g } , \Pi _ { 1 } ^ { * } \right.$ . Hence $( { \hat { \Pi } } , { \hat { s } } , { \hat { t } } )$ reduces the value of the objective function of Formulation 1 which is a contradiction. This completes the proof.
+
+# B.2 PROOF OF LEMMA A.2
+
+Proof. 1. Suppose $\Pi _ { 1 } ^ { * } ( i , j ) ~ > ~ 0$ . Then dump this mass to $s _ { 1 } ^ { * } ( j )$ and make it 0. In this way $\left. C _ { a u g } , \Pi _ { 1 } ^ { * } \right.$ will decrease by $> 2 \lambda \Pi _ { 1 } ^ { * } ( i , j )$ and the regularizer value will increase by atmost $2 \lambda \Pi _ { 1 } ^ { * } ( i , j )$ , resulting in overall reduction in the objective value, which leads to a contradiction.
+
+2. Suppose each entry of $i ^ { t h }$ row of $C$ is $< 2 \lambda$ . Then if $s _ { 1 } ^ { * } ( i ) > 0$ , we can distribute this mass in the $\bar { i } ^ { t h }$ row such that, $s _ { 1 } ^ { * } ( i ) = a _ { 1 } + a _ { 2 } + \cdot \cdot \cdot + a _ { m }$ with the condition that $t _ { 1 } ^ { * } ( j ) \geq a _ { j }$ . Now we reduce $t _ { 1 } ^ { * }$ as:
+
+$$
+t _ { 1 } ^ { * } ( j ) \gets t _ { 1 } ^ { * } ( j ) - a _ { j }
+$$
+
+Hence the value $\left. C _ { a u g } , \Pi _ { 1 } ^ { * } ( i , j ) \right.$ will increase by a value $< 2 \lambda s _ { 1 } ^ { * } ( i )$ but the value of regularizer will decrease by the value of $2 \lambda s _ { 1 } ^ { * } ( i )$ , resulting in overall decrease in the value of objective function.
+
+3. Same as proof of part (2) by interchanging row and column in the argument.
+
+4. Suppose not. Then choose $\epsilon < s _ { 1 } ^ { * } ( i ) \bar { \wedge } t _ { 1 } ^ { * } ( j )$ , Add $\epsilon$ to $\Pi _ { 1 } ^ { * } ( i , j )$ . Hence the cost function value $\left. C _ { a u g } , \Pi _ { 1 } ^ { * } \right.$ will increase by $< 2 \lambda \epsilon$ but the regularizer value will decrease by $2 \lambda \epsilon$ , resulting in overall decrease in the objective function.
+
+# B.3 PROOF OF LEMMA A.4
+
+Proof. For the notational simplicity, we drop the subscript 4 now as we will only deal with the solution of Formulation 4 and there will be no ambiguity. We prove the Lemma by contradiction. Suppose $s _ { 1 , i } ^ { * } > 0$ . Then we show one can come up with another solution $( \tilde { \Pi } , \tilde { s } _ { 1 } , \tilde { s } _ { 2 } )$ of Formulation 4 such that it has lower objective value. To construct this new solution, make:
+
+$$
+\tilde { s } _ { 1 , j } = \left\{ \begin{array} { l l } { s _ { 1 , j } ^ { * } , } & { \mathrm { i f } \ j \ne i } \\ { 0 , } & { \mathrm { i f } \ j = i } \end{array} \right.
+$$
+
+Now to change the optimal transport plan, we will only change $i ^ { t h }$ row of $\Pi ^ { * }$ . We subtract $a _ { 1 } , a _ { 2 } , \ldots , a _ { n } \geq 0$ from $i ^ { t h }$ column of $\Pi ^ { * }$ in such a way, such that none of the elements are negative. Hence the column sum will be change, i.e. the value of ${ \tilde { s } } _ { 2 }$ will be:
+
+$$
+\tilde { s } _ { 2 , j } = s _ { 2 , j } ^ { * } - a _ { j } \forall 1 \leq j \leq n .
+$$
+
+Now clearly from our construction:
+
+$$
+\langle C , \tilde { \Pi } \rangle \leq \langle C , \Pi ^ { * } \rangle
+$$
+
+For the regularization part, note that, as we only reduced $i ^ { t h }$ element of $s _ { 1 } ^ { * }$ , we have $\| \tilde { s } _ { 1 } \| _ { 1 } =$ $\| s _ { 1 } ^ { * } \| _ { 1 } - s _ { 1 , i } ^ { * }$ . And by simple triangle inequality,
+
+$$
+\| \widetilde s _ { 2 } \| _ { 1 } \leq \| s _ { 2 } ^ { * } \| _ { 1 } + \| a _ { 1 } \| _ { 1 } = \| s _ { 2 } ^ { * } \| _ { 1 } + s _ { 1 , i } ^ { * }
+$$
+
+by construction $a _ { i }$ ’s, as $a _ { i } \geq 0$ and $\textstyle \sum _ { i } a _ { i } = s _ { 1 , i } ^ { * }$ . Hence we have:
+
+$$
+\| \widetilde s _ { 1 } \| _ { 1 } + \| \widetilde s _ { 2 } \| _ { 1 } \leq \| s _ { 1 } ^ { * } \| _ { 1 } - s _ { 1 , i } ^ { * } + \| s _ { 2 } ^ { * } \| _ { 1 } + s _ { 1 , i } ^ { * } = \| s _ { 1 } ^ { * } \| _ { 1 } + \| s _ { 2 } ^ { * } \| _ { 1 } .
+$$
+
+Hence the value corresponding to regularizer will also decrease. This completes the proof.
+
+# B.4 PROOF OF LEMMA A.6
+
+Proof. We prove this lemma by contradiction. Suppose $\Pi _ { 3 } ^ { * }$ does not have the structure mentioned in the statement of Lemma. Construct another transport plan for Formulation $3 \tilde { \Pi } _ { 3 }$ as follows: Keep $\tilde { \Pi } _ { 3 , 1 2 } = \Pi _ { 3 , 1 2 } ^ { * }$ and set $\tilde { \Pi } _ { 3 , 1 2 } = \mathbf { 0 }$ . Construct the other parts as:
+
+$$
+\begin{array} { r } { \tilde { \Pi } _ { 3 , 1 1 } ( i , j ) = \left\{ \begin{array} { l l } { \sum _ { k = 1 } ^ { m } \Pi _ { 3 , 1 1 } ^ { * } ( i , k ) + \sum _ { k = 1 } ^ { n } \Pi _ { 3 , 2 1 } ^ { * } ( k , i ) , } & { \mathrm { i f ~ } i = j } \\ { 0 , } & { \mathrm { i f ~ } i \ne j } \end{array} \right. } \end{array}
+$$
+
+and
+
+$$
+\tilde { \Pi } _ { 3 , 2 2 } ( i , j ) = \left\{ \begin{array} { l l } { \sum _ { k = 1 } ^ { n } \Pi _ { 3 , 2 2 } ^ { * } ( k , i ) , } & { \mathrm { i f ~ } i = j } \\ { 0 , } & { \mathrm { i f ~ } i \ne j } \end{array} \right.
+$$
+
+It is immediate from the construction that:
+
+$$
+\left. C _ { a u g } , \tilde { \Pi } _ { 3 } \right. \leq \left. C _ { a u g } , \Pi _ { 3 } ^ { * } \right.
+$$
+
+As for the regularization term: Note the by our construction ${ \tilde { s } } _ { 4 }$ will be same as $s _ { 4 } ^ { * }$ as column sum of $\tilde { \Pi } _ { 3 , 2 2 }$ is same as $\Pi _ { 3 , 2 2 } ^ { * }$ . For the other three:
+
+$$
+\tilde { s } _ { 3 } ( i ) = \tilde { \Pi } _ { 3 , 1 1 } ( i , i ) = \sum _ { k = 1 } ^ { m } \Pi _ { 3 , 1 1 } ^ { * } ( i , k ) + \sum _ { k = 1 } ^ { n } \Pi _ { 3 , 2 1 } ^ { * } ( k , i )
+$$
+
+$$
+\tilde { s } _ { 2 } ( i ) = \tilde { \Pi } _ { 3 , 2 2 } ( i , i ) = \sum _ { k = 1 } ^ { n } \Pi _ { 3 , 2 2 } ^ { * } ( k , i )
+$$
+
+and hence by construction:
+
+$$
+\begin{array} { r } { \| \tilde { s } _ { 2 } \| _ { 1 } = \mathbf { 1 } ^ { \top } \Pi _ { 3 , 2 2 } ^ { * } \mathbf { 1 } = \| s _ { 2 } ^ { * } \| _ { 1 } - \mathbf { 1 } ^ { \top } \Pi _ { 3 , 2 1 } ^ { * } \mathbf { 1 } . } \\ { \| \tilde { s } _ { 3 } \| _ { 1 } = \mathbf { 1 } ^ { \top } \Pi _ { 3 , 1 1 } ^ { * } \mathbf { 1 } + \mathbf { 1 } ^ { \top } \Pi _ { 3 , 2 1 } ^ { * } \mathbf { 1 } = \| s _ { 3 } ^ { * } \| _ { 1 } } \end{array}
+$$
+
+And also by our construction, $\tilde { s } _ { 1 } = s _ { 1 } ^ { * } + c$ where $c = ( \Pi _ { 3 , 2 1 } ^ { * } ) ^ { \top } \mathbf { 1 }$ . As a consequence we have $\Vert c \Vert _ { 1 } = \mathbf { 1 } ^ { \top } \Pi _ { 3 , 2 1 } ^ { * } \mathbf { 1 }$ . Then it follows:
+
+$$
+\begin{array} { l } { \displaystyle \sum _ { i = 1 } ^ { 4 } \| \widetilde s _ { i } \| _ { 1 } = \| s _ { 1 } ^ { * } + c \| + \| s _ { 2 } ^ { * } \| _ { 1 } - \mathbf { 1 } ^ { \top } \Pi _ { 3 , 2 1 } ^ { * } \mathbf { 1 } + \| s _ { 3 } ^ { * } \| _ { 1 } + \| s _ { 4 } ^ { * } \| _ { 1 } } \\ { \displaystyle \qquad \leq \displaystyle \sum _ { i = 1 } ^ { 4 } \| s _ { i } ^ { * } \| _ { 1 } + \| c \| _ { 1 } - \mathbf { 1 } ^ { \top } \Pi _ { 3 , 2 1 } ^ { * } \mathbf { 1 } } \\ { \displaystyle \qquad = \displaystyle \sum _ { i = 1 } ^ { 4 } \| s _ { i } ^ { * } \| _ { 1 } } \end{array}
+$$
+
+So the objective value is overall reduced. This contradicts the optimality of $\Pi _ { 3 } ^ { * }$ which completes the proof.
+
+# C PROOF OF THEOREM 2.1
+
+Proof. The proof is immediate from the Formulation 1. Recall that the Formulation 1 can restructured as:
+
+$$
+R O B O T ( \tilde { \mu } , \nu ) = \operatorname* { i n f } _ { P } \left\{ O T ( P , \nu ) + \lambda \| P - \tilde { \mu } \| _ { T V } \right\} .
+$$
+
+where the infimum is taking over all measure dominated by some common measure $\sigma$ (with respect to which $\mu , \mu _ { c } , \nu$ are dominated). Hence,
+
+$$
+R O B O T ( \tilde { \mu } , \nu ) \leq O T ( P , \nu ) + \lambda \| P - \tilde { \mu } \| _ { T V }
+$$
+
+for any particular choice of $P$ . Taking $P = \mu$ we get that
+
+$$
+R O B O T ( \tilde { \mu } , \nu ) \leq O T ( \mu , \nu ) + \lambda \| \mu - \tilde { \mu } \| _ { T V } = O T ( \mu , \nu ) ) + \lambda \epsilon \| \mu - \mu _ { c } \| _ { T V }
+$$
+
+Taking $P ~ = ~ \nu$ we get $R O B O T ( \tilde { \mu } , \nu ) ~ \leq ~ \lambda \| \nu - \tilde { \mu } \| _ { T V }$ and finally taking $P = ~ \tilde { \mu }$ we get $R O B \bar { O } T ( \tilde { \mu } , \nu ) \le O \bar { T } ( \tilde { \mu } , \nu )$ . This completes the proof.