Add files using upload-large-folder tool

parse/train/BylRkAEKDH/BylRkAEKDH.md

@@ -0,0 +1,369 @@
+# TABNET: ATTENTIVE INTERPRETABLE TABULAR LEARNING
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+We propose a novel high-performance interpretable deep tabular data learning network, TabNet. TabNet utilizes a sequential attention mechanism that softly selects features to reason from at each decision step and then aggregates the processed information to make a final prediction decision. By explicitly selecting sparse features, TabNet learns very efficiently as the model capacity at each decision step is fully utilized for the most relevant features, resulting in a high performance model. This sparsity also enables more interpretable decision making through the visualization of feature selection masks. We demonstrate that TabNet outperforms other neural network and decision tree variants on a wide range of tabular data learning datasets, especially those are not saturated in performance, and yields interpretable feature attributions and insights into the global model behavior.
+
+# 1 INTRODUCTION
+
+Deep neural networks have been demonstrated to be very powerful in understanding images (He et al., 2015; Simonyan & Zisserman, 2014; Zagoruyko & Komodakis, 2016), text (Conneau et al., 2016; Devlin et al., 2018; Lai et al., 2015) and audio (van den Oord et al., 2016; Amodei et al., 2015; Chiu et al., 2018), yielding many important artificial intelligence use cases. For these data types, a major enabler of the rapid research and development progress is the availability of canonical neural network architectures to efficiently encode the raw data into meaningful representations. Integrated with simple decision-making layers, these canonical architectures yield high performance on new datasets and related tasks with small extra tuning effort. For example, consider the image understanding task – variants of convolutional layers with residual connections, e.g. the notable ResNet (He et al., 2015) architecture, can yield reasonably good performance on a new image dataset (e.g. in medical imaging) or a slightly different visual recognition problem (e.g. segmentation).
+
+Our focus in this paper is tabular (structured) data. Tabular data is indeed the most common data type in the entire addressable artificial intelligent market (Chui et al., 2018). Yet, canonical neural network architectures for tabular data understanding have been under-explored. Instead, variants of ensemble decision trees still dominate data science competitions with tabular data (Kaggle, 2019b). A primary reason for the popularity of tree-based approaches is their representation power for decision manifolds with approximately hyperplane boundaries that are commonly observed for tabular data. In addition, decision tree-based approaches are easy to develop and fast to train. They are highly-interpretable in their basic form (e.g. by tracking decision nodes and edges) and various interpretability techniques have been shown to be effective for their ensemble form, e.g. (Lundberg et al., 2018). On the other hand, conventional neural network architectures based on stacked convolutional or multilayer perceptrons, may not be the best fit for tabular data decision manifolds due to being vastly overparametrized – the lack of appropriate inductive bias often causes them to fail to find robust solutions for tabular decision manifolds (Goodfellow et al., 2016). We argue here that neural network architectures for tabular data should be redesigned to account for a ‘decision-tree-like’ mapping.
+
+Given the aforementioned benefits and reasonable performances of tree-based methods, why is deep learning worth exploring for tabular data? One obvious motivation is pushing the performance albeit an increased computational cost, especially with more training data. In addition, introduction of a high-performance deep neural network architecture unlocks the benefits of gradient descent-based end-to-end deep learning for tabular data. For example, decision tree learning (even with gradient boosting) does not utilize back-propagation into their inputs to use an error signal to guide efficient learning of complex data types. On the other hand, with a deep neural network architecture, complex data types like images can be integrated into tabular data efficiently. Another well-known challenge for tree-based methods is learning from streaming data. Most algorithms for tree learning need global statistical information to select split points and straightforward modifications such as (Ben-Haim & Tom-Tov, 2010) typically yield lower accuracy compared to learning from full data at once, yet deep neural networks show great potential for continual learning (Parisi et al., 2018). Lastly, deep learning models learn meaningful representations which enable new capabilities such as data-efficient domain adaptation (Goodfellow et al., 2016), generative modeling (e.g. using variational autoencoders or generative adversarial networks (Radford et al., 2015) or semi-supervised learning (Dai et al., 2017). As one example of these potential new capabilities, we demonstrate the potential of semi-supervised learning in the Appendix, showing the potential benefits of information extraction from unlabeled data which non-deep learning models are much weaker at.
+
+![](images/a38bf1082c0f764ee6cdc2a8597e35bbf79ac055bdd48e55db394312960f5b41.jpg)  
+Figure 1: Depiction of TabNet’s sparse feature selection for Adult Census Income prediction (Dua & Graff, 2017). TabNet employs multiple decision blocks that focus on processing a subset of input features for overall decision making. Two decision blocks shown as examples process the features that are professional occupation related and investment related in order to predict the income level.
+
+In this paper we propose TabNet, a deep neural network architecture to make a significant leap forward towards the optimal model design for tabular data learning. Motivated by the key problems for tabular data discussed above, the design of TabNet has two goals that are often not considered jointly: state-of-the-art performance and interpretability. With decision tree motivations, TabNet brings sparsity-controlled soft feature selection, but individually for each instance. Unlike other instance-wise feature selection methods like (Chen et al., 2018) or (Yoon et al., 2019), TabNet employs a single deep learning architecture with end-to-end learning, to map the raw data to the final decision with soft feature selection. The key aspects and contributions of TabNet are:
+
+1. In order to learn flexible representations and enable flexible integration into end-to-end learning, unlike most tabular data methods, TabNet inputs raw tabular data without any feature preprocessing and is trained using conventional gradient descent-based optimization.
+
+2. To improve performance and interpretability, TabNet utilizes a sequential attention mechanism to choose which features to reason from at each decision step, as shown in Fig. 1. We design this feature selection to be instance-wise such that the model can decide which features to focus on separately for each input – e.g., for income classification capital gain may be a more important feature to focus on for a middle-aged individual. Explicit selection of sparse features enables interpretability as well as more efficient learning as the model parameters are fully utilized for the most salient features at the corresponding decision step.
+
+3. Overall, our careful architecture design leads to two valuable properties for real world tabular learning problems: (1) TabNet outperforms other tabular learning models on various datasets for classification and regression problems from different domains, particularly those which are not saturated in performance; and (2) TabNet enables two kinds of interpretability: local interpretability that visualizes the importance of input features and how they are combined, and global interpretability that quantifies the amount of contribution of each input feature to the trained model.
+
+# 2 RELATED WORK
+
+Feature selection: Feature selection in machine learning broadly refers to the techniques for judicious selection of a subset of features that are useful to build a good predictor for a specified response variable. Commonly-used feature selection techniques such as forward feature selection and LASSO regularization (Guyon & Elisseeff, 2003) attribute importance to the features based on the entire training data set, and are referred as global methods. On the other hand, instance-wise feature selection refers to selection of the most important features, individually and differently for each input. Instance-wise feature selection was studied in (Chen et al., 2018) by training an explainer model to maximize the mutual information between the selected features and the response variable, and in (Yoon et al., 2019) by using an actor-critic framework to mimic a baseline model while optimizing the feature selection. (Ma et al., 2018) uses partial variational autoencoder to dynamically decide which piece of information to acquire next sequentially, that can be adapted for instance-wise feature selection. Unlike these approaches, our proposed method employs soft feature selection with controllable sparsity in end-to-end learning – a single model jointly performs feature selection and output mapping, enabled by the specific design of the architecture. Thus, we demonstrate superior performance with very compact representations.
+
+Tree-based learning: Tree-based models are the most common machine learning approaches for tabular data learning. The prominent strength of tree-based models is their efficacy in picking global features with the most statistical information gain (Grabczewski & Jankowski, 2005). To improve the performance of standard tree-based models by reducing the model variance, one common approach is ensembling. Among ensembling methods, random forests (Ho, 1998) use random subsets of data with randomly selected features to grow many trees. XGBoost (Chen & Guestrin, 2016) and LightGBM (Ke et al., 2017) are the two recent ensemble decision tree approaches that dominate most of the recent data science competitions. They are based on learning the structures of trees at first, and then updating the leaves with the streaming data.
+
+Integration of neural networks into decision trees: One direction to address the limitations of decision trees is integration of neural networks. Representing decision trees with canonical neural network building blocks, as in (Humbird et al., 2018), yields redundancy in representation and inefficient learning. Soft (neural) decision trees (Wang et al., 2017; Kontschieder et al., 2015) are proposed with differentiable decision functions, instead of non-differentiable axis aligned splits to construct trees. Yet, abandoning axis-aligned splits loses the automatic feature selection ability, which is important for learning from tabular data. In (Yang et al., 2018), a soft binning function is proposed to simulate decision trees in neural networks, which needs to enumerate all possible decisions and is inefficient. In (Ke et al., 2019), a novel neural network architecture is proposed, with the motivations of explicitly leveraging expressive feature combinations and reducing model complexity. However, learning is based on transferring knowledge from a gradient boosted decision tree. Thus, it yields very limited performance improvement compared to it, and interpretability was not considered. In (Tanno et al., 2018), a deep learning framework is proposed based on adaptively growing the architecture from primitive blocks while representation learning into edges, routing functions and leaf nodes of a decision tree. Our proposed model TabNet differs from these methods as it embeds the soft feature selection ability into a sequential attention-based network architecture, with controllable sparsity.
+
+Attentive table-to-text models: Table-to-text models extract textual information from tabular data. Recent works (Liu et al., 2017) (Bao et al., 2019) propose an architecture based on sequential mechanism for field-level attention. Despite the high-level similarities in the architecture, TabNet aims to perform the ultimate classification or regression task considering the entire input features, rather than mapping them to a different data type.
+
+# 3 TABNET MODEL
+
+# 3.1 PRINCIPLES
+
+We initially consider the implementation of a decision tree-like output manifold using conventional neural network building blocks (Fig. 2). Individual feature selection is the key idea to obtain decision boundaries in hyperplane form, which can be generalized for linear combination of features where constituent coefficients determine the proportion of each feature in the decision boundary. We aim to generalize this type of tree-like functionality by:
+
+• Utilizing sparse instance-wise feature selection, learned based on the training dataset.   
+• Constructing a sequential multi-step architecture, where each decision step can contribute to a portion of the decision that is based on the selected features.   
+• Improving the model capacity by non-linear processing of the selected features.   
+• Ensembling via higher feature dimension and more decision steps.
+
+# 3.2 OVERALL ARCHITECTURE
+
+Fig. 3 depicts the TabNet architecture. Tabular data inputs are comprised of numerical and categorical features. We use the raw numerical features and we consider mapping of categorical features with trainable embeddings1. We do not consider any global normalization of features, but merely apply batch normalization. We pass the same $D$ -dimensional features $\mathbf { f } \in \mathfrak { R } ^ { B \times D }$ to each decision step, where $B$ is the batch size. TabNet is based on sequential multi-step processing, with $N _ { s t e p s }$ decision steps. The $i ^ { t h }$ step inputs the processed information from the $( i - 1 ) ^ { t h }$ step to decide which features to use and outputs the processed feature representation to be aggregated into the overall decision. The idea of top-down attention in sequential form is inspired from its applications in processing visual and language data such as for visual question answering (Hudson & Manning, 2018) or in reinforcement learning (Mott et al., 2019) while searching for a small subset of relevant information in high dimensional input. Ablation studies in Appendix focus on the impact of various TabNet design choices, explained next. Overall, the performance is not too sensetitive to most hyperparameters, and guidelines on selection of the important hyperparameters are also provided in Appendix.
+
+![](images/74b5f1763ad18e3f9e35311b43e7e4e6ab18f1444d1175e37191cdc6affd5c3a.jpg)  
+Figure 2: Illustration of decision tree-like classification using conventional neural network blocksSplit and the corresponding two-dimensional manifold ( $x _ { 1 }$ and $x _ { 2 }$ are the input dimensions, and $a$ and $d$ are constants). By employing multiplicative sparse masks to inputs, the relevant features are selected.Feature  Feature The selected features are linearly transformed and after a bias addition (to represent boundaries),transformer ReLU function performs region selection by zeroing the regions that are on the negative side of theMask Attentive boundary. Aggregation of multiple regions is based on the addition operation. As $C _ { 1 }$ and $C _ { 2 }$ get larger, the decision boundary gets sharper due to the softmax.
+
+![](images/309803243de507ee064bc9e9c2b0b030f4fc3956e4db9be07030c09d8b8c9fbb.jpg)  
+Figure 3: (a) TabNet architecture, composed of feature transformer, attentive transformer and feature masking at each decision step. Split block divides the processed representation into two, to be Attentive used at the attentive transformer of the subsequent step and to be used towards construction of the overall output. At each decision step, its feature selection mask can provide insights about its Prior scales +functionality, and the masks can be aggregated (using the Agg. block) ultimately to obtain global feature important attribution behavior. (b) A feature transformer block example – 4-layer network is shown, where 2 of them are shared across all decision steps and 2 of them are decision step-dependent. Each layer is composed of a fully-connected layer, batch normalization and GLU nonlinearity. (c) An attentive transformer block example – a single layer mapping is modulated with a prior scale information, which aggregates how much each feature has been used before the current decision step. Normalization of the coefficients is employed using sparsemax (Martins & Astudillo, 2016) for sparse selection of the most salient features at each decision step.
+
+Feature selection: We employ a learnable sparse mask $\mathbf { M } [ \mathbf { i } ] \in \Re ^ { B \times D }$ for soft selection of the salient features. Through sparse selection of the most salient features, the learning capacity of a decision step is not wasted on irrelevant features, and thus the model becomes more parameter efficient. The masking is in multiplicative form, $\mathbf { M } [ \mathbf { i } ] \cdot \mathbf { f }$ . We use an attentive transformer (see Fig. 3) to obtain the masks using the processed features from the preceding step, ${ \bf a } [ { \bf i } - { \bf 1 } ]$ :
+
+$$
+\mathbf { M } [ \mathbf { i } ] = \mathrm { s p a r s e m a x } ( \mathbf { P } [ \mathbf { i } - \mathbf { 1 } ] \cdot \mathrm { h } _ { i } ( \mathbf { a } [ \mathbf { i } - \mathbf { 1 } ] ) ) .
+$$
+
+Sparsemax normalization (Martins & Astudillo, 2016) encourages sparsity by mapping the Euclidean projection onto the probabilistic simplex, which is observed to be superior in performance and aligned with the goal of sparse feature selection for most real-world datasets. Note that Eq. 1 has the normalization property, $\begin{array} { r } { \sum _ { j = 1 } ^ { D } \mathbf { M } [ \mathbf { i } ] _ { \mathbf { b } , \mathbf { j } } = 1 } \end{array}$ . $\mathrm { h } _ { i }$ is a trainable function, shown in Fig. 3 using a fully-connected layer, followed by batch normalization. $\mathbf { P } [ \mathbf { i } ]$ is the prior scale term, denoting how much a particular feature has been used previously:
+
+$$
+\mathbf { P } [ \mathbf { i } ] = \prod _ { j = 1 } ^ { i } ( \gamma - \mathbf { M } [ \mathbf { j } ] ) ,
+$$
+
+where $\gamma$ is a relaxation parameter – when $\gamma = 1$ , a feature is enforced to be used only at one decision step and as $\gamma$ increases, more flexibility is provided to use a feature at multiple decision steps. $\mathbf { P } [ \mathbf { 0 } ]$ is initialized as all ones. To further control the sparsity of the selected features, we propose sparsity regularization in the form of entropy (Grandvalet $\&$ Bengio, 2004):
+
+$$
+{ \cal L } _ { s p a r s e } = - \frac { 1 } { N _ { s t e p s } \cdot B } \sum _ { i = 1 } ^ { N _ { s t e p s } } \sum _ { b = 1 } ^ { B } \sum _ { j = 1 } ^ { D } { \bf M _ { b , j } [ i ] } \log ( { \bf M _ { b , j } [ i ] } + \epsilon ) ,
+$$
+
+where $\epsilon$ is a small number for numerical stability. We add the sparsity regularization to the overall loss, with a coefficient $\lambda _ { s p a r s e }$ . Sparsity may provide a favorable inductive bias for convergence to higher accuracy for some datasets where most of the input features are redundant.
+
+Feature processing: We process the filtered features using a feature transformer (see Fig. 3) to obtain the features that are split for the decision step output and information for the subsequent step:
+
+$$
+[ \mathbf { d } [ \mathbf { i } ] , \mathbf { a } [ \mathbf { i } ] ] = \mathbf { f } _ { i } ( \mathbf { M } [ \mathbf { i } ] \cdot \mathbf { f } ) ,
+$$
+
+where $\mathbf { d } [ \mathbf { i } ] \in \Re ^ { B \times N _ { d } }$ and $\mathbf { a } [ \mathbf { i } ] \in \Re ^ { B \times N _ { a } }$ . For parameter-efficient learning and efficient convergence with the high model capacity, a feature transformer should comprise layers that are shared across all decision steps (as the same features are input across different decision steps), as well as decision step-dependent layers. In Fig. 3, we show the implementation of a block as concatenation of two shared layers and two decision step-dependent layers. Each fully-connected layer is followed by batch normalization and gated linear unit (GLU) nonlinearity (Dauphin et al., 2016) 2, eventually√ connected to a normalized residual connection with normalization. Normalization with $\sqrt { 0 . 5 }$ helps to stabilize learning by ensuring that the variance throughout the network does not change dramatically, as discussed in (Gehring et al., 2017). For faster training, we aim for very large batch sizes in practice. To improve performance with large batch sizes, all batch normalization operations, except the one applied to the input features, are implemented in ghost batch normalization (Hoffer et al., 2017) form, with a virtual batch size $B _ { V }$ and momentum $m _ { B }$ . For the input features, we observe the benefit of low-variance averaging and hence avoid ghost batch normalization. After the last layer, we split the processed representation into $\mathbf { d } [ \mathbf { i } ]$ and a[i]. Inspired by decision-tree like aggregation as in Fig. 2, we construct the overall decision embedding as:
+
+$$
+\mathbf { d _ { o u t } } = \sum _ { i = 1 } ^ { N _ { s t e p s } } \mathrm { R e L U } ( \mathbf { d [ i ] } ) .
+$$
+
+Finally, we apply a linear mapping $\mathbf { W _ { f i n a l } d _ { o u t } }$ , for the final decision. When discrete outputs are required, we additionally employ a softmax function during training (and argmax during inference).
+
+# 4 EXPERIMENTS
+
+We evaluate the performance of TabNet in wide range of problems, that contain regression or classification tasks. We specifically focus on tabular datasets with published benchmarks, based on notable tree-based and neural network-based approaches.
+
+For all datasets, categorical inputs are mapped to a single-dimensional trainable scalar with a learnable embedding3 and numerical columns are input without and preprocessing.4 We use standard classification (softmax cross entropy) and regression (mean squared error) loss functions and we train until convergence. Hyperparameters of the TabNet models are optimized on a validation set and listed in Appendix. TabNet performance is not very sensitive to most hyperparameters as shown with ablation studies in Appendix. In all of the experiments where we cite results from other papers, we use the same training, validation and testing data split with the original work. Adam optimization algorithm (Kingma & Ba, 2014) and Glorot uniform initialization are used for training of all models.
+
+# 4.1 PERFORMANCE
+
+Comparison to methods that integrate explicit feature selection. For this comparison, we consider the 6 synthetic tabular datasets from (Chen et al., 2018). As the datasets are small (10k training samples), efficient feature selection is crucial for high performance in this task. The synthetic datasets are constructed in such a way that only a subset of the features determine the output. For Syn1, Syn2 and Syn3 datasets, the ‘salient’ features are the same for all instances, so that an accurate global feature selection mechanism should be optimal. E.g., the ground truth output of the Syn2 dataset only depends on features $X _ { 3 ^ { - } } X _ { 6 }$ . For Syn4, Syn5 and Syn6 datasets, the salient features are instance dependent. E.g., for Syn4 dataset, $X _ { 1 1 }$ is the indicator, and the ground truth output depends on either $X _ { 1 } – X _ { 2 }$ or $X _ { 3 ^ { - } } X _ { 6 }$ depending on the value of $X _ { 1 1 }$ . This instance dependence makes global feature selection suboptimal, as the globally-salient features would be redundant for some instances.
+
+Table 1: TabNet achieves high performance with small number of network parameters. Mean and std. of test area under the receiving operating characteristic curve (AUC) on 6 synthetic datasets from (Chen et al., 2018), for TabNet vs. other feature selection-based neural network models: No sel.: using all input features without any feature selection, Global: using only globally-salient features, Tree refers to Tree Ensembles (Geurts et al., 2006), LASSO: LASSO-regularized model, L2X (Chen et al., 2018) and INVASE (Yoon et al., 2019) are instance-wise feature selection frameworks. Bold numbers are the best method for each dataset.   
+
+<table><tr><td rowspan=1 colspan=1>Model</td><td rowspan=1 colspan=1>Syn1</td><td rowspan=1 colspan=1>Syn2</td><td rowspan=1 colspan=1>Syn3</td><td rowspan=1 colspan=1>Syn4</td><td rowspan=1 colspan=1>Syn5</td><td rowspan=1 colspan=1>Syn6</td></tr><tr><td rowspan=1 colspan=1>No sel.</td><td rowspan=1 colspan=1>.578± .004</td><td rowspan=1 colspan=1>.789±.003</td><td rowspan=1 colspan=1>.854 ± .004</td><td rowspan=1 colspan=1>.558 ± .021</td><td rowspan=1 colspan=1>.662 ± .013</td><td rowspan=1 colspan=1>.692 ± .015</td></tr><tr><td rowspan=1 colspan=1>Tree</td><td rowspan=1 colspan=1>.574 ± .101</td><td rowspan=1 colspan=1>.872 ± .003</td><td rowspan=1 colspan=1>.899± .001</td><td rowspan=1 colspan=1>.684 ± .017</td><td rowspan=1 colspan=1>.741 ± .004</td><td rowspan=1 colspan=1>.771 ± .031</td></tr><tr><td rowspan=1 colspan=1>Lasso</td><td rowspan=1 colspan=1>.498 ± .006</td><td rowspan=1 colspan=1>.555± .061</td><td rowspan=1 colspan=1>.886± .003</td><td rowspan=1 colspan=1>.512 ± .031</td><td rowspan=1 colspan=1>.691 ± .024</td><td rowspan=1 colspan=1>.727 ± .025</td></tr><tr><td rowspan=1 colspan=1>L2X</td><td rowspan=1 colspan=1>.498 ± .005</td><td rowspan=1 colspan=1>.823 ± .029</td><td rowspan=1 colspan=1>.862 ± .009</td><td rowspan=1 colspan=1>.678 ± .024</td><td rowspan=1 colspan=1>.709 ± .008</td><td rowspan=1 colspan=1>.827 ± .017</td></tr><tr><td rowspan=1 colspan=1>INVASE</td><td rowspan=1 colspan=1>.690 ± .006</td><td rowspan=1 colspan=1>.877 ± .003</td><td rowspan=1 colspan=1>.902 ± .003</td><td rowspan=1 colspan=1>.787 ± .004</td><td rowspan=1 colspan=1>.784 ± .005</td><td rowspan=1 colspan=1>.877 ± .003</td></tr><tr><td rowspan=1 colspan=1>Global</td><td rowspan=1 colspan=1>.686 ± .005</td><td rowspan=1 colspan=1>.873 ± .003</td><td rowspan=1 colspan=1>.900 ± .003</td><td rowspan=1 colspan=1>.774 ± .006</td><td rowspan=1 colspan=1>.784 ± .005</td><td rowspan=1 colspan=1>.858 ± .004</td></tr><tr><td rowspan=1 colspan=1>TabNet</td><td rowspan=1 colspan=1>.682 ± .005</td><td rowspan=1 colspan=1>.892 ± .004</td><td rowspan=1 colspan=1>.897 ± .003</td><td rowspan=1 colspan=1>.776 ± .017</td><td rowspan=1 colspan=1>.789 ± .009</td><td rowspan=1 colspan=1>.878 ± .004</td></tr></table>
+
+Table 1 shows the performance of TabNet vs. other techniques, including no selection, using only globally-salient features, Tree Ensembles (Geurts et al., 2006), LASSO regularization, L2X (Chen et al., 2018) and INVASE (Yoon et al., 2019). We observe that TabNet outperforms all other methods and is on par with INVASE. For Syn1, Syn2 and Syn3 datasets, we observe that the TabNet performance is very close to global feature selection. For Syn4, Syn5 and Syn6 datasets, we observe that TabNet improves global feature selection, which would contain redundant features. (Feature selection is visualized in Sec. 4.2.) All other methods utilize a predictive model with $4 3 \mathrm { k }$ parameters, and the total number of trainable parameters is 101k for INVASE due to the two other networks in the actor-critic framework. On the other hand, TabNet is a single neural network architecture, and the total number of parameters is 26k for Syn1-Syn3 datasets and 31k for Syn4-Syn6 datasets. This compact end-to-end representation is one of TabNet’s valuable properties.
+
+Comparison to models that do not employ explicit feature selection. We compare TabNet to high-performance tabular data learning models that are demonstrated on the following problems:
+
+• Forest cover type (Dua & Graff, 2017): Classification of forest cover type from cartographic variables.   
+• Poker hand (Dua & Graff, 2017): Classification of the poker hand from the raw input features of suit and rank attributes of the cards.   
+• Sarcos robotics arm inverse dynamics (Vijayakumar & Schaal, 2000): Regression for inverse dynamics of seven degrees-of-freedom of an anthropomorphic robot arm.   
+• Higgs boson (Baldi et al., 2014): Distinguishing between a signal process which produces Higgs bosons and a background process which does not.
+
+Table 2: Performance for forest cover type dataset. The performance of the comparison models∗ are from (Mitchell et al., 2018). AutoInt models pairwise feature interactions with an attention-base deep neural network (Song et al., 2018). AutoML Tables (denoted as $\star \star$ ) is an automated machine learning development tool based on ensemble of models including linear feed-forward deep neural network, gradient boosted decision tree, AdaNet (Cortes et al., 2016) and ensembles (AutoML, 2019). For AutoML Tables $( ^ { \star \star } )$ , the amount of node hours reflects the measure of the count of searched models for the ensemble and their complexity.6 A single TabNet model, without fine-grained hyperparameter search, can outperform the accuracy of ensemble models with very thorough hyperparameter search.
+
+<table><tr><td rowspan=1 colspan=1>Model</td><td rowspan=1 colspan=1>Test accuracy (%)</td></tr><tr><td rowspan=1 colspan=1>XGBoost*</td><td rowspan=1 colspan=1>89.34*</td></tr><tr><td rowspan=1 colspan=1>LightGBM*</td><td rowspan=1 colspan=1>89.28*</td></tr><tr><td rowspan=1 colspan=1>CatBoost*</td><td rowspan=1 colspan=1>85.14*</td></tr><tr><td rowspan=1 colspan=1>AutoInt</td><td rowspan=1 colspan=1>90.24*</td></tr><tr><td rowspan=1 colspan=1>AutoML Tables (2 node hours)**</td><td rowspan=1 colspan=1>94.56**</td></tr><tr><td rowspan=1 colspan=1>AutoML Tables (5 node hours)**</td><td rowspan=1 colspan=1>94.95**</td></tr><tr><td rowspan=1 colspan=1>AutoML Tables (10 node hours)**</td><td rowspan=1 colspan=1>96.67**</td></tr><tr><td rowspan=1 colspan=1>AutoML Tables (30 node hours)**</td><td rowspan=1 colspan=1>96.93**</td></tr><tr><td rowspan=1 colspan=1>TabNet</td><td rowspan=1 colspan=1>96.99</td></tr></table>
+
+Table 3: Performance for poker hand induction dataset. The input-output relationship is deterministic and hand-crafted rules implemented with several lines of code can get $100 \%$ accuracy. Yet, neural networks and decision tree models severely suffer from the imbalanced data and cannot learn the required sorting and ranking operations with the raw input features. The results for comparison models∗ are from (Yang et al., 2018).   
+
+<table><tr><td rowspan=1 colspan=1>Model</td><td rowspan=1 colspan=1>Test accuracy (%)</td></tr><tr><td rowspan=1 colspan=1>Decision tree*</td><td rowspan=1 colspan=1>50.0*</td></tr><tr><td rowspan=1 colspan=1>Multi layer perceptron*</td><td rowspan=1 colspan=1>50.0*</td></tr><tr><td rowspan=1 colspan=1>Deep neural decision tree*</td><td rowspan=1 colspan=1>65.1*</td></tr><tr><td rowspan=1 colspan=1>XGBoost</td><td rowspan=1 colspan=1>71.1</td></tr><tr><td rowspan=1 colspan=1>LightGBM</td><td rowspan=1 colspan=1>70.0</td></tr><tr><td rowspan=1 colspan=1>CatBoost</td><td rowspan=1 colspan=1>66.6</td></tr><tr><td rowspan=1 colspan=1>TabNet</td><td rowspan=1 colspan=1>99.3</td></tr><tr><td rowspan=1 colspan=1>Rule-based</td><td rowspan=1 colspan=1>100.0</td></tr></table>
+
+Tables 2-5 show the performance comparisons. We observe that TabNet outperforms multi-layer perceptrons and the variants of ensemble decision trees on all four datasets. TabNet allocates the learning capacity to salient features, and it yields a more compact model in terms of the number of parameters. When the model size is constrained, we observe the superior performance of TabNet even compared to the decision tree variants. The performance is only slightly worse than the evolutionary sparsification algorithms (Mocanu et al., 2018). Yet, the sparsity learned in TabNet is structured unlike the alternative approaches – i.e. it does not degrade the operational intensity of the model (Wen et al., 2016) and can efficiently utilize modern multi-core processors. Also note that we do not consider any matrix sparsification techniques such as adaptive pruning (Narang et al., 2017) which could further improve the parameter-efficiency.
+
+Table 4: Performance for Sarcos robotics arm inverse dynamics dataset. Three TabNet models of different sizes are considered (denoted with -S, -M and -L). The performance of the comparison models∗ are from (Tanno et al., 2018).   
+
+<table><tr><td rowspan=1 colspan=1>Model</td><td rowspan=1 colspan=1>Test MSE</td><td rowspan=1 colspan=1>Numberof parameters</td></tr><tr><td rowspan=1 colspan=1>Random forest*</td><td rowspan=1 colspan=1>2.39*</td><td rowspan=1 colspan=1>16.7K</td></tr><tr><td rowspan=1 colspan=1>Stochastic decision tree*</td><td rowspan=1 colspan=1>2.11*</td><td rowspan=1 colspan=1>28K</td></tr><tr><td rowspan=1 colspan=1>Multi layer perceptron*</td><td rowspan=1 colspan=1>2.13*</td><td rowspan=1 colspan=1>0.14M</td></tr><tr><td rowspan=1 colspan=1>Adaptive neural tree ensemble*</td><td rowspan=1 colspan=1>1.23*</td><td rowspan=1 colspan=1>0.60M</td></tr><tr><td rowspan=1 colspan=1>Gradientboosted tree*</td><td rowspan=1 colspan=1>1.44*</td><td rowspan=1 colspan=1>0.99M</td></tr><tr><td rowspan=1 colspan=1>TabNet-S</td><td rowspan=1 colspan=1>1.25</td><td rowspan=1 colspan=1>6.3K</td></tr><tr><td rowspan=1 colspan=1>TabNet-M</td><td rowspan=1 colspan=1>0.28</td><td rowspan=1 colspan=1>0.59M</td></tr><tr><td rowspan=1 colspan=1>TabNet-L</td><td rowspan=1 colspan=1>0.14</td><td rowspan=1 colspan=1>1.75M</td></tr></table>
+
+Table 5: Performance on Higgs boson dataset. Two TabNet models of different sizes are considered (denoted with -S and -M). The performance of the comparison models∗ are from (Mocanu et al., 2018). Sparse evolutionary training applies non-structured sparsity integrated into training, yielding low number of parameters. With its compact representation, TabNet, (without any further pruning or extra non-structured sparsity), yields almost similar performance with sparse evolutionary training for the same number of parameters. Gradient boosted tree models are implemented using (Tensorflow, 2019), see Appendix for details.   
+
+<table><tr><td rowspan=1 colspan=1>Model</td><td rowspan=1 colspan=1>Test accuracy (%)</td><td rowspan=1 colspan=1>Number of parameters</td></tr><tr><td rowspan=1 colspan=1>Sparse evolutionary trained multi layer perceptron*</td><td rowspan=1 colspan=1>78.47*</td><td rowspan=1 colspan=1>81K</td></tr><tr><td rowspan=1 colspan=1>Gradient boosted tree-S</td><td rowspan=1 colspan=1>74.22</td><td rowspan=1 colspan=1>0.12M</td></tr><tr><td rowspan=1 colspan=1>Gradient boosted tree-M</td><td rowspan=1 colspan=1>75.97</td><td rowspan=1 colspan=1>0.69M</td></tr><tr><td rowspan=1 colspan=1>Multi-layer perceptron*</td><td rowspan=1 colspan=1>78.44*</td><td rowspan=1 colspan=1>2.04M</td></tr><tr><td rowspan=1 colspan=1>Gradient boosted tree-L</td><td rowspan=1 colspan=1>76.98</td><td rowspan=1 colspan=1>6.96M</td></tr><tr><td rowspan=1 colspan=1>TabNet-S</td><td rowspan=1 colspan=1>78.25</td><td rowspan=1 colspan=1>81K</td></tr><tr><td rowspan=1 colspan=1>TabNet-M</td><td rowspan=1 colspan=1>78.84</td><td rowspan=1 colspan=1>0.66M</td></tr></table>
+
+# 4.2 INTERPRETABILITY
+
+The feature selection masks in TabNet can be used to build insights on selected features at each step. Such capability would not be possible for conventional neural networks with fully-connected layers, as each subsequent layer hidden units would jointly process all features without sparsity-controlled selection mechanism. For feature selection masks, if $\mathbf { \bar { M } _ { b , j } } [ \mathbf { i } ] = 0$ , then $j ^ { t h }$ feature of the $b ^ { t h }$ sample should have 0 contribution to the overall decision. If $\mathrm { f } _ { i }$ were a linear function, the coefficient $\mathbf { M _ { b , j } [ i ] }$ would correspond to the feature importance of $\mathbf { f _ { b , j } }$ . Although each decision step employs non-linear processing, their outputs are combined later in a linear way. Our goal is to quantify an aggregate feature importance beyond analysis of each step as well. Combination of the masks at different decisioWe use $\begin{array} { r } { \eta _ { \mathbf { b } } [ \bar { \mathbf { i } } ] = \bar { \sum } _ { c = 1 } ^ { N _ { d } } \mathrm { R e L U } ( \mathbf { d _ { b , c } } [ \bar { \mathbf { i } } ] ) } \end{array}$ t can weigh the relative importance of each step into denote the aggregate decision contribution at $i ^ { t h }$ decision.decision step for the $b ^ { t h }$ sample. Intuitively, $\mathbf { d } _ { \mathbf { b } , \mathbf { c } } [ \mathbf { i } ] < 0$ , then all features at decision step should have 0 contribution to the overall decision and as its value increases, it plays a higher role in the overall linear combination given in Eq. 5. Scaling the decision mask at each decision step with $\eta _ { \mathbf { b } } [ \mathbf { i } ]$ , we propose the aggregate feature importance mask as:
+
+$$
+\mathbf { M _ { a g g - b , j } } = \sum _ { i = 1 } ^ { N _ { s t e p s } } \eta _ { \mathbf { b } } [ \mathbf { i } ] \mathbf { M _ { b , j } } [ \mathbf { i } ] \bigg / \sum _ { j = 1 } ^ { D } \sum _ { i = 1 } ^ { N _ { s t e p s } } \eta _ { \mathbf { b } } [ \mathbf { i } ] \mathbf { M _ { b , j } } [ \mathbf { i } ] .
+$$
+
+Normalization is used to ensure $\begin{array} { r } { \sum _ { j = 1 } ^ { D } \mathbf { M _ { a g g - b , j } } = 1 } \end{array}$ for each sample.
+
+![](images/8d9602e68eac2096c80d01b7e5a551f93a319afcb9ccb345db988395abfe1bcf.jpg)  
+Figure 4: Feature importance masks $\mathbf { M } [ \mathbf { i } ]$ (that indicate which features are selected at $i ^ { t h }$ step) and the aggregate feature importance mask $\mathbf { M _ { a g g } }$ showing the global instance-wise feature selection for Syn2 and Syn3 datasets from (Chen et al., 2018). Brighter colors show a higher value. E.g. for Syn2 dataset, only four features $( X _ { 3 } – X _ { 6 } )$ are used.
+
+![](images/c2e1584da74a19b93ab8fe0b23eedaf24531398f14d86e175112358d26650d73.jpg)  
+Figure 5: Feature importance masks $\mathbf { M } [ \mathbf { i } ]$ (that indicate which features are selected at $i ^ { t h }$ step) and the aggregate feature importance mask $\mathbf { M _ { a g g } }$ showing the global instance-wise feature selection for Syn4 and Syn6 datasets from (Chen et al., 2018). Brighter colors show a higher value. E.g. for Syn4 dataset, the chosen features depend on the value of $X _ { 1 1 }$ .
+
+Figs. 4 and 5 show the aggregate feature importance masks for the synthetic datasets discussed in Sec. 4.1 (for better illustration here, unlike Sec. 4.1, the models are trained with 10M training samples rather than 10K as we obtain sharper feature selection masks). The ground truth output of the Syn2 dataset only depends on features $X _ { 3 ^ { - } } X _ { 6 }$ , and the ground truth output of the Syn3 dataset only depends on features $X _ { 7 }  – X _ { 1 0 }$ . We observe that the aggregate masks are almost all-zero for irrelevant features and they merely focus on relevant ones. For Syn4 dataset, $X _ { 1 1 }$ is the indicator, and the ground truth output depends on either $X _ { 1 } – X _ { 2 }$ or $X _ { 3 ^ { - } } X _ { 6 }$ depending on the value of $X _ { 1 1 }$ . For Syn6 dataset, $X _ { 1 1 }$ is the indicator, and the ground truth output depends on either $X _ { 3 ^ { - } } X _ { 6 }$ or $X _ { 7 }  – X _ { 1 0 }$ depending on the value of $X _ { 1 1 }$ . For both, TabNet yields accurate instance-wise feature selection – it uses majority of the weights in two masks to focus on $X _ { 1 1 }$ , and assigns almost all-zero weights to irrelevant features (the ones other than one of the two feature groups based on the value of $X _ { 1 1 , }$ ).
+
+![](images/56cbdd82d5b08d75ae439773f6040e4b1819e0a81d339579dde632ddfe7586e7.jpg)  
+Figure 6: (a) Comparison to previous work for the ratio of the feature importance of “Odor” feature to all the features of the top feature for the mushroom edibility prediction (Dua & Graff, 2017) (task: classify whether a mushroom is edible or poisonous). With “Odor” feature only, $> 9 8 . 5 \%$ test accuracy can be obtained, so a high feature importance is expected to be assigned to it, as observed with TabNet. (b) Comparison to previous work for importance ranking of features in the Adult Census Income dataset (Dua & Graff, 2017) (task: distinguish whether a person’s income is above $\$ 50,000$ . (c) Impact of the most important feature on the decision manifold. T-SNE of the decision manifold for Adult Census Income test samples and the impact of the most dominant feature ‘Age’.
+
+Fig. 6(a) shows the feature importance score of the top feature obtained with TabNet vs. other explainability techniques from (Ibrahim et al., 2019) for mushroom edibility prediction. Mushroom edibility is a simple pattern recognition problem - TabNet achieves $100 \%$ test accuracy. It is indeed known (Dua & Graff, 2017) that with “Odor” feature only, a model can get $> 9 8 . 5 \%$ test accuracy (Dua & Graff, 2017), so a high feature importance is expected for it, as observed with TabNet. Fig. 6(b) shows the importance ranking of features for TabNet vs. other explainability techniques from (Lundberg et al., 2018) (Nbviewer, 2019) for Adult Census Income prediction. TabNet achieves $8 5 . 7 \%$ test accuracy for this problem. We observe the commonality of the most important features (“Age”, “Capital gain/loss”, “Education number”, “Relationship”) and the least important features (“Native country”, “Race”, “Gender”, “Work class”). For the same problem, Fig. 6(c) shows the impact of the most important feature on the output decision by visualizing the T-SNE of the decision manifold. A clear separation between age groups is observed, underlining the importance of the “Age” feature, as suggested by its high value in the aggregate feature importance mask of TabNet.
+
+# 5 CONCLUSIONS
+
+We propose TabNet, a novel deep learning architecture for tabular learning. TabNet utilizes a sequential attention mechanism to choose a subset of semantically-meaningful features to process at each decision step. The selected features are processed to the representation, that contributes to the overall decision output and sends information to the next decision step. Instance-wise feature selection enables efficient learning as the model capacity is fully used for the most salient features, and also yields more interpretable decision making via visualization of selection masks. We demonstrate that TabNet outperforms previous work across tabular datasets from different domains.
+
+REFERENCES   
+Dario Amodei, Rishita Anubhai, Eric Battenberg, Carl Case, Jared Casper, et al. Deep speech 2: End-to-end speech recognition in english and mandarin. arXiv:1512.02595, 2015.   
+AutoML. AutoML Tables – Google Cloud, 2019. URL https://cloud.google.com/ automl-tables/.   
+P. Baldi, P. Sadowski, and D. Whiteson. Searching for exotic particles in high-energy physics with deep learning. Nature Commun., Jul 2014.   
+Pierre Baldi. Autoencoders, unsupervised learning, and deep architectures. In Proceedings of ICML Workshop on Unsupervised and Transfer Learning, volume 27 of Proceedings of Machine Learning Research, pp. 37–49, Bellevue, Washington, USA, 02 Jul 2012. PMLR.   
+J. Bao, D. Tang, N. Duan, Z. Yan, M. Zhou, and T. Zhao. Text generation from tables. IEEE/ACM Transactions on Audio, Speech, and Language Processing, 27(2):311–320, Feb 2019.   
+Yael Ben-Haim and Elad Tom-Tov. A streaming parallel decision tree algorithm. J. Mach. Learn. Res., 11:849–872, March 2010.   
+Catboost. Benchmarks. https://github.com/catboost/benchmarks, 2019. Accessed: 2019-11-10.   
+Jianbo Chen, Le Song, Martin J. Wainwright, and Michael I. Jordan. Learning to explain: An information-theoretic perspective on model interpretation. arXiv:1802.07814, 2018.   
+Tianqi Chen and Carlos Guestrin. XGboost: A scalable tree boosting system. In KDD, 2016.   
+C. Chiu, T. N. Sainath, Y. Wu, R. Prabhavalkar, P. Nguyen, et al. State-of-the-art speech recognition with sequence-to-sequence models. In ICASSP, April 2018.   
+Michael Chui, James Manyika, Mehdi Miremadi, Nicolaus Henke, Rita Chung, et al. Notes from the ai frontier. McKinsey Global Institute, 4 2018.   
+Alexis Conneau, Holger Schwenk, Lo¨ıc Barrault, and Yann LeCun. Very deep convolutional networks for natural language processing. arXiv:1606.01781, 2016.   
+Corinna Cortes, Xavi Gonzalvo, Vitaly Kuznetsov, Mehryar Mohri, and Scott Yang. Adanet: Adaptive structural learning of artificial neural networks. arXiv:1607.01097, 2016.   
+Zihang Dai, Zhilin Yang, Fan Yang, William W. Cohen, and Ruslan Salakhutdinov. Good semisupervised learning that requires a bad GAN. arxiv:1705.09783, 2017.   
+Yann N. Dauphin, Angela Fan, Michael Auli, and David Grangier. Language modeling with gated convolutional networks. arXiv:1612.08083, 2016.   
+Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. BERT: pre-training of deep bidirectional transformers for language understanding. arxiv:1810.04805, 2018.   
+Dheeru Dua and Casey Graff. UCI Machine Learning Repository, 2017. URL http://archive. ics.uci.edu/ml.   
+Jonas Gehring, Michael Auli, David Grangier, Denis Yarats, and Yann N. Dauphin. Convolutional sequence to sequence learning. arXiv:1705.03122, 2017.   
+Pierre Geurts, Damien Ernst, and Louis Wehenkel. Extremely randomized trees. Machine Learning, 63(1):3–42, Apr 2006. ISSN 1573-0565. doi: 10.1007/s10994-006-6226-1.   
+Ian Goodfellow, Yoshua Bengio, and Aaron Courville. Deep Learning. MIT Press, 2016.   
+K. Grabczewski and N. Jankowski. Feature selection with decision tree criterion. In HIS), Nov 2005.   
+Yves Grandvalet and Yoshua Bengio. Semi-supervised learning by entropy minimization. In NIPS 2004, 2004.   
+Isabelle Guyon and Andre Elisseeff. An introduction to variable and feature selection. ´ J. Mach. Learn. Res., 3:1157–1182, March 2003.   
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. arXiv:1512.03385, 2015.   
+Tin Kam Ho. The random subspace method for constructing decision forests. IEEE Trans. on PAMI, 20(8):832–844, Aug 1998.   
+Elad Hoffer, Itay Hubara, and Daniel Soudry. Train longer, generalize better: closing the generalization gap in large batch training of neural networks. arXiv:1705.08741, 2017.   
+Drew A. Hudson and Christopher D. Manning. Compositional attention networks for machine reasoning. arXiv:1803.03067, 2018.   
+K. D. Humbird, J. L. Peterson, and R. G. McClarren. Deep neural network initialization with decision trees. IEEE Transactions on Neural Networks and Learning Systems, 2018.   
+Mark Ibrahim, Melissa Louie, Ceena Modarres, and John W. Paisley. Global explanations of neural networks: Mapping the landscape of predictions. arXiv:1902.02384, 2019.   
+Kaggle. Rossmann store sales. https://www.kaggle.com/c/rossmann-store-sales, 2019a. Accessed: 2019-11-10.   
+Kaggle. Historical data science trends on Kaggle. https://www.kaggle.com/shivamb/ data-science-trends-on-kaggle, 2019b. Accessed: 2019-04-20.   
+Guolin Ke, Qi Meng, Thomas Finley, Taifeng Wang, Wei Chen, et al. Lightgbm: A highly efficient gradient boosting decision tree. In NIPS. 2017.   
+Guolin Ke, Jia Zhang, Zhenhui Xu, Jiang Bian, and Tie-Yan Liu. TabNN: A universal neural network solution for tabular data, 2019. URL https://openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ r1eJssCqY7.   
+Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In ICLR, 2014.   
+P. Kontschieder, M. Fiterau, A. Criminisi, and S. R. Bulo. Deep neural decision forests. In \` ICCV, 2015.   
+Siwei Lai, Liheng Xu, Kang Liu, and Jun Zhao. Recurrent convolutional neural networks for text classification. In AAAI, 2015.   
+Tianyu Liu, Kexiang Wang, Lei Sha, Baobao Chang, and Zhifang Sui. Table-to-text generation by structure-aware seq2seq learning. arXiv:1711.09724, 2017.   
+Scott M. Lundberg, Gabriel G. Erion, and Su-In Lee. Consistent individualized feature attribution for tree ensembles. arXiv:1802.03888, 2018.   
+Chao Ma, Sebastian Tschiatschek, Konstantina Palla, Jose Miguel Hern ´ andez-Lobato, Sebastian ´ Nowozin, and Cheng Zhang. EDDI: efficient dynamic discovery of high-value information with partial VAE. arXiv:1809.11142, 2018.   
+Freddie Mac. Loan level dataset. http://www.freddiemac.com/research/datasets/ sf_loanlevel_dataset.page, 2019. Accessed: 2019-3-10.   
+Andre F. T. Martins and Ram ´ on Fern ´ andez Astudillo. From softmax to sparsemax: A sparse model ´ of attention and multi-label classification. arXiv:1602.02068, 2016.   
+Rory Mitchell, Andrey Adinets, Thejaswi Rao, and Eibe Frank. Xgboost: Scalable GPU accelerated learning. arXiv:1806.11248, 2018.   
+Decebal Mocanu, Elena Mocanu, Peter Stone, Phuong Nguyen, Madeleine Gibescu, and Antonio Liotta. Scalable training of artificial neural networks with adaptive sparse connectivity inspired by network science. Nature Communications, 9, 12 2018.   
+Alex Mott, Daniel Zoran, Mike Chrzanowski, Daan Wierstra, and Danilo J. Rezende. S3TA: A soft, spatial, sequential, top-down attention model, 2019. URL https://openreview.net/ forum?id $_ { \cdot } =$ B1gJOoRcYQ.   
+Sharan Narang, Gregory F. Diamos, Shubho Sengupta, and Erich Elsen. Exploring sparsity in recurrent neural networks. arXiv:1704.05119, 2017.   
+Nbviewer. Notebook on Nbviewer, 2019. URL https://nbviewer.jupyter.org/ github/dipanjanS/data_science_for_all/blob/master/tds_model interpretation_xai/Human-interpretableMachineLearning-DS.ipynb#.   
+N. C. Oza. Online bagging and boosting. In 2005 IEEE International Conference on Systems, Man and Cybernetics, volume 3, pp. 2340–2345 Vol. 3, Oct 2005.   
+German Ignacio Parisi, Ronald Kemker, Jose L. Part, Christopher Kanan, and Stefan Wermter. Continual lifelong learning with neural networks: A review. arXiv:1802.07569, 2018.   
+Liudmila Prokhorenkova, Gleb Gusev, Aleksandr Vorobev, Anna Veronika Dorogush, and Andrey Gulin. Catboost: unbiased boosting with categorical features. In NIPS, pp. 6638–6648. 2018.   
+Alec Radford, Luke Metz, and Soumith Chintala. Unsupervised Representation Learning with Deep Convolutional Generative Adversarial Networks. arXiv:1511.06434, 2015.   
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv:1409.1556, 2014.   
+Weiping Song, Chence Shi, Zhiping Xiao, Zhijian Duan, Yewen Xu, Ming Zhang, and Jian Tang. Autoint: Automatic feature interaction learning via self-attentive neural networks. arxiv:1810.11921, 2018.   
+Ryutaro Tanno, Kai Arulkumaran, Daniel C. Alexander, Antonio Criminisi, and Aditya V. Nori. Adaptive neural trees. arXiv:1807.06699, 2018.   
+Tensorflow. Classifying higgs boson processes in the higgs data set, 2019. URL https://github. com/tensorflow/models/tree/master/official/boosted_trees.   
+Aaron van den Oord, Sander Dieleman, Heiga Zen, Karen Simonyan, Oriol Vinyals, et al. Wavenet: ¨ A generative model for raw audio. arXiv:1609.03499, 2016.   
+Sethu Vijayakumar and Stefan Schaal. Locally weighted projection regression: An o(n) algorithm for incremental real time learning in high dimensional space. In ICML, 2000.   
+Suhang Wang, Charu Aggarwal, and Huan Liu. Using a random forest to inspire a neural network and improving on it. In SDM, 2017.   
+Wei Wen, Chunpeng Wu, Yandan Wang, Yiran Chen, and Hai Li. Learning structured sparsity in deep neural networks. arXiv:1608.03665, 2016.   
+Yongxin Yang, Irene Garcia Morillo, and Timothy M. Hospedales. Deep neural decision trees. arXiv:1806.06988, 2018.   
+Jinsung Yoon, James Jordon, and Mihaela van der Schaar. INVASE: Instance-wise variable selection using neural networks. In ICLR, 2019.   
+Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. arXiv:1605.07146, 2016.   
+Hongyi Zhang, Moustapha Cisse, Yann N. Dauphin, and David Lopez-Paz. mixup: Beyond empirical ´ risk minimization. arXiv:1710.09412, 2017.
+
+# A SIMPLIFIED DIAGRAM FOR TABNET FEEDFORWARD PASS
+
+![](images/ffe96376bfcdd1c250e7f99010f1615fe4bb69a25fc3392c8ed50ef2e6755748.jpg)  
+Figure 7: Simplified diagram for TabNet feedforward pass for an input with 3 features, assuming $N _ { s t e p s } = 2$ . At the first step, the model selects only the first feature, and applies feature processing on it. At the second step, the model selects the last feature, and applies the feature processing on it. Lastly, the two outputs are combined for the final decision.
+
+# B ADDITIONAL RESULTS
+
+# B.1 RETAIL DATASET WITH TIME COMPONENT
+
+In this section, we show additional results on a real-world tabular data learning problem - Rossmann store sales forecasting (Kaggle, 2019a). This dataset has time-dependent features. Time information is input as day, month, and year columns. We observe that TabNet outperforms alternative methods that are commonly used for such problems.
+
+Table 6: Performance for Rossmann store sales dataset (Kaggle, 2019a). We use the exactly same preprocessing and data split with (Catboost, 2019) - data from 2014 is used for training and validation, whereas 2015 is used for testing. The performance of the comparison models∗ are from (Catboost, 2019).   
+
+<table><tr><td rowspan=1 colspan=1>Model</td><td rowspan=1 colspan=1>TestMSE</td></tr><tr><td rowspan=1 colspan=1>XGBoost*</td><td rowspan=1 colspan=1>490.83*</td></tr><tr><td rowspan=1 colspan=1>LightGBM*</td><td rowspan=1 colspan=1>504.76*</td></tr><tr><td rowspan=1 colspan=1>CatBoost*</td><td rowspan=1 colspan=1>489.75*</td></tr><tr><td rowspan=1 colspan=1>TabNet</td><td rowspan=1 colspan=1>485.12</td></tr></table>
+
+# B.2 KDD DATASETS
+
+Table 7: Performance on three KDD datasets on Customer Relationship Management: Appetency, Churn and Upselling. We apply the similar preprocessing and data partitioning as (Prokhorenkova et al., 2018). The performance of the comparison models∗ are from (Prokhorenkova et al., 2018).   
+
+<table><tr><td rowspan=1 colspan=1>Model</td><td rowspan=1 colspan=1>Appetency testaccuracy (%)</td><td rowspan=1 colspan=1>Churn testaccuracy (%)</td><td rowspan=1 colspan=1>Upselling testaccuracy (%)</td></tr><tr><td rowspan=1 colspan=1>XGBoost*</td><td rowspan=1 colspan=1>98.2*</td><td rowspan=1 colspan=1>92.7*</td><td rowspan=1 colspan=1>95.1*</td></tr><tr><td rowspan=1 colspan=1>CatBoost*</td><td rowspan=1 colspan=1>98.2*</td><td rowspan=1 colspan=1>92.8*</td><td rowspan=1 colspan=1>95.1*</td></tr><tr><td rowspan=1 colspan=1>TabNet</td><td rowspan=1 colspan=1>98.2</td><td rowspan=1 colspan=1>92.7</td><td rowspan=1 colspan=1>95.0</td></tr></table>
+
+We experiment TabNet on four KDD datasets: the three Customer Relationship Management and Census Income. These datasets show saturated behavior in achievable performance (even simple
+
+Table 8: Performance for KDD Census Income (Dua & Graff, 2017). The task is income prediction from demographic and employment related variables. The performance of the comparison models∗ are from (Oza, 2005).   
+
+<table><tr><td rowspan=1 colspan=1>Model</td><td rowspan=1 colspan=1>Test accuracy (%)</td></tr><tr><td rowspan=1 colspan=1>XGBoost</td><td rowspan=1 colspan=1>95.76</td></tr><tr><td rowspan=1 colspan=1>CatBoost</td><td rowspan=1 colspan=1>95.72</td></tr><tr><td rowspan=1 colspan=1>Multi-layer perceptron*</td><td rowspan=1 colspan=1>95.19</td></tr><tr><td rowspan=1 colspan=1>Boosting, Multi-layer perceptron*</td><td rowspan=1 colspan=1>94.86</td></tr><tr><td rowspan=1 colspan=1>Bagging, Multi-layer perceptron*</td><td rowspan=1 colspan=1>95.33</td></tr><tr><td rowspan=1 colspan=1>TabNet</td><td rowspan=1 colspan=1>95.49</td></tr></table>
+
+models yield similar results). For these cases, TabNet shows very similar (or slightly worse) performance than XGBoost and CatBoost, that are known to be very robust as they contain high amount of ensembles.
+
+# B.3 LOAN DELINQUENCY PREDICTION
+
+Table 9: Performance for loan delinquency prediction on a proprietary dataset, constructed from (Mac, 2019). The task is to classify loan delinquency status (among four categories), from many input features including personal information and financial status. The training dataset consists of $9 3 \mathrm { k }$ samples. The dataset is highly imbalanced as the delinquency situation is observed rarely.   
+
+<table><tr><td rowspan=1 colspan=1>Model</td><td rowspan=1 colspan=1>Testmean perclassaccuracy</td></tr><tr><td rowspan=1 colspan=1>XGBoost</td><td rowspan=1 colspan=1>0.55</td></tr><tr><td rowspan=1 colspan=1>H2OAutoML (with 15 models)</td><td rowspan=1 colspan=1>0.60</td></tr><tr><td rowspan=1 colspan=1>Multi-layer perceptron</td><td rowspan=1 colspan=1>0.46</td></tr><tr><td rowspan=1 colspan=1>TabNet</td><td rowspan=1 colspan=1>0.86</td></tr></table>
+
+We consider TabNet for a real-world problem in financial services industry: loan delinquency prediction. On a proprietary dataset, we demonstrate strong outperformance of TabNet, especially finding rare delinquency cases without any special techniques on anomaly detection.
+
+# C EXPERIMENT HYPERPARAMETERS
+
+For all datasets, we start hyperparameter tuning with a pre-defined value space. $N _ { d }$ and $N _ { a }$ are chosen from $\{ 8 , 1 6 , 2 4 , 3 2 , 6 4 , 1 2 8 \}$ , $N _ { s t e p s }$ is chosen from $\{ 3 , 4 , 5 , 6 , 7 , 8 , 9 , 1 0 \}$ , $\gamma$ is chosen from $\{ 1 . 0 , 1 . 2 , 1 . 5 , 2 . 0 \}$ , $\lambda _ { s p a r s e }$ is chosen from $\{ 0 , 0 . 0 0 0 0 0 1 , 0 . 0 0 0 1 , 0 . 0 0 1 , 0 . 0 1 , 0 . 1 \}$ , $B$ is chosen from {256, 512, 1024, 2048, 4096, 8192, 16384, 32768}, $B _ { V }$ is chosen from $\{ 2 5 6 , 5 1 2 , 1 0 2 4 , 2 0 4 8 , 4 0 9 6 \}$ and $m _ { B }$ is chosen from $\{ 0 . 6 , 0 . 7 , 0 . 8 , 0 . 9 , 0 . 9 5 , 0 . 9 8 \}$ . If the model size is not under the desired cutoff (e.g. for Table 5 comparisons), we decrease the value to satisfy the model size constraint.
+
+# C.1 SYNTHETIC DATASETS
+
+All TabNet models use $N _ { d } = N _ { a } = 1 6$ , $B = 3 0 0 0$ , $B _ { V } = 1 0 0$ , $m _ { B } = 0 . 7$ . For Syn1 we use $\lambda _ { s p a r s e } = 0 . 0 2$ , $N _ { s t e p s } = 4$ and $\gamma = 2 . 0$ ; for Syn2 and Syn3 we use $\lambda _ { s p a r s e } = 0 . 0 1$ , $N _ { s t e p s } = 4$ and $\gamma = 2 . 0$ ; and for Syn4, Syn5 and Syn6 we use $\lambda _ { s p a r s e } = 0 . 0 0 5$ , $N _ { s t e p s } = 5$ and $\gamma = 1 . 5$ . Each feature transformer block uses two shared and two decision step-dependent fully-connected layer, ghost batch normalization and GLU blocks. All models use Adam optimization a learning rate of 0.02 (decayed 0.7 every 200 iterations with an exponential decay) for $4 \mathrm { k \Omega }$ iterations.
+
+For visualizations in Section 4.2, we also train TabNet models with datasets of size 10M samples. For this case, we choose $N _ { d } = N _ { a } = 3 2$ , $\lambda _ { s p a r s e } = 0 . 0 0 1$ , $B = 1 0 0 0 0$ , $B _ { V } = 1 0 0$ , $m _ { B } = 0 . 9$ Adam optimization is used with a learning rate of 0.02 (decayed 0.9 every 2k iterations with an exponential decay) for 15k iterations. For Syn2 and Syn3, $N _ { s t e p s } = 4$ and $\gamma = 2$ . For Syn4 and Syn6, $N _ { s t e p s } = 5$ and $\gamma = 1 . 5$ .
+
+# C.2 FOREST COVER TYPE DATASET
+
+We use the exact same partitioning of the train, evaluation and test datasets with (Mitchell et al., 2018) for a fair comparison.
+
+TabNet model uses $N _ { d } = N _ { a } = 6 4$ , $\lambda _ { s p a r s e } = 0 . 0 0 0 1$ , $B = 1 6 3 8 4$ , $B _ { V } = 5 1 2$ , $m _ { B } = 0 . 7$ , $N _ { s t e p s } = 5$ and $\gamma = 1 . 5$ . Each feature transformer block uses two shared and two decision stepdependent fully-connected layer, ghost batch normalization and GLU blocks. Adam optimization is used with a learning rate of 0.02 (decayed 0.95 every $0 . 5 \mathrm { k }$ iterations with an exponential decay) for $1 3 0 \mathrm { k }$ iterations.
+
+# C.3 POKER HANDS DATASET
+
+TabNet uses $N _ { d } = 2 4$ , $N _ { a } = 8$ , $\lambda _ { s p a r s e } = 0 . 0 0 1$ , $B = 4 0 9 6$ , $B _ { V } = 2 5 6$ , $m _ { B } = 0 . 8$ , $N _ { s t e p s } = 4$ and $\gamma = 1 . 5$ . Each feature transformer block uses two shared and two decision step-dependent fully-connected layer, ghost batch normalization and GLU blocks. Adam optimization is used with a learning rate of 0.02 (decayed 0.9 every 10k iterations with an exponential decay) for 71k iterations.
+
+# C.4 SARCOS DATASET
+
+TabNet-S model uses $N _ { d } = N _ { a } = 8 .$ , $\lambda _ { s p a r s e } = 0 . 0 0 0 1$ , $B = 4 0 9 6$ , $B _ { V } = 2 5 6$ , $m _ { B } = 0 . 9$ , $N _ { s t e p s } = 3$ and $\gamma = 1 . 2$ . Each feature transformer block uses one shared and two decision stepdependent fully-connected layer, ghost batch normalization and GLU blocks. Adam optimization is used with a learning rate of 0.01 (decayed 0.95 every $^ { 8 \mathrm { k } }$ iterations with an exponential decay) for $6 0 0 \mathrm { k }$ iterations.
+
+TabNet-M model uses $N _ { d } = N _ { a } = 6 4$ , $\lambda _ { s p a r s e } = 0 . 0 0 0 1$ , $B = 4 0 9 6$ , $B _ { V } = 1 2 8$ , $m _ { B } = 0 . 8$ , $N _ { s t e p s } = 7$ and $\gamma = 1 . 5$ . Each feature transformer block uses two shared and two decision stepdependent fully-connected layer, ghost batch normalization and GLU blocks. Adam optimization is used with a learning rate of 0.01 (decayed 0.95 every 8k iterations with an exponential decay) for $6 0 0 \mathrm { k }$ iterations.
+
+The TabNet-L model uses $N _ { d } = N _ { a } = 1 2 8$ , $\lambda _ { s p a r s e } = 0 . 0 0 0 1$ , $B = 4 0 9 6$ , $B _ { V } = 1 2 8$ , $m _ { B } = 0 . 8$ , $N _ { s t e p s } = 5$ and $\gamma = 1 . 5$ . Each feature transformer block uses two shared and two decision stepdependent fully-connected layer, ghost batch normalization and GLU blocks. Adam optimization is used with a learning rate of 0.02 (decayed 0.9 every 8k iterations with an exponential decay) for $6 0 0 \mathrm { k }$ iterations.
+
+# C.5 HIGGS DATASET
+
+TabNet-S model uses $N _ { d } = 2 4$ , $N _ { a } = 2 6$ , $\lambda _ { s p a r s e } = 0 . 0 0 0 0 0 1$ , $B = 1 6 3 8 4$ , $B _ { V } = 5 1 2$ , $m _ { B } = 0 . 6$ , $N _ { s t e p s } = 5$ and $\gamma = 1 . 5$ . Each feature transformer block uses two shared and two decision stepdependent fully-connected layer, ghost batch normalization and GLU blocks. Adam optimization is used with a learning rate of 0.02 (decayed 0.9 every $2 0 \mathrm { k }$ iterations with an exponential decay) for 870k iterations.
+
+TabNet-M model uses $N _ { d } = 9 6$ , $N _ { a } = 3 2$ , $\lambda _ { s p a r s e } = 0 . 0 0 0 0 0 1$ , $B = 8 1 9 2$ , $B _ { V } = 2 5 6$ , $m _ { B } = 0 . 9$ , $N _ { s t e p s } = 8$ and $\gamma = 2 . 0$ . Each feature transformer block uses two shared and two decision stepdependent fully-connected layer, ghost batch normalization and GLU blocks. Adam optimization is used with a learning rate of 0.025 (decayed 0.9 every 10k iterations with an exponential decay) for $3 7 0 \mathrm { k }$ iterations.
+
+For gradient boosted trees, we use the implementation (Tensorflow, 2019). We choose the learning rate of 0.1 and optimize the maximum depth to 8, based on the performance. The Gradient boosted tree-S model uses 50 trees, the Gradient boosted tree-M model uses 300 trees and the Gradient boosted tree-L model uses 3000 trees.
+
+# C.6 MUSHROOM EDIBILITY DATASET
+
+TabNet model uses $N _ { d } = N _ { a } = 8$ , $\lambda _ { s p a r s e } = 0 . 0 0 1$ , $B = 2 0 4 8$ , $B _ { V } = 1 2 8$ , $m _ { B } = 0 . 9$ , $N _ { s t e p s } = 3$ and $\gamma = 1 . 5$ . Each feature transformer block uses two shared and two decision step-dependent
+
+fully-connected layer, ghost batch normalization and GLU blocks. Adam optimization is used with a learning rate of 0.01 (decayed 0.8 every 400 iterations with an exponential decay) for 10k iterations.
+
+# C.7 ADULT CENSUS INCOME DATASET
+
+TabNet model uses $N _ { d } = N _ { a } = 1 6$ , $\lambda _ { s p a r s e } = 0 . 0 0 0 1$ , $B = 4 0 9 6$ , $B _ { V } = 1 2 8$ , $m _ { B } = 0 . 9 8$ , $N _ { s t e p s } = 5$ and $\gamma = 1 . 5$ . Each feature transformer block uses two shared and two decision stepdependent layer, ghost batch normalization and GLU blocks. Adam optimization is used with a learning rate of 0.02 (decayed 0.4 every $2 . 5 \mathrm { k }$ iterations with an exponential decay) for $7 . 7 \mathrm { k }$ iterations.
+
+When only 40 labeled examples are used instead of the full dataset, based on re-optimization of hyperparameters on the validation set, we modify $B = 1 2 8$ , $\lambda _ { s p a r s e } = 0 . 0 1$ and the learning rate of 0.005 (decayed 0.95 every 10 iterations with an exponential decay) for 100 iterations.
+
+# C.8 ROSSMANN DATASET
+
+TabNet model uses $N _ { d } = N _ { a } = 3 2$ , $\lambda _ { s p a r s e } = 0 . 0 0 1$ , $B \ = \ 4 0 9 6$ , $B _ { V } ~ = ~ 5 1 2$ , $m _ { B } ~ = ~ 0 . 8$ , $N _ { s t e p s } = 5$ and $\gamma = 1 . 2$ . Each feature transformer block uses two shared and two decision stepdependent fully-connected layer, ghost batch normalization and GLU blocks. Adam optimization is used with a learning rate of 0.002 (decayed 0.95 every 2000 iterations with an exponential decay) for $1 5 \mathrm { k }$ iterations.
+
+# D GUIDELINES FOR HYPERPARAMETER SELECTION
+
+We consider datasets ranging from $\mathord { \sim } 1 0 \mathrm { K }$ to $\mathord { \sim } 1 0 \mathbf { M }$ training points, with varying degrees of fitting difficulty. TabNet obtains high performance for all with a few general principles on hyperparameter selection:
+
+• Most datasets yield the best results for $N _ { s t e p s } \in [ 3 , 1 0 ]$ . Typically, we observe that when there are more information-bearing features, the optimal value of $N _ { s t e p s }$ tends to be higher. On the other hand, increasing it beyond some value may adversely affect training dynamics as some paths in the network becomes deeper and there are more potentially-problematic ill-conditioned matrices. A very high value of $N _ { s t e p s }$ typically suffers from overfitting and yields poor generalization.   
+• Adjustment of the values of $N _ { d }$ and $N _ { a }$ is the most efficient way of obtaining a trade-off between performance and complexity. $N _ { d } = N _ { a }$ is a reasonable choice for most datasets. A very high value of $N _ { d }$ and $N _ { a }$ may suffer from overfitting and yield poor generalization.   
+• An optimal choice of $\gamma$ can have a major role on the overall performance. Typically a larger $N _ { s t e p s }$ value favors for a larger $\gamma$ .   
+• A large batch size is beneficial for performance - if the memory constraints permit, as large as $1 - 1 0 \%$ of the total training dataset size is suggested. The virtual batch size is typically much smaller than the batch size.   
+• Initially large learning rate is important, which should be gradually decayed until convergence.
+
+When the model size is constrained, the hyperparameter search becomes more complicated. Because the optimal ways to increase the representation capacity may be chosen among different options, such as increasing the number of steps or the unit size. For example, increasing the number of units while slightly decreasing the step size can be a better way of optimal utilization of the limited capacity constrained by the size on the number of parameters.
+
+# E ABLATION STUDIES
+
+In Table 10, we show the impact of various design and hyperparameter choices. For all cases, the number of iterations is optimized on the validation set.
+
+Table 10: Ablation studies for the TabNet model for the forest cover type dataset.   
+
+<table><tr><td rowspan=1 colspan=1>Ablation cases</td><td rowspan=1 colspan=1>Test accuracy %(difference)</td><td rowspan=1 colspan=1>Number ofparameters</td></tr><tr><td rowspan=1 colspan=1>Base(Nd = Na = 64, γ = 1.5, Nsteps = 5,Xsparse = 0.0o01, feature transformer block composedof two shared and two decision step-dependent layers,B = 16384)</td><td rowspan=1 colspan=1>96.99 (0)</td><td rowspan=1 colspan=1>470k</td></tr><tr><td rowspan=1 colspan=1>Decreasing capacity via number of units (withNd = Na =32)</td><td rowspan=1 colspan=1>94.99 (-2.00)</td><td rowspan=1 colspan=1>129k</td></tr><tr><td rowspan=1 colspan=1>Decreasing capacity via number of decision steps (withNsteps = 3)</td><td rowspan=1 colspan=1>96.22 (-0.77)</td><td rowspan=1 colspan=1>328k</td></tr><tr><td rowspan=1 colspan=1>Increasing capacity via number of decision steps (withNsteps = 9)</td><td rowspan=1 colspan=1>95.48 (-1.51)</td><td rowspan=1 colspan=1>755k</td></tr><tr><td rowspan=1 colspan=1>Decreasing capacity via all-shared feature transformerblocks</td><td rowspan=1 colspan=1>96.74 (-0.25)</td><td rowspan=1 colspan=1>143k</td></tr><tr><td rowspan=1 colspan=1>Increasing capacity via decision step-dependent featuretransformer blocks</td><td rowspan=1 colspan=1>96.76 (-0.23)</td><td rowspan=1 colspan=1>703k</td></tr><tr><td rowspan=1 colspan=1>Replacing feature transformer block with a single sharedlayer</td><td rowspan=1 colspan=1>95.32 (-1.67)</td><td rowspan=1 colspan=1>35k</td></tr><tr><td rowspan=1 colspan=1>Replacing feature transformer block with a single sharedlayer, with ReLU instead of GLU</td><td rowspan=1 colspan=1>93.92 (-3.07)</td><td rowspan=1 colspan=1>27k</td></tr><tr><td rowspan=1 colspan=1>Replacing feature transformer block with two sharedlayers</td><td rowspan=1 colspan=1>96.34 (-0.66)</td><td rowspan=1 colspan=1>71k</td></tr><tr><td rowspan=1 colspan=1>Replacing feature transformer block with two sharedlayers and 1 decision step-dependent layer</td><td rowspan=1 colspan=1>96.54 (-0.45)</td><td rowspan=1 colspan=1>271k</td></tr><tr><td rowspan=1 colspan=1>Replacing feature transformer block with a singledecision-step dependent layer</td><td rowspan=1 colspan=1>94.71 (-0.28)</td><td rowspan=1 colspan=1>105k</td></tr><tr><td rowspan=1 colspan=1>Replacing feature transformer block with a singledecision-step dependent layer,with Nd = Na = 128</td><td rowspan=1 colspan=1>96.24 (-0.75)</td><td rowspan=1 colspan=1>208k</td></tr><tr><td rowspan=1 colspan=1>Replacing feature transformer block with a singledecision-step dependent layer, with Nd = Na = 128 andreplacing GLU with ReLU</td><td rowspan=1 colspan=1>95.67 (-1.32)</td><td rowspan=1 colspan=1>139k</td></tr><tr><td rowspan=1 colspan=1>Replacing feature transformer block with a singledecision-step dependent layer, with Nd = Na = 256 andreplacing GLU with ReLU</td><td rowspan=1 colspan=1>96.41 (-0.58)</td><td rowspan=1 colspan=1>278k</td></tr><tr><td rowspan=1 colspan=1>Reducing the impact of prior scale (with γy = 3.0)</td><td rowspan=1 colspan=1>96.49 (-0.50)</td><td rowspan=1 colspan=1>470k</td></tr><tr><td rowspan=1 colspan=1>Increasing the impact of prior scale (with γ = 1.0)</td><td rowspan=1 colspan=1>96.67 (-0.32)</td><td rowspan=1 colspan=1>470k</td></tr><tr><td rowspan=1 colspan=1>No sparsity regularization (with Xsparse= 0)</td><td rowspan=1 colspan=1>96.50 (-0.49)</td><td rowspan=1 colspan=1>470k</td></tr><tr><td rowspan=1 colspan=1>High sparsity regularization (with Xsparse= 0.01)</td><td rowspan=1 colspan=1>93.87 (-3.12)</td><td rowspan=1 colspan=1>470k</td></tr><tr><td rowspan=1 colspan=1>Small batch size (B = 4096)</td><td rowspan=1 colspan=1>96.42 (-0.57)</td><td rowspan=1 colspan=1>470k</td></tr></table>
+
+Obtaining high performance necessitates appropriately-adjusted model capacity based on the characteristics of the dataset. Decreasing the number of units $N _ { d }$ , $N _ { a }$ or the number of decision steps $N _ { s t e p s }$ are efficient ways of gradually decreasing the capacity without significant degradation in performance. On the other hand, increasing these parameters beyond some value causes optimization issues and do not yield performance benefits.
+
+Replacing the feature transformer block with a very simpler alternative, such as a single shared layer, can still give strong performance while yielding a very compact model architecture. This shows the importance of the inductive bias introduced with feature selection and sequential attention.
+
+To push for the performance further, increasing the depth of the feature transformer is the effective approach. While increasing the depth, parameter sharing between feature transformer blocks across different decisions is an efficient way to decrease model size without significant degradation from performance. We indeed observe the benefit of partial parameter sharing, compared to fully decision step-dependent blocks or fully shared blocks. We observe the empirical benefit of GLU, compared to conventional nonlinearities like ReLU.
+
+The strength of sparse feature selection depends on the two parameters we introduce: $\gamma$ and $\lambda _ { s p a r s e }$ . We show that optimal choice of these two is important for performance. A $\gamma$ close to 1, or a high $\lambda _ { s p a r s e }$ may yield too tight constraints on the strength of sparsity and may hurt performance. On the other hand, there is still the benefit of a sufficient low $\gamma$ and sufficiently high $\lambda _ { s p a r s e }$ , to aid learning of the model via a favorable inductive bias.
+
+Lastly, given the fixed model architecture, we show the benefit of large-batch training, enabled by ghost batch normalization (Hoffer et al., 2017). The optimal batch size for TabNet seems considerably higher than the conventional batch sizes used for other data types, such as images or speech.
+
+# F MIXUP TRAINING
+
+In (Zhang et al., 2017), mixup training was shown to be beneficial for tabular data learning, on small-scale datasets with simple neural network models comprising fully-connected layers. We experiment mixup training with TabNet and did not observe superior performance compared to standard softmax training. For Covertype dataset, the best mixup model (for mixup parameter $\alpha { = } 0 . 3$ ) yields a test accuracy of $9 6 . 2 8 \%$ , roughly $0 . 7 \%$ lower than softmax training. For Higgs dataset, for the best TabNet-S model, the best mixup model (for mixup parameter $\alpha { = } 0 . 1$ ) yields a test accuracy of $7 8 . 1 1 \%$ , roughly $0 . 1 \%$ lower than softmax training. We hypothesize that linearization of the inputs may cause significant shifts in the input distribution and thus adversely affect the feature selection blocks of TabNet.
+
+# G SEMI-SUPERVISED LEARNING
+
+![](images/f43a8da055754ce6e70f5a78281e4aa4ff670968f0b01c34d0e8b741699836c3.jpg)  
+Figure 8: Decoder architecture to transform the encoded representation into reconstructed tabular data features. Each decision step is composed of a feature transformer block (see Fig. 3), and a fully-connected layer.
+
+We explore the capability of TabNet in learning semantically-meaningful representations by integrating it into an autoencoder framework (Baldi, 2012). For this purpose, we propose a simple decoder architecture, shown in Fig. 8. The decoder is composed of a feature transformer block (as given in Fig. 3), followed by a fully-connected layer at each decision step. Different decision steps are summed to output the reconstructed features.
+
+We propose an additive reconstruction loss (with a coefficient $\lambda _ { u n s u p . }$ ) between the input features $\mathbf { X }$ and the reconstructed features $\hat { \bf X }$ . The reconstruction loss (computed over unlabeled data batch of size $B _ { U }$ ) is in the form of L2 loss, normalized with the population standard deviation of the ground truth data, and scaled by $\mathbf { S }$ :
+
+$$
+L _ { u n s u p } ( \hat { \mathbf { X } } , \mathbf { X } ) = \frac { 1 } { B _ { U } \cdot D } \sum _ { b = 1 } ^ { B _ { U } } \sum _ { j = 1 } ^ { D } \left| \frac { ( \hat { \mathbf { X } } _ { \mathbf { b } , \mathbf { j } } - \mathbf { X } _ { \mathbf { b } , \mathbf { j } } ) \cdot \mathbf { S } _ { \mathbf { b } , \mathbf { j } } } { \sqrt { \frac { 1 } { B _ { U } } \sum _ { b = 1 } ^ { B _ { U } } ( \mathbf { X } _ { \mathbf { b } , \mathbf { j } } - \frac { 1 } { B _ { U } } \sum _ { b = 1 } ^ { B _ { U } } \mathbf { X } _ { \mathbf { b } , \mathbf { j } } ) ^ { 2 } } } \right| ^ { 2 }
+$$
+
+Normalization with the input value is observed to be crucial, as the tabular data features may have very different ranges. A straightforward approach in conventional reconstruction loss is scaling with a uniform mask, $\mathbf { S _ { b , j } } = 1 / D$ . As a more promising alternative, we propose that scaling should be based on feature importance values, such that the autoencoder should prioritize learning the representation for features that are the most important for decision making. We use the feature important mask Sb,j = M0agg−b,j/ PDj=1 M0agg−b,j to promote learning for the most salient features. M0a is inferred from the TabNet for the batch of unlabeled training samples, and fixed in the computation of loss to avoid the trivial solutions of fitting the easiest features.
+
+For semi-supervised learning experiments, we consider the Adult Census Income dataset. We randomly choose 50 samples as the labeled set. We fix the TabNet model with the aferomentioned hyperparameters. As the original learning hyperparameters overfit very quickly for 50 samples, we reoptimize the learning rate to 0.01 (decayed 0.9 every 100 iterations with an exponential decay) and trained for 800 iterations. For the autoencoder, we also fix the TabNet architecture, and optimize the decoder and learning hyperparameters. We use a decoder architecture with $N _ { d } = N _ { a } = 1 6$ , $B = 1 2 8$ , and $m _ { B } = 0 . 9 8$ . We use an unlabeled batch size of $B _ { U } = 2 0 4 8$ . The model with uniform masking uses $\lambda _ { u n s u p } = 0 . 2$ , $\lambda _ { s p a r s e } = 0 . 0 0 5$ , the number of decoder steps of $N _ { s t e p s } = 6$ and a learning rate of 0.005 (decayed 0.95 every $4 \mathrm { k \Omega }$ iterations with an exponential decay) and trained for $2 0 . 6 \mathrm { k }$ iterations. The model with feature importance mask uses $\lambda _ { u n s u p } = 0 . 1$ , $\lambda _ { s p a r s e } = 0 . 0 0 5$ , the number of decoder steps of $N _ { s t e p s } = 4$ and a learning rate of 0.01 (decayed 0.9 every 10k iterations with an exponential decay) and trained for $6 3 \mathrm { k }$ iterations. Since feature importance masking focuses on reconstructing the most salient features, the learning capacity of the optimal decoder is lower.
+
+Table 11: Results for semi-supervised learning for Adult Census Income, along with the supervised learning benchmarks. 50 samples with labels are randomly chosen from the training dataset. We reoptimize the learning hyperparameters on a separate validation set for a fair comparison.   
+
+<table><tr><td rowspan=1 colspan=1>Dataset</td><td rowspan=1 colspan=1>Learning setting</td><td rowspan=1 colspan=1>Test accuracy (%)</td></tr><tr><td rowspan=1 colspan=1>50 labeled</td><td rowspan=1 colspan=1>Fully-supervised</td><td rowspan=1 colspan=1>76.8</td></tr><tr><td rowspan=1 colspan=1>50labeled+26015unlabeled</td><td rowspan=1 colspan=1>Semi-supervised (autoencoder withuniform mask)</td><td rowspan=1 colspan=1>78.9</td></tr><tr><td rowspan=1 colspan=1>50labeled+26015unlabeled</td><td rowspan=1 colspan=1>Semi-supervised (autoencoder withfeature importance mask)</td><td rowspan=1 colspan=1>80.6</td></tr><tr><td rowspan=1 colspan=1>26065labeled</td><td rowspan=1 colspan=1>Fully-supervised</td><td rowspan=1 colspan=1>85.7</td></tr></table>
+
+Table 11 shows the semi-supervised learning performance, along with the two supervised learning benchmarks: when trained without additional unlabeled data and when trained after labeling the entire dataset. We observe a significant boost in performance with the contributions from the unlabeled data, closing the gap towards the supervised learning baseline of the entire dataset. Focusing on the most important features in autoencoding helps improving the semi-supervised learning performance.

parse/train/H1emus0qF7/H1emus0qF7.md

@@ -0,0 +1,534 @@
+# NEAR-OPTIMAL REPRESENTATION LEARNING FOR HIERARCHICAL REINFORCEMENT LEARNING
+
+Ofir Nachum, Shixiang Gu, Honglak Lee & Sergey Levine∗ Google Brain {ofirnachum,shanegu,honglak,slevine}@google.co
+
+# ABSTRACT
+
+We study the problem of representation learning in goal-conditioned hierarchical reinforcement learning. In such hierarchical structures, a higher-level controller solves tasks by iteratively communicating goals which a lower-level policy is trained to reach. Accordingly, the choice of representation – the mapping of observation space to goal space – is crucial. To study this problem, we develop a notion of sub-optimality of a representation, defined in terms of expected reward of the optimal hierarchical policy using this representation. We derive expressions which bound the sub-optimality and show how these expressions can be translated to representation learning objectives which may be optimized in practice. Results on a number of difficult continuous-control tasks show that our approach to representation learning yields qualitatively better representations as well as quantitatively better hierarchical policies, compared to existing methods.12
+
+# 1 INTRODUCTION
+
+Hierarchical reinforcement learning has long held the promise of extending the successes of existing reinforcement learning (RL) methods (Gu et al., 2017; Schulman et al., 2015; Lillicrap et al., 2015) to more complex, difficult, and temporally extended tasks (Parr & Russell, 1998; Sutton et al., 1999; Barto & Mahadevan, 2003). Recently, goal-conditioned hierarchical designs, in which higher-level policies communicate goals to lower-levels and lower-level policies are rewarded for reaching states (i.e. observations) which are close to these desired goals, have emerged as an effective paradigm for hierarchical RL (Nachum et al. (2018); Levy et al. (2017); Vezhnevets et al. (2017), inspired by earlier work Dayan & Hinton (1993); Schmidhuber & Wahnsiedler (1993)). In this hierarchical design, representation learning is crucial; that is, a representation function must be chosen mapping state observations to an abstract space. Goals (desired states) are then specified by the choice of a point in this abstract space.
+
+Previous works have largely studied two ways to choose the representation: learning the representation end-to-end together with the higher- and lower-level policies (Vezhnevets et al., 2017), or using the state space as-is for the goal space (i.e., the goal space is a subspace of the state space) (Nachum et al., 2018; Levy et al., 2017). The former approach is appealing, but in practice often produces poor results (see Nachum et al. (2018) and our own experiments), since the resulting representation is under-defined; i.e., not all possible sub-tasks are expressible as goals in the space. On the other hand, fixing the representation to be the full state means that no information is lost, but this choice is difficult to scale to higher dimensions. For example, if the state observations are entire images, the higher-level must output target images for the lower-level, which can be very difficult.
+
+We instead study how unsupervised objectives can be used to train a representation that is more concise than the full state, but also not as under-determined as in the end-to-end approach. In order to do so in a principled manner, we propose a measure of sub-optimality of a given representation. This measure aims to answer the question: How much does using the learned representation in place of the full representation cause us to lose, in terms of expected reward, against the optimal policy? This question is important, because a useful representation will compress the state, hopefully making the learning problem easier. At the same time, the compression might cause the representation to lose information, making the optimal policy impossible to express. It is therefore critical to understand how lossy a learned representation is, not in terms of reconstruction, but in terms of the ability to represent near-optimal policies on top of this representation.
+
+Our main theoretical result shows that, for a particular choice of representation learning objective, we can learn representations for which the return of the hierarchical policy approaches the return of the optimal policy within a bounded error. This suggests that, if the representation is learned with a principled objective, the ‘lossy-ness’ in the resulting representation should not cause a decrease in overall task performance. We then formulate a representation learning approach that optimizes this bound. We further extend our result to the case of temporal abstraction, where the higher-level controller only chooses new goals at fixed time intervals. To our knowledge, this is the first result showing that hierarchical goal-setting policies with learned representations and temporal abstraction can achieve bounded sub-optimality against the optimal policy. We further observe that the representation learning objective suggested by our theoretical result closely resembles several other recently proposed objectives based on mutual information (van den Oord et al., 2018; Ishmael Belghazi et al., 2018; Hjelm et al., 2018), suggesting an intriguing connection between mutual information and goal representations for hierarchical RL. Results on a number of difficult continuous-control navigation tasks show that our principled representation learning objective yields good qualitative and quantitative performance compared to existing methods.
+
+# 2 FRAMEWORK
+
+Following previous work (Nachum et al., 2018), we consider a two-level hierarchical policy on an MDP $\overset { \triangledown } { \mathcal { M } } = ( S , A , R , T )$ , in which the higher-level policy modulates the behavior of a lowerlevel policy by choosing a desired goal state and rewarding the lower-level policy for reaching this state. While prior work has used a sub-space of the state space as goals (Nachum et al., 2018), in more general settings, some type of state representation is necessary. That is, consider a state representation function $f : \mathcal { S } \overset { \vartriangle } {  } \mathbb { R } ^ { d }$ . A two-level hierarchical policy on $\mathcal { M }$ is composed of a higher-level policy $\pi _ { \mathrm { h i } } ( g | s )$ , where $g \in G = \mathbb { R } ^ { d }$ is the goal space, that samples a high-level action (or goal) $g _ { t } \sim \pi _ { \mathrm { h i } } ( g | s _ { t } )$ every $c$ steps, for fixed $c$ . A non-stationary, goal-conditioned, lower-level policy $\pi _ { \mathrm { l o } } ( a | s _ { t } , g _ { t } , s _ { t + k } , k )$ then translates these high-level actions into low-level actions $a _ { t + k } \in A$ for $k \in [ 0 , c - 1 ]$ . The process is then repeated, beginning with the higher-level policy selecting another goal according to $s _ { t + c }$ . The policy $\pi _ { \mathrm { l o } }$ is trained using a goal-conditioned reward; e.g. the reward of a transition $g , s , s ^ { \prime }$ is $- D ( f ( s ^ { \prime } ) , g )$ , where $D$ is a distance function.
+
+In this work we adopt a slightly different interpretation of the lower-level policy and its relation to $\pi _ { \mathrm { h i } }$ . Every $c$ steps, the higher-level policy chooses a goal $g _ { t }$ based on a state $s _ { t }$ . We interpret this state-goal pair as being mapped to a nonstationary policy $\pi ( a | s _ { t + k } , k ) , \pi ~ \in ~ \Pi$ , where $\Pi$ denotes the set of all possible $c$ -step policies acting on $\mathcal { M }$ . We use $\Psi$ to denote this mapping from $S \times G$ to $\Pi$ . In other words, on every $c ^ { \mathrm { t h } }$ step, we encounter some state $s _ { t } ~ \in ~ S$ . We use the higher-level policy to sample a goal
+
+![](images/a497a31ee3e2f136741ae2d4a66e45e6894b458d2f8935ae08fc5ee805435315.jpg)  
+Figure 1: The hierarchical design we consider.
+
+$g _ { t } \sim \pi _ { \mathrm { h i } } ( g | s _ { t } )$ and translate this to a policy $\pi _ { t } = \Psi ( s _ { t } , g _ { t } )$ . We then use $\pi _ { t }$ to sample actions $a _ { t + k } \sim \pi _ { t } ( a | s _ { t + k } , k )$ for $k \in [ 0 , c - 1 ]$ . The process is then repeated from $s _ { t + c }$ .
+
+Although the difference in this interpretation is subtle, the introduction of $\Psi$ is crucial for our subsequent analysis. The communication of $g _ { t }$ is no longer as a goal which $\pi _ { \mathrm { h i } }$ desires to reach, but rather more precisely, as an identifier to a low-level behavior which $\pi _ { \mathrm { h i } }$ desires to induce or activate.
+
+The mapping $\Psi$ is usually expressed as the result of an RL optimization over $\Pi$ ; e.g.,
+
+$$
+\Psi ( s _ { t } , g ) = \underset { \pi \in \Pi } { \arg \operatorname* { m a x } } \sum _ { k = 1 } ^ { c } \gamma ^ { k - 1 } \mathbb { E } _ { P _ { \pi } ( s _ { t + k } \mid s _ { t } ) } [ - D ( f ( s _ { t + k } ) , g ) ] ,
+$$
+
+where we use $P _ { \pi } ( s _ { t + k } | s _ { t } )$ to denote the probability of being in state $s _ { t + k }$ after following $\pi$ for $k$ steps starting from $s _ { t }$ . We will consider variations on this low-level objective in later sections. From Equation 1 it is clear how the choice of representation $f$ affects $\Psi$ (albeit indirectly).
+
+We will restrict the environment reward function $R$ to be defined only on states. We use $R _ { m a x }$ to denote the maximal absolute reward: $R _ { m a x } = \operatorname* { s u p } _ { S } | R ( s ) |$ .
+
+# 3 HIERARCHICAL POLICY SUB-OPTIMALITY
+
+In the previous section, we introduced two-level policies where a higher-level policy $\pi _ { \mathrm { h i } }$ chooses goals $g$ , which are translated to lower-level behaviors via $\Psi$ . The introduction of this hierarchy leads to a natural question: How much do we lose by learning $\pi _ { \mathrm { h i } }$ which is only able to act on $\mathcal { M }$ via $\Psi ?$ The choice of $\Psi$ restricts the type and number of lower-level behaviors that the higher-level policy can induce. Thus, the optimal policy on $\mathcal { M }$ is potentially not expressible by $\pi _ { \mathrm { h i } }$ . Despite the potential lossy-ness of $\Psi$ , can one still learn a hierarchical policy which is near-optimal?
+
+To approach this question, we introduce a notion of sub-optimality with respect to the form of $\Psi$ : Let $\pi _ { \mathrm { h i } } ^ { * } ( g | s , \Psi )$ be the optimal higher-level policy acting on $G$ and using $\Psi$ as the mapping from $G$ to low-level behaviors. Let $\pi _ { \mathrm { h i e r } } ^ { * }$ be the corresponding full hierarchical policy on $\mathcal { M }$ . We will compare $\pi _ { \mathrm { h i e r } } ^ { * }$ to an optimal hierarchical policy $\pi ^ { * }$ agnostic to $\Psi$ . To define $\pi ^ { * }$ we begin by introducing an optimal higher-level policy $\pi _ { \mathrm { h i } } ^ { * * } ( \pi | s )$ agnostic to $\Psi$ ; i.e. every $c$ steps, $\pi _ { \mathrm { h i } } ^ { * * }$ samples a low-level behavior $\pi \in \Pi$ which is applied to $\mathcal { M }$ for the following $c$ steps. In this way, $\pi _ { \mathrm { h i } } ^ { * * }$ may express all possible low-level behaviors. We then denote $\pi ^ { * }$ as the full hierarchical policy resulting from $\pi _ { \mathrm { h i } } ^ { * * }$ .
+
+We would like to compare $\pi _ { \mathrm { h i e r } } ^ { * }$ to $\pi ^ { * }$ . A natural and common way to do so is in terms of state values. Let $V ^ { \pi } ( s )$ be the future value achieved by a policy $\pi$ starting at state $s$ . We define the sub-optimality of $\Psi$ as
+
+$$
+\mathrm { S u b O p t } ( \Psi ) = \displaystyle \operatorname* { s u p } _ { s \in S } V ^ { \pi ^ { * } } ( s ) - V ^ { \pi _ { \mathrm { h i e r } } ^ { * } } ( s ) .
+$$
+
+The state values $V ^ { \pi _ { \mathrm { h i e r } } ^ { * } } ( s )$ are determined by the form of $\Psi$ , which is in turn determined by the choice of representation $f$ . However, none of these relationships are direct. It is unclear how a change in $f$ will result in a change to the sub-optimality. In the following section, we derive a series of bounds which establish a more direct relationship between $\mathrm { S u b O p t } \bar { ( } \Psi )$ and $f$ . Our main result will show that if one defines $\Psi$ as a slight modification of the traditional objective given in Equation 1, then one may translate sub-optimality of $\Psi$ to a practical representation learning objective for $f$ .
+
+# 4 GOOD REPRESENTATIONS LEAD TO BOUNDED SUB-OPTIMALITY
+
+In this section, we provide proxy expressions that bound the sub-optimality induced by a specific choice of $\Psi$ . Our main result is Claim 4, which connects the sub-optimality of $\Psi$ to both goalconditioned policy objectives (i.e., the objective in 1) and representation learning (i.e., an objective for the function $f$ ).
+
+# 4.1 SINGLE-STEPS $\displaystyle c = 1$ ) AND DETERMINISTIC POLICIES
+
+For ease of presentation, we begin by presenting our results in the restricted case of $c = 1$ and deterministic lower-level policies. In this setting, the class of low-level policies $\Pi$ may be taken to be simply $A$ , where $a \in \Pi$ corresponds to a policy which always chooses action $a$ . There is no temporal abstraction: The higher-level policy chooses a high-level action $g \in G$ at every step, which is translated via $\Psi$ to a low-level action $a \in A$ . Our claims are based on quantifying how many of the possible low-level behaviors (i.e., all possible state to state transitions) can be produced by $\Psi$ for different choices of $g$ . To quantify this, we make use of an auxiliary inverse goal model $\varphi ( s , a )$ , which aims to predict which goal $g$ will cause $\Psi$ to yield an action $\tilde { \boldsymbol { a } } = \boldsymbol { \Psi } ( s , g )$ that induces a next state distribution $P ( s ^ { \prime } | s , \tilde { a } )$ similar to $P ( s ^ { \prime } | s , a )$ .3 We have the following theorem, which bounds the sub-optimality in terms of total variation divergences between $P ( s ^ { \prime } | s , a )$ and $P ( s ^ { \prime } | s , \tilde { a } )$ :
+
+Theorem 1. If there exists $\varphi : S \times A \to G$ such that,
+
+$$
+\operatorname* { s u p } _ { s \in S , a \in A } D _ { \mathrm { T V } } ( P ( s ^ { \prime } | s , a ) | | P ( s ^ { \prime } | s , \Psi ( s , \varphi ( s , a ) ) ) ) \leq \epsilon ,
+$$
+
+$\operatorname { S u b O p t } ( \Psi ) \leq C \epsilon$ , where $\begin{array} { r } { C = \frac { 2 \gamma } { ( 1 - \gamma ) ^ { 2 } } R _ { m a x } } \end{array}$
+
+Proof. See Appendices A and B for all proofs.
+
+Theorem 1 allows us to bound the sub-optimality of $\Psi$ in terms of how recoverable the effect of any action in $A$ is, in terms of transition to the next state. One way to ensure that effects of actions in $A$ are recoverable is to have an invertible $\Psi$ . That is, if there exists $\varphi : S \times A \to G$ such that $\Psi ( s , \varphi ( s , a ) ) = a$ for all $s , a$ , then the sub-optimality of $\Psi$ is 0.
+
+However, in many cases it may not be desirable or feasible to have an invertible $\Psi$ . Looking back at Theorem 1, we emphasize that its statement requires only the effect of any action to be recoverable. That is, for any $s , \in S , a \in A$ , we require only that there exist some $g \in G$ (given by $\varphi ( s , a ) )$ which yields a similar next-state distribution. To this end, we have the following claim, which connects the sub-optimality of $\Psi$ to both representation learning and the form of the low-level objective.
+
+Claim 2. Let $\rho ( s )$ be a prior and $f , \varphi$ be so that, for $K ( s ^ { \prime } | s , a ) \propto \rho ( s ^ { \prime } ) \exp ( - D ( f ( s ^ { \prime } ) , \varphi ( s , a ) ) ) ;$
+
+$$
+\operatorname* { s u p } _ { s \in S , a \in A } D _ { \mathrm { K L } } ( P ( s ^ { \prime } | s , a ) | | K ( s ^ { \prime } | s , a ) ) \le \epsilon ^ { 2 } / 8 .
+$$
+
+If the low-level objective is defined as
+
+$$
+\Psi ( s , g ) = \underset { a \in A } { \operatorname { a r g m a x } } \mathbb { E } _ { P ( s ^ { \prime } \mid s , a ) } [ - D ( f ( s ^ { \prime } ) , g ) + \log \rho ( s ^ { \prime } ) - \log P ( s ^ { \prime } \mid s , a ) ] ,
+$$
+
+then the sub-optimality of $\Psi$ is bounded by $C \epsilon$
+
+We provide an intuitive explanation of the statement of Claim 2. First, consider that the distribution $K ( s ^ { \prime } | s , a )$ appearing in Equation 4 may be interpreted as a dynamics model determined by $f$ and $\varphi$ . By bounding the difference between the true dynamics $P ( s ^ { \prime } | s , a )$ and the dynamics $K ( s ^ { \prime } | s , a )$ implied by $f$ and $\varphi$ , Equation 4 states that the representation $f$ should be chosen in such a way that dynamics in representation space are roughly given by $\varphi ( s , a )$ . This is essentially a representation learning objective for choosing $f$ , and in Section 5 we describe how to optimize it in practice.
+
+Moving on to Equation 5, we note that the form of $\Psi$ here is only slightly different than the onestep form of the standard goal-conditioned objective in Equation 1.5 Therefore, all together Claim 2 establishes a deep connection between representation learning (Equation 4), goal-conditioned policy learning (Equation 5), and sub-optimality.
+
+# 4.2 TEMPORAL ABSTRACTION $( c \geq 1$ ) AND GENERAL POLICIES
+
+We now move on to presenting the same results in the fully general, temporally abstracted setting, in which the higher-level policy chooses a high-level action $g \in G$ every $c$ steps, which is transformed via $\Psi$ to a $c$ -step lower-level behavior policy $\pi \in \Pi$ . In this setting, the auxiliary inverse goal model $\varphi ( s , \pi )$ is a mapping from $S \times \Pi$ to $G$ and aims to predict which goal $g$ will cause $\Psi$ to yield a policy $\tilde { \pi } = \Psi ( s , g )$ that induces future state distributions $P _ { \tilde { \pi } } \big ( s _ { t + k } \big | s _ { t } \big )$ similar to $P _ { \pi } { \left( { { s } _ { t + k } } \vert { { s } _ { t } } \right) }$ , for $\bar { k } \in [ 1 , c ]$ $w _ { k } \stackrel { \cdot } { = } ( \stackrel { \cdot } { 1 } - \gamma ) ^ { - 1 }$ . We weight the divergences between the distributions by weights for $k = c$ . We denote $\begin{array} { r } { \overline { { \boldsymbol { w } } } = \sum _ { k = 1 } ^ { c } \gamma ^ { k - 1 } \boldsymbol { w } _ { k } } \end{array}$ k  . The analogue to Theorem 1 is as for and follows:
+
+Theorem 3. Consider a mapping $\varphi : S \times \Pi  G$ and define $\epsilon _ { k } : S \times \Pi  \mathbb { R }$ for $k \in [ 1 , c ]$ as,
+
+$$
+\epsilon _ { k } ( s _ { t } , \pi ) = D _ { \mathrm { T V } } ( P _ { \pi } ( s _ { t + k } | s _ { t } ) | | P _ { \Psi ( s _ { t } , \varphi ( s _ { t } , \pi ) ) } ( s _ { t + k } | s _ { t } ) ) .
+$$
+
+If
+
+$$
+\operatorname* { s u p } _ { s _ { t } \in S , \pi \in \Pi } \frac { 1 } { \overline { { w } } } \sum _ { k = 1 } ^ { c } \gamma ^ { k - 1 } w _ { k } \epsilon _ { k } ( s _ { t } , \pi ) \le \epsilon ,
+$$
+
+$\operatorname { S u b O p t } ( \Psi ) \leq C \epsilon$ , where $\begin{array} { r } { C = \frac { 2 \gamma } { 1 - \gamma ^ { c } } R _ { m a x } \overline { { w } } } \end{array}$
+
+For the analogue to Claim 2, we simply replace the single-step KL divergences and low-level rewards with a discounted weighted sum thereof:
+
+Claim 4. Let $\rho ( s )$ be a prior over $S$ . Let $f , \varphi$ be such that,
+
+$$
+\operatorname* { s u p } _ { s _ { t } \in S , \pi \in \Pi } \frac { 1 } { \overline { { w } } } \sum _ { k = 1 } ^ { c } \gamma ^ { k - 1 } w _ { k } D _ { \mathrm { K L } } ( P _ { \pi } ( s _ { t + k } | s _ { t } ) | | K ( s _ { t + k } | s _ { t } , \pi ) ) \le \epsilon ^ { 2 } / 8 ,
+$$
+
+where $K ( s _ { t + k } | s _ { t } , \pi ) \propto \rho ( s _ { t + k } ) \exp ( - D ( f ( s _ { t + k } ) , \varphi ( s _ { t } , \pi ) ) ) .$
+
+If the low-level objective is defined as
+
+$$
+\Psi ( s _ { t } , g ) = \underset { \pi \in \Pi } { \operatorname { a r g m a x } } \sum _ { k = 1 } ^ { c } \gamma ^ { k - 1 } w _ { k } \mathbb { E } _ { P _ { \pi } ( s _ { t + k } | s _ { t } ) } [ - D ( f ( s _ { t + k } ) , g ) + \log \rho ( s _ { t + k } ) - \log P _ { \pi } ( s _ { t + k } | s _ { t } ) ] ,
+$$
+
+then the sub-optimality of $\Psi$ is bounded by $C \epsilon$
+
+Claim 4 is the main theoretical contribution of our work. As in the previous claim, we have a strong statement, saying that if the low-level objective is defined as in Equation 9, then minimizing the sub-optimality may be done by optimizing a representation learning objective based on Equation 8. We emphasize that Claim 4 applies to any class of low-level policies $\Pi$ , including either closed-loop or open-loop policies.
+
+# 5 LEARNING
+
+We now have the mathematical foundations necessary to learn representations that are provably good for use in hierarchical RL. We begin by elaborating on how we translate Equation 8 into a practical training objective for $f$ and auxiliary $\varphi$ (as well as a practical parameterization of policies $\pi$ as input to $\varphi$ ). We then continue to describe how one may train a lower-level policy to match the objective presented in Equation 9. In this way, we may learn $f$ and lower-level policy to directly optimize a bound on the sub-optimality of $\Psi$ . A pseudocode of the full algorithm is presented in the Appendix (see Algorithm 1).
+
+# 5.1 LEARNING GOOD REPRESENTATIONS
+
+Consider a representation function $f _ { \theta } : S  \mathbb { R } ^ { d }$ and an auxiliary function $\varphi _ { \theta } : S \times \Pi  \mathbb { R } ^ { d }$ , parameterized by vector $\theta$ . In practice, these are separate neural networks: $f _ { \theta _ { 1 } } , \varphi _ { \theta _ { 2 } } , \theta = [ \theta _ { 1 } , \theta _ { 2 } ]$ .
+
+While the form of Equation 8 suggests to optimize a supremum over all $s _ { t }$ and $\pi$ , in practice we only have access to a replay buffer which stores experience $s _ { 0 } , a _ { 0 } , s _ { 1 } , a _ { 1 } , \ldots$ sampled from our hierarchical behavior policy. Therefore, we propose to choose $s _ { t }$ sampled uniformly from the replay buffer and use the subsequent $c$ actions $a _ { t : t + c - 1 }$ as a representation of the policy $\pi$ , where we use $a _ { t : t + c - 1 }$ to denote the sequence $a _ { t } , \ldots , a _ { t + c - 1 }$ . Note that this is equivalent to setting the set of candidate policies $\Pi$ to $A ^ { c }$ (i.e., $\Pi$ is the set of $c$ -step, deterministic, open-loop policies). This choice additionally simplifies the possible structure of the function approximator used for $\varphi _ { \theta }$ (a standard neural net which takes in $s _ { t }$ and $a _ { t : t + c - 1 }$ ). Our proposed representation learning objective is thus,
+
+$$
+J ( \theta ) = \mathbb { E } _ { s _ { t } , a _ { t : t + c - 1 } \sim \mathrm { r e p l a y } } [ J ( \theta , s _ { t } , a _ { t : t + c - 1 } ) ] ,
+$$
+
+where $J ( \theta , s _ { t } , a _ { t : t + c - 1 } )$ will correspond to the inner part of the supremum in Equation 8.
+
+We now define the inner objective $J ( \theta , s _ { t } , a _ { t : t + c - 1 } )$ . To simplify notation, we use $E _ { \theta } ( s ^ { \prime } , s , \pi ) =$ $\exp ( - D ( f _ { \boldsymbol { \theta } } ( s ^ { \prime } ) , \varphi _ { \boldsymbol { \theta } } ( s , \pi ) ) )$ and use $K _ { \theta } ( s ^ { \prime } | s , \pi )$ as the distribution over $S$ such that $K _ { \theta } ( s ^ { \prime } | s , \pi ) \propto$ $\rho ( s ^ { \prime } ) E _ { \theta } ( s ^ { \prime } , s , \pi )$ . Equation 8 suggests the following learning objective on each $s _ { t } , \pi \equiv a _ { t : t + c - 1 }$ :
+
+$$
+\begin{array} { r l } { J ( \theta , s _ { t } , \pi ) = \displaystyle \sum _ { k = 1 } ^ { c } \gamma ^ { k - 1 } w _ { k } D _ { \mathrm { K L } } \big ( P _ { \pi } ( s _ { t + k } | s _ { t } ) | | K _ { \theta } ( s _ { t + k } | s _ { t } , \pi ) \big ) } & { { } } \\ { \displaystyle } & { { } = B + \displaystyle \sum _ { k = 1 } ^ { c } - \gamma ^ { k - 1 } w _ { k } \mathbb { E } _ { P _ { \pi } ( s _ { t + k } | s _ { t } ) } \left[ \log K _ { \theta } ( s _ { t + k } | s _ { t } , \pi ) \right] } \end{array}
+$$
+
+$$
+= B + \sum _ { k = 1 } ^ { c } - \gamma ^ { k - 1 } w _ { k } \mathbb { E } _ { P _ { \pi } ( s _ { t + k } \mid s _ { t } ) } \left[ \log E _ { \theta } ( s _ { t + k } , s _ { t } , \pi ) \right] + \gamma ^ { k - 1 } w _ { k } \log \mathbb { E } _ { \bar { s } \sim \rho } \left[ E _ { \theta } ( \tilde { s } , s _ { t } , \pi ) \right] ,
+$$
+
+where $B$ is a constant. The gradient with respect to $\theta$ is then,
+
+$$
+\sum _ { k = 1 } ^ { c } - \gamma ^ { k - 1 } w _ { k } \mathbb { E } _ { P _ { \pi } ( s _ { t + k } \mid s _ { t } ) } \left[ \nabla _ { \theta } \log E _ { \theta } ( s _ { t + k } , s _ { t } , \pi ) \right] + \gamma ^ { k - 1 } w _ { k } \frac { \mathbb { E } _ { \tilde { s } \sim \rho } \left[ \nabla _ { \theta } E _ { \theta } ( \tilde { s } , s _ { t } , \pi ) \right] } { \mathbb { E } _ { \tilde { s } \sim \rho } \left[ E _ { \theta } ( \tilde { s } , s _ { t } , \pi ) \right] }
+$$
+
+The first term of Equation 14 is straightforward to estimate using experienced $\scriptstyle { s _ { t + 1 : t + k } }$ . We set $\rho$ to be the replay buffer distribution, so that the numerator of the second term is also straightforward. We approximate the denominator of the second term using a mini-batch $\widetilde { S }$ of states independently sampled from the replay buffer:
+
+$$
+\begin{array} { r } { \mathbb { E } _ { \tilde { s } \sim { \rho } } \left[ E _ { \theta } ( \tilde { s } , s _ { t } , \pi ) \right] \approx | \widetilde { S } | ^ { - 1 } \sum _ { \tilde { s } \in \widetilde { S } } E _ { \theta } ( \tilde { s } , s _ { t } , \pi ) . } \end{array}
+$$
+
+This completes the description of our representation learning algorithm.
+
+Connection to Mutual Information Estimators. The form of the objective we optimize (i.e. Equation 13) is very similar to mutual information estimators, mostly CPC (van den Oord et al., 2018). Indeed, one may interpret our objective as maximizing a mutual information $M I ( s _ { t + k } ; s _ { t } , \pi )$ via an energy function given by $E _ { \theta } ( s _ { t + k } , s _ { t } , \pi )$ . The main differences between our approach and these previous proposals are as follows: (1) Previous approaches maximize a mutual information $M I ( s _ { t + k } ; s _ { t } )$ agnostic to actions or policy. (2) Previous approaches suggest to define the energy function as $\exp \bar { ( } f ( s _ { t + k } ) ^ { T } M _ { k } f ( s _ { t } ) )$ for some matrix $M _ { k }$ , whereas our energy function is based on the distance $D$ used for low-level reward. (3) Our approach is provably good for use in hierarchical RL, and hence our theoretical results may justify some of the good performance observed by others using mutual information estimators for representation learning. Different approaches to translating our theoretical findings to practical implementations may yield objectives more or less similar to CPC, some of which perform better than others (see Appendix D).
+
+# 5.2 LEARNING A LOWER-LEVEL POLICY
+
+Equation 9 suggests to optimize a policy $\pi _ { s _ { t } , g } ( a | s _ { t + k } , k )$ for every $s _ { t } , g$ . This is equivalent to the parameterization $\pi _ { \mathrm { l o } } ( a | s _ { t } , g , s _ { t + k } , k )$ , which is standard in goal-conditioned hierarchical designs. Standard RL algorithms may be employed to maximize the low-level reward implied by Equation 9:
+
+$$
+- D ( f ( s _ { t + k } ) , g ) + \log \rho ( s _ { t + k } ) - \log P _ { \pi } ( s _ { t + k } | s _ { t } ) ,
+$$
+
+weighted by $w _ { k }$ and where $\pi$ corresponds to $\pi _ { \mathrm { l o } }$ when the state $s _ { t }$ and goal $g$ are fixed. While the first term of Equation 16 is straightforward to compute, the log probabilities $\log \rho ( s _ { t + k } ) , \log P _ { \pi } ( s _ { t + k } | s _ { t } )$ are in general unknown. To approach this issue, we take advantage of the representation learning objective for $f , \varphi$ . When $f , \varphi$ are optimized as dictated by Equation 8, we have
+
+$$
+\begin{array} { r } { \log P _ { \pi } ( s _ { t + k } | s _ { t } ) \approx \log \rho ( s _ { t + k } ) - D ( f ( s _ { t + k } ) , \varphi ( s _ { t } , \pi ) ) - \log \mathbb { E } _ { \widetilde { s } \sim \rho } [ E ( \widetilde { s } , s _ { t } , \pi ) ] . } \end{array}
+$$
+
+We may therefore approximate the low-level reward as
+
+$$
+- D ( f ( s _ { t + k } ) , g ) + D ( f ( s _ { t + k } ) , \varphi ( s _ { t } , \pi ) ) + \log \mathbb { E } _ { \widetilde { s } \sim \rho } [ E ( \widetilde { s } , s _ { t } , \pi ) ] .
+$$
+
+As in Section 5.1, we use the sampled actions $a _ { t : t + c - 1 }$ to represent $\pi$ as input to $\varphi$ . We approximate the third term of Equation 18 analogously to Equation 15. Note that this is a slight difference from standard low-level rewards, which use only the first term of Equation 18 and are unweighted.
+
+# 6 RELATED WORK
+
+Representation learning for RL has a rich and diverse existing literature, often interpreted as an abstraction of the original MDP. Previous works have interpreted the hierarchy introduced in hierarchical RL as an MDP abstraction of state, action, and temporal spaces (Sutton et al., 1999; Dietterich, 2000; Thomas & Barto, 2012; Bacon et al., 2017). In goal-conditioned hierarchical designs, although the representation is learned on states, it is in fact a form of action abstraction (since goals $g$ are high-level actions). While previous successful applications of goal-conditioned hierarchical designs have either learned representations naively end-to-end (Vezhnevets et al., 2017), or not learned them at all (Levy et al., 2017; Nachum et al., 2018), we take a principled approach to representation learning in hierarchical RL, translating a bound on sub-optimality to a practical learning objective.
+
+Bounding sub-optimality in abstracted MDPs has a long history, from early work in theoretical analysis on approximations to dynamic programming models (Whitt, 1978; Bertsekas & Castanon, 1989). Extensive theoretical work on state abstraction, also known as state aggregation or model minimization, has been done in both operational research (Rogers et al., 1991; Van Roy, 2006) and RL (Dean & Givan, 1997; Ravindran & Barto, 2002; Abel et al., 2017). Notably, Li et al. (2006)
+
+introduce a formalism for categorizing classic work on state abstractions such as bisimulation (Dean & Givan, 1997) and homomorphism (Ravindran & Barto, 2002) based on what information is preserved, which is similar in spirit to our approach. Exact state abstractions (Li et al., 2006) incur no performance loss (Dean & Givan, 1997; Ravindran & Barto, 2002), while their approximate variants generally have bounded sub-optimality (Bertsekas & Castanon, 1989; Dean & Givan, 1997; Sorg & Singh, 2009; Abel et al., 2017). While some of the prior work also focuses on learning state abstractions (Li et al., 2006; Sorg & Singh, 2009; Abel et al., 2017), they often exclusively apply to simple MDP domains as they rely on techniques such as state partitioning or Q-value based aggregation, which are difficult to scale to our experimented domains. Thus, the key differentiation of our work from these prior works is that we derive bounds which may be translated to practical representation learning objectives. Our impressive results on difficult continuous-control, high-dimensional domains is a testament to the potential impact of our theoretical findings.
+
+Lastly, we note the similarity of our representation learning algorithm to recently introduced scalable mutual information maximization objectives such as CPC (van den Oord et al., 2018) and MINE (Ishmael Belghazi et al., 2018). This is not a surprise, since maximizing mutual information relates closely with maximum likelihood learning of energy-based models, and our bounds effectively correspond to bounds based on model-based predictive errors, a basic family of bounds in representation learning in MDPs (Sorg & Singh, 2009; Brunskill & Li, 2014; Abel et al., 2017). Although similar information theoretic measures have been used previously for exploration in RL (Still & Precup, 2012), to our knowledge, no prior work has connected these mutual information estimators to representation learning in hierarchical RL, and ours is the first to formulate theoretical guarantees on sub-optimality of the resulting representations in such a framework.
+
+# 7 EXPERIMENTS
+
+We evaluate our proposed representation learning objective compared to a number of baselines:
+
+• XY: The oracle baseline which uses the $x , y$ position of the agent as the representation. • VAE: A variational autoencoder (Kingma & Welling, 2013) on raw observations. • E2C: Embed to control (Watter et al., 2015). A method which uses variational objectives to train a representation of states and actions which have locally linear dynamics. • E2E: End-to-end learning of the representation. The representation is fed as input to the higher-level policy and learned using gradients from the RL objective. • Whole obs: The raw observation is used as the representation. No representation learning. This is distinct from Nachum et al. (2018), in which a subset of the observation space was pre-determined for use as the goal space.
+
+![](images/ec2867c168d772713ca9b3b200e8b97d787b1d88c543334f07c5c50256cec894.jpg)  
+Figure 2: Learned representations (2D embeddings) of our method and a number of variants on a MuJoCo Ant Maze environment, with color gradient based on episode time-step (black for beginning of episode, yellow for end). The ant travels from beginning to end of a $\supset$ -shaped corridor along an $x , y$ trajectory shown under XY. Without any supervision, our method is able to deduce this nearideal representation, even when the raw observation is given as a top-down image. Other approaches are unable to properly recover a good representation.
+
+![](images/c379f03dbb2bd31624c1bcce15826b43a46e568fabe24a0a5ade3fec0fc85234.jpg)  
+Figure 3: Results of our method and a number of variants on a suite of tasks in 10M steps of training, plotted according to median over 10 trials with $\mathrm { 3 0 ^ { t h } }$ and $7 0 ^ { \mathrm { t h } }$ percentiles. We find that outside of simple point environments, our method is the only one which can approach the performance of oracle $x , y$ representations. These results show that our method can be successful, even when the representation is learned online concurrently while learning a hierarchical policy.
+
+We evaluate on the following continuous-control MuJoCo (Todorov et al., 2012) tasks (see Appendix C for details):
+
+• Ant (or Point) Maze: An ant (or point mass) must navigate a $\supset$ -shaped corridor.   
+• Ant Push: An ant must push a large block to the side to reach a point behind it.   
+• Ant Fall: An ant must push a large block into a chasm so that it may walk over it to the other side without falling.   
+• Ant Block: An ant must push a small block to various locations in a square room.   
+• Ant Block Maze: An ant must push a small block through a $\supset$ -shaped corridor.
+
+In these tasks, the raw observation is the agent’s $x , y$ coordinates and orientation as well as local coordinates and orientations of its limbs. In the Ant Block and Ant Block Maze environments we also include the $x , y$ coordinates and orientation of the block. We also experiment with more difficult raw representations by replacing the $x , y$ coordinates of the agent with a low-resolution $5 \times 5 \times 3$ top-down image of the agent and its surroundings. These experiments are labeled ‘Images’.
+
+For the baseline representation learning methods which are agnostic to the RL training (VAE and E2C), we provide comparative qualitative results in Figure 2. These representations are the result of taking a trained policy, fixing it, and using its sampled experience to learn 2D representations of the raw observations. We find that our method can successfully deduce the underlying near-optimal $x , y$ representation, even when the raw observation is given as an image.
+
+![](images/e9a64692ab22d04cb52d600612569571640b0b5574d5ae4a76421987b468dd3c.jpg)  
+Figure 4: We investigate importance of various observation coordinates in learned representations on a difficult block-moving task. In this task, a simulated robotic ant must move a small red block from beginning to end of a $\supset$ -shaped corridor. Observations include both ant and block $x , y$ coordinates. We show the trajectory of the learned representations on the right (cyan). At four time steps, we also plot the resulting representations after perturbing the observation’s ant coordinates (green) or the observation’s block coordinates (magenta). The learned representations put a greater emphasis (i.e., higher sensitivity) on the block coordinates, which makes sense for this task as the external reward is primarily determined by the position of the block.
+
+We provide quantitative results in Figure 3. In these experiments, the representation is learned concurrently while learning a full hierarchical policy (according to the procedure in Nachum et al. (2018)). Therefore, this setting is especially difficult since the representation learning must learn good representations even when the behavior policy is very far from optimal. Accordingly, we find that most baseline methods completely fail to make any progress. Only our proposed method is able to approach the performance of the XY oracle.
+
+For the ‘Block’ environments, we were curious what our representation learning objective would learn, since the $x , y$ coordinate of the agent is not the only near-optimal representation. For example, another suitable representation is the $x , y$ coordinates of the small block. To investigate this, we plotted (Figure 4) the trajectory of the learned representations of a successful policy (cyan), along with the representations of the same observations with agent $x , y$ perturbed (green) or with block $x , y$ perturbed (magenta). We find that the learned representations greatly emphasize the block $x , y$ coordinates over the agent $x , y$ coordinates, although in the beginning of the episode, there is a healthy mix of the two.
+
+# 8 CONCLUSION
+
+We have presented a principled approach to representation learning in hierarchical RL. Our approach is motivated by the desire to achieve maximum possible return, hence our notion of sub-optimality is in terms of optimal state values. Although this notion of sub-optimality is intractable to optimize directly, we are able to derive a mathematical relationship between it and a specific form of representation learning. Our resulting representation learning objective is practical and achieves impressive results on a suite of high-dimensional, continuous-control tasks.
+
+# ACKNOWLEDGMENTS
+
+We thank Bo Dai, Luke Metz, and others on the Google Brain team for insightful comments and discussions.
+
+# REFERENCES
+
+David Abel, D Ellis Hershkowitz, and Michael L Littman. Near optimal behavior via approximate state abstraction. arXiv preprint arXiv:1701.04113, 2017.   
+Joshua Achiam, David Held, Aviv Tamar, and Pieter Abbeel. Constrained policy optimization. arXiv preprint arXiv:1705.10528, 2017.   
+Pierre-Luc Bacon, Jean Harb, and Doina Precup. The option-critic architecture. In AAAI, pp. 1726– 1734, 2017.   
+Andrew G Barto and Sridhar Mahadevan. Recent advances in hierarchical reinforcement learning. Discrete Event Dynamic Systems, 13(4):341–379, 2003.   
+Dimitri P Bertsekas and David Alfred Castanon. Adaptive aggregation methods for infinite horizon dynamic programming. IEEE transactions on Automatic Control, 34(6):589–598, 1989.   
+Emma Brunskill and Lihong Li. Pac-inspired option discovery in lifelong reinforcement learning. In International Conference on Machine Learning, pp. 316–324, 2014.   
+Peter Dayan and Geoffrey E Hinton. Feudal reinforcement learning. In Advances in neural information processing systems, pp. 271–278, 1993.   
+Thomas Dean and Robert Givan. Model minimization in markov decision processes. In AAAI/IAAI, pp. 106–111, 1997.   
+Thomas G Dietterich. Hierarchical reinforcement learning with the maxq value function decomposition. Journal of Artificial Intelligence Research, 13:227–303, 2000.
+
+Shixiang Gu, Ethan Holly, Timothy Lillicrap, and Sergey Levine. Deep reinforcement learning for robotic manipulation with asynchronous off-policy updates. In Robotics and Automation (ICRA), 2017 IEEE International Conference on, pp. 3389–3396. IEEE, 2017.
+
+Irina Higgins, Loic Matthey, Xavier Glorot, Arka Pal, Benigno Uria, Charles Blundell, Shakir Mohamed, and Alexander Lerchner. Early visual concept learning with unsupervised deep learning. arXiv preprint arXiv:1606.05579, 2016.
+
+R Devon Hjelm, Alex Fedorov, Samuel Lavoie-Marchildon, Karan Grewal, Adam Trischler, and Yoshua Bengio. Learning deep representations by mutual information estimation and maximization. arXiv preprint arXiv:1808.06670, 2018.
+
+Mohamed Ishmael Belghazi, Aristide Baratin, Sai Rajeswar, Sherjil Ozair, Yoshua Bengio, Aaron Courville, and R Devon Hjelm. Mine: Mutual information neural estimation. arXiv preprint arXiv:1801.04062, 2018.
+
+Diederik P Kingma and Max Welling. Auto-encoding variational bayes. arXiv preprint arXiv:1312.6114, 2013.
+
+Andrew Levy, Robert Platt, and Kate Saenko. Hierarchical actor-critic. arXiv preprint arXiv:1712.00948, 2017.
+
+Lihong Li, Thomas J Walsh, and Michael L Littman. Towards a unified theory of state abstraction for mdps. In ISAIM, 2006.
+
+Timothy P Lillicrap, Jonathan J Hunt, Alexander Pritzel, Nicolas Heess, Tom Erez, Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learning. arXiv preprint arXiv:1509.02971, 2015.
+
+Ofir Nachum, Shane Gu, Honglak Lee, and Sergey Levine. Data-efficient hierarchical reinforcement learning. NIPS, 2018.
+
+Ronald Parr and Stuart J Russell. Reinforcement learning with hierarchies of machines. In Advances in neural information processing systems, pp. 1043–1049, 1998.
+
+Balaraman Ravindran and Andrew G Barto. Model minimization in hierarchical reinforcement learning. In International Symposium on Abstraction, Reformulation, and Approximation, pp. 196–211. Springer, 2002.
+
+David F Rogers, Robert D Plante, Richard T Wong, and James R Evans. Aggregation and disaggregation techniques and methodology in optimization. Operations Research, 39(4):553–582, 1991.
+
+Jurgen Schmidhuber and Reiner Wahnsiedler. Planning simple trajectories using neural subgoal ¨ generators. In From Animals to Animats 2: Proceedings of the Second International Conference on Simulation of Adaptive Behavior, volume 2, pp. 196. MIT Press, 1993.
+
+John Schulman, Sergey Levine, Pieter Abbeel, Michael Jordan, and Philipp Moritz. Trust region policy optimization. In International Conference on Machine Learning, pp. 1889–1897, 2015.
+
+Jonathan Sorg and Satinder Singh. Transfer via soft homomorphisms. In Proceedings of The 8th International Conference on Autonomous Agents and Multiagent Systems-Volume 2, pp. 741–748. International Foundation for Autonomous Agents and Multiagent Systems, 2009.
+
+Susanne Still and Doina Precup. An information-theoretic approach to curiosity-driven reinforcement learning. Theory in Biosciences, 131(3):139–148, 2012.
+
+Richard S Sutton, Doina Precup, and Satinder Singh. Between mdps and semi-mdps: A framework for temporal abstraction in reinforcement learning. Artificial intelligence, 112(1-2):181– 211, 1999.
+
+Philip S Thomas and Andrew G Barto. Motor primitive discovery. In Development and Learning and Epigenetic Robotics (ICDL), 2012 IEEE International Conference on, pp. 1–8. IEEE, 2012.
+
+Emanuel Todorov, Tom Erez, and Yuval Tassa. Mujoco: A physics engine for model-based control. In Intelligent Robots and Systems (IROS), 2012 IEEE/RSJ International Conference on, pp. 5026– 5033. IEEE, 2012.
+
+Aaron van den Oord, Yazhe Li, and Oriol Vinyals. Representation learning with contrastive predictive coding. arXiv preprint arXiv:1807.03748, 2018.
+
+Benjamin Van Roy. Performance loss bounds for approximate value iteration with state aggregation. Mathematics of Operations Research, 31(2):234–244, 2006.
+
+Alexander Sasha Vezhnevets, Simon Osindero, Tom Schaul, Nicolas Heess, Max Jaderberg, David Silver, and Koray Kavukcuoglu. Feudal networks for hierarchical reinforcement learning. arXiv preprint arXiv:1703.01161, 2017.
+
+Manuel Watter, Jost Springenberg, Joschka Boedecker, and Martin Riedmiller. Embed to control: A locally linear latent dynamics model for control from raw images. In Advances in neural information processing systems, pp. 2746–2754, 2015.
+
+Ward Whitt. Approximations of dynamic programs, i. Mathematics of Operations Research, 3(3): 231–243, 1978.
+
+# A PROOF OF THEOREM 3 (GENERALIZATION OF THEOREM 1)
+
+Consider the sub-optimality with respect to a specific state $s _ { 0 }$ , $V ^ { \pi ^ { * } } ( s _ { 0 } ) - V ^ { \pi _ { \mathrm { h i e r } } ^ { * } } ( s _ { 0 } )$ . Recall that $\pi ^ { * }$ is the hierarchical result of a policy $\pi _ { \mathrm { h i } } ^ { * * } : S  \Delta ( \Pi )$ , and note that $\pi _ { \mathrm { h i } } ^ { * * }$ may be assumed to be deterministic due to the Markovian nature of $\mathcal { M }$ . We may use the mapping $\varphi$ to transform $\pi _ { \mathrm { h i } } ^ { * * }$ to a high-level policy $\pi _ { \mathrm { h i } }$ on $G$ and using the mapping $\Psi$ :
+
+$$
+g \sim \pi _ { \mathrm { h i } } ( - | s ) \equiv \pi \sim \pi _ { \mathrm { h i } } ^ { * * } ( - | s ) , g : = \varphi ( s , \pi ) .
+$$
+
+Let $\pi _ { \mathrm { h i e r } }$ be the corresponding hierarchical policy. We will bound the quantity $V ^ { \pi ^ { * } } ( s _ { 0 } ) - V ^ { \pi _ { \mathrm { h i e r } } } ( s _ { 0 } ) .$ , which will bound $V ^ { \pi ^ { * } } ( s _ { 0 } ) - V ^ { \pi _ { \mathrm { h i e r } } ^ { * } } ( s _ { 0 } )$ . We follow logic similar to Achiam et al. (2017) and begin by bounding the total variation divergence between the $\gamma$ -discounted state visitation frequencies of the two policies.
+
+Denote the $k$ -step state transition distributions using either $\pi ^ { * }$ or $\pi _ { \mathrm { h i e r } }$ as,
+
+$$
+\begin{array} { r l } & { \quad P _ { * } ^ { k } ( s ^ { \prime } | s ) = P _ { \pi _ { \mathrm { h i } } ^ { * * } ( s ) } ( s _ { t + k } = s ^ { \prime } | s _ { t } = s ) , } \\ & { \quad P _ { \mathrm { h i e r } } ^ { k } ( s ^ { \prime } | s ) = P _ { \Psi ( s , \pi _ { \mathrm { h i } } ( s ) ) } ( s _ { t + k } = s ^ { \prime } | s _ { t } = s ) , } \end{array}
+$$
+
+for $k \in [ 1 , c ]$ . Considering $P _ { * } , P _ { \mathrm { h i e r } }$ as linear operators, we may express the state visitation frequencies $d _ { * } , d _ { \mathrm { h i e r } }$ of $\pi ^ { * }$ , $\pi _ { \mathrm { h i e r } }$ , respectively, as
+
+$$
+\begin{array} { r } { d _ { * } = ( 1 - \gamma ) A _ { * } ( I - \gamma ^ { c } P _ { * } ^ { c } ) ^ { - 1 } \mu , \qquad } \\ { d _ { \mathrm { h i e r } } = ( 1 - \gamma ) A _ { \mathrm { h i e r } } ( I - \gamma ^ { c } P _ { \mathrm { h i e r } } ^ { c } ) ^ { - 1 } \mu , \qquad } \end{array}
+$$
+
+where $\mu$ is a Dirac $\delta$ distribution centered at $s _ { 0 }$ and
+
+$$
+\begin{array} { r } { A _ { * } = I + \displaystyle \sum _ { k = 1 } ^ { c - 1 } \gamma ^ { k } P _ { * } ^ { k } , } \\ { A _ { \mathrm { h i e r } } = I + \displaystyle \sum _ { k = 1 } ^ { c - 1 } \gamma ^ { k } P _ { \mathrm { h i e r } } ^ { k } . } \end{array}
+$$
+
+We will use $d _ { * } ^ { c } , d _ { \mathrm { h i e r } } ^ { c }$ to denote the every- $c$ -steps $\gamma$ -discounted state frequencies of $\pi ^ { * }$ , $\pi _ { \mathrm { h i e r } }$ ; i.e.,
+
+$$
+\begin{array} { c } { d _ { \ast } ^ { c } = ( 1 - \gamma ^ { c } ) ( I - \gamma ^ { c } P _ { \ast } ^ { c } ) ^ { - 1 } \mu , } \\ { d _ { \mathrm { h i e r } } ^ { c } = ( 1 - \gamma ^ { c } ) ( I - \gamma ^ { c } P _ { \mathrm { h i e r } } ^ { c } ) ^ { - 1 } \mu . } \end{array}
+$$
+
+By the triangle inequality, we have the following bound on the total variation divergence $| d _ { \mathrm { h i e r } } - d _ { * } |$ :
+
+$$
+\begin{array} { r l } & { \left| d _ { \mathrm { h i e r } } - d _ { * } \right| \leq ( 1 - \gamma ) | A _ { \mathrm { h i e r } } ( I - \gamma ^ { c } P _ { \mathrm { h i e r } } ^ { c } ) ^ { - 1 } \mu - A _ { \mathrm { h i e r } } ( I - \gamma ^ { c } P _ { * } ^ { c } ) ^ { - 1 } \mu | } \\ & { \qquad + \left( 1 - \gamma \right) | A _ { \mathrm { h i e r } } ( I - \gamma ^ { c } P _ { * } ^ { c } ) ^ { - 1 } \mu - A _ { * } ( I - \gamma ^ { c } P _ { * } ^ { c } ) ^ { - 1 } \mu | . } \end{array}
+$$
+
+We begin by attacking the first term of Equation 28. We note that
+
+$$
+| A _ { \mathrm { h i e r } } | \leq | I | + \sum _ { k = 1 } ^ { c - 1 } \gamma ^ { k } | P _ { \mathrm { h i e r } } ^ { k } | = \frac { 1 - \gamma ^ { c } } { 1 - \gamma } .
+$$
+
+Thus the first term of Equation 28 is bounded by
+
+$$
+\begin{array} { r l } & { ( 1 - \gamma ^ { c } ) | ( I - \gamma ^ { c } P _ { \mathrm { h i e r } } ^ { c } ) ^ { - 1 } \mu - ( I - \gamma ^ { c } P _ { * } ^ { c } ) ^ { - 1 } \mu | } \\ & { \qquad = ( 1 - \gamma ^ { c } ) | ( I - \gamma ^ { c } P _ { \mathrm { h i e r } } ^ { c } ) ^ { - 1 } ( ( I - \gamma ^ { c } P _ { * } ^ { c } ) - ( I - \gamma ^ { c } P _ { \mathrm { h i e r } } ^ { c } ) ) ( I - \gamma ^ { c } P _ { * } ^ { c } ) ^ { - 1 } \mu | } \\ & { \qquad = \gamma ^ { c } | ( I - \gamma ^ { c } P _ { \mathrm { h i e r } } ^ { c } ) ^ { - 1 } ( P _ { \mathrm { h i e r } } ^ { c } - P _ { * } ^ { c } ) d _ { * } ^ { c } | . } \end{array}
+$$
+
+By expressing $( I - \gamma ^ { c } P _ { \mathrm { h i e r } } ^ { c } ) ^ { - 1 }$ as a geometric series and employing the triangle inequality, we have $| ( I - \gamma ^ { c } P _ { \mathrm { h i e r } } ^ { c } ) ^ { - 1 } | \leq ( 1 - \gamma ^ { c } ) ^ { - 1 }$ , and we thus bound the whole quantity (30) by
+
+$$
+\gamma ^ { c } ( 1 - \gamma ^ { c } ) ^ { - 1 } | ( P _ { \mathrm { h i e r } } ^ { c } - P _ { * } ^ { c } ) d _ { * } ^ { c } | .
+$$
+
+We now move to attack the second term of Equation 28. We may express this term as
+
+$$
+( 1 - \gamma ) ( 1 - \gamma ^ { c } ) ^ { - 1 } | ( A _ { \mathrm { h i e r } } - A _ { * } ) d _ { * } ^ { c } | .
+$$
+
+Furthermore, by the triangle inequality we have
+
+$$
+| ( A _ { \mathrm { h i e r } } - A _ { * } ) d _ { * } ^ { c } | \leq \sum _ { k = 1 } ^ { c - 1 } \gamma ^ { k } | ( P _ { \mathrm { h i e r } } ^ { k } - P _ { * } ^ { k } ) d _ { * } ^ { c } | .
+$$
+
+Therefore, recalling $w _ { k } = 1$ for $k < c$ and $w _ { k } = ( 1 - \gamma ) ^ { - 1 }$ for $k = c$ , we may bound the total variation of the state visitation frequencies as
+
+$$
+\begin{array} { r l } & { \displaystyle | d _ { \mathrm { h i e r } } - d _ { * } | \le \gamma ( 1 - \gamma ) ( 1 - \gamma ^ { c } ) ^ { - 1 } \sum _ { k = 1 } ^ { c } \gamma ^ { k - 1 } w _ { k } | ( P _ { \mathrm { h i e r } } ^ { k } - P _ { * } ^ { k } ) d _ { * } ^ { c } | } \\ & { \qquad = 2 \gamma ( 1 - \gamma ) ( 1 - \gamma ^ { c } ) ^ { - 1 } \displaystyle \sum _ { k = 1 } ^ { c } \gamma ^ { k - 1 } w _ { k } \mathbb { E } _ { s \sim d _ { * } ^ { c } } [ D _ { \mathrm { T V } } ( P _ { * } ^ { k } ( s ^ { \prime } | s ) | | P _ { \mathrm { h i e r } } ^ { k } ( s ^ { \prime } | s ) ) ] } \\ & { \qquad = 2 \gamma ( 1 - \gamma ) ( 1 - \gamma ^ { c } ) ^ { - 1 } \mathbb { E } _ { s \sim d _ { * } ^ { c } } \left[ \displaystyle \sum _ { k = 1 } ^ { c } \gamma ^ { k - 1 } w _ { k } D _ { \mathrm { T V } } ( P _ { * } ^ { k } ( s ^ { \prime } | s ) | | P _ { \mathrm { h i e r } } ^ { k } ( s ^ { \prime } | s ) ) \right] . } \end{array}
+$$
+
+By condition 7 of Theorem 3 we have,
+
+$$
+| d _ { \mathrm { h i e r } } - d _ { * } | \le 2 \gamma ( 1 - \gamma ) ( 1 - \gamma ^ { c } ) ^ { - 1 } \overline { { w } } \epsilon
+$$
+
+We now move to considering the difference in values. We have
+
+$$
+\begin{array} { l } { { V ^ { \pi ^ { * } } ( s _ { 0 } ) = ( 1 - \gamma ) ^ { - 1 } \displaystyle \int _ { S } d _ { * } ( s ) R ( s ) d s , } } \\ { { V ^ { \pi _ { \mathrm { h i e r } } } ( s _ { 0 } ) = ( 1 - \gamma ) ^ { - 1 } \displaystyle \int _ { S } d _ { \mathrm { h i e r } } ( s ) R ( s ) d s . } } \end{array}
+$$
+
+Therefore, we have
+
+$$
+\begin{array} { r l } & { \bigl | V ^ { \pi ^ { * } } ( s _ { 0 } ) - V ^ { \pi _ { \mathrm { h i e r } } } ( s _ { 0 } ) \bigr | \le ( 1 - \gamma ) ^ { - 1 } R _ { m a x } \bigl | d _ { \mathrm { h i e r } } - d _ { * } \bigr | } \\ & { \qquad \le \displaystyle \frac { 2 \gamma } { 1 - \gamma ^ { c } } R _ { m a x } \overline { w } \epsilon , } \end{array}
+$$
+
+as desired.
+
+# B PROOF OF CLAIM 4 (GENERALIZATION OF CLAIM 2)
+
+Consider a specific $s _ { t } , \pi$ . Let $K ( s ^ { \prime } | s _ { t } , \pi ) \propto \rho ( s ^ { \prime } ) \exp ( - D ( f ( s ^ { \prime } ) , \varphi ( s _ { t } , \pi ) ) )$ . Note that the definition of $\Psi \big ( s _ { t } , \varphi ( s _ { t } , \pi ) \big )$ may be expressed in terms of a KL:
+
+$$
+\Psi \big ( s _ { t } , \varphi \big ( s _ { t } , \pi \big ) \big ) = \underset { \pi ^ { \prime } \in \Pi } { \arg \operatorname* { m i n } } \frac { 1 } { \overline { { w } } } \sum _ { k = 1 } ^ { c } \gamma ^ { k - 1 } w _ { k } D _ { \mathrm { K L } } \big ( P _ { \pi ^ { \prime } } \big ( s _ { t + k } \big | s _ { t } \big ) \big | \big | K \big ( s _ { t + k } \big | s _ { t } , \pi \big ) \big ) .
+$$
+
+Therefore we have,
+
+$$
+\begin{array} { r l r } {  { \frac { 1 } { \overline { { w } } } \sum _ { k = 1 } ^ { c } \gamma ^ { k - 1 } w _ { k } D _ { \mathrm { K L } } \big ( P _ { \Psi ( s _ { t } , \varphi ( s _ { t } , \pi ) ) } { \big ( } s _ { t + k } | s _ { t } \big ) \big | | K ( s _ { t + k } | s _ { t } , \pi ) \big ) } } \\ & { } & { \leq \frac { 1 } { \overline { { w } } } \displaystyle \sum _ { k = 1 } ^ { c } \gamma ^ { k - 1 } w _ { k } D _ { \mathrm { K L } } \big ( P _ { \pi } ( s _ { t + k } | s _ { t } ) | | K ( s _ { t + k } | s _ { t } , \pi ) \big ) . } \end{array}
+$$
+
+By condition 8 we have,
+
+$$
+\frac { 1 } { \overline { { w } } } \sum _ { k = 1 } ^ { c } \gamma ^ { k - 1 } w _ { k } D _ { \mathrm { K L } } ( P _ { \pi } ( s _ { t + k } | s _ { t } ) | | K ( s _ { t + k } | s _ { t } , \pi ) ) \leq \epsilon ^ { 2 } / 8 .
+$$
+
+Jensen’s inequality on the sqrt function then implies
+
+$$
+\frac { 1 } { \overline { { w } } } \sum _ { k = 1 } ^ { c } \gamma ^ { k - 1 } w _ { k } \sqrt { 2 D _ { \mathrm { K L } } ( P _ { \pi } ( s _ { t + k } | s _ { t } ) | | K ( s _ { t + k } | s _ { t } , \pi ) ) } \le \epsilon / 2 .
+$$
+
+Pinsker’s inequality now yields,
+
+$$
+\frac { 1 } { \overline { { w } } } \sum _ { k = 1 } ^ { c } \gamma ^ { k - 1 } w _ { k } D _ { \mathrm { T V } } \big ( P _ { \pi } \big ( s _ { t + k } \big | s _ { t } \big ) \big | \big | K \big ( s _ { t + k } \big | s _ { t } , \pi \big ) \big ) \leq \epsilon / 2 .
+$$
+
+Similarly Jensen’s and Pinsker’s inequality on the LHS of Equation 43 yields
+
+$$
+\frac { 1 } { \overline { { w } } } \sum _ { k = 1 } ^ { c } \gamma ^ { k - 1 } w _ { k } D _ { \mathrm { T V } } \big ( P _ { \Psi ( s _ { t } , \varphi ( s _ { t } , \pi ) ) } ( s _ { t + k } | s _ { t } ) | | K ( s _ { t + k } | s _ { t } , \pi ) \big ) \leq \epsilon / 2 .
+$$
+
+The triangle inequality and Equations 46 and 47 then give us,
+
+$$
+\begin{array} { l } { \displaystyle \frac { 1 } { \overline { { w } } } \sum _ { k = 1 } ^ { c } \gamma ^ { k - 1 } w _ { k } D _ { \mathrm { T V } } \big ( P _ { \pi } ( s _ { t + k } | s _ { t } ) | | P _ { \Psi ( s , \varphi ( s , \pi ) ) } ( s _ { t + k } | s _ { t } ) \big ) } \\ { \displaystyle \le \frac { 1 } { \overline { { w } } } \sum _ { k = 1 } ^ { c } \gamma ^ { k - 1 } w _ { k } \big ( D _ { \mathrm { T V } } ( P _ { \pi } ( s _ { t + k } | s _ { t } ) | | K ( s _ { t + k } | s _ { t } , \pi ) ) + D _ { \mathrm { T V } } ( P _ { \Psi ( s _ { t } , \varphi ( s _ { t } , \pi ) ) } ( s _ { t + k } | s _ { t } ) | | K ( s _ { t + k } | s _ { t } , \pi ) ) \big ) } \end{array}
+$$
+
+as desired.
+
+# C EXPERIMENTAL DETAILS
+
+# C.1 ENVIRONMENTS
+
+The environments for Ant Maze, Ant Push, and Ant Fall are as described in Nachum et al. (2018). During training, target $( x , y )$ locations are selected randomly from all possible points in the environment (in Ant Fall, the target includes a $z$ coordinate as well). Final results are evaluated on a single difficult target point, equal to that used in Nachum et al. (2018).
+
+The Point Maze is equivalent to the Ant Maze, with size scaled down by a factor of 2 and the agent replaced with a point mass, which is controlled by actions of dimension two – one action determines a rotation on the pivot of the point mass and the other action determines a push or pull on the point mass in the direction of the pivot.
+
+For the ‘Images’ versions of these environments, we zero-out the $x , y$ coordinates in the observation and append a low-resolution $5 \times 5 \times 3$ top-down view of the environment. The view is centered on the agent and each pixel covers the size of a large block (size equal to width of the corridor in Ant Maze). The 3 channels correspond to (1) immovable blocks (walls, gray in the videos), (2) movable blocks (shown in red in videos), and (3) chasms where the agent may fall.
+
+![](images/fea06edf2918abd8a9aaca69f2797b3551aed0900ff66da620e51c3636e64eb3.jpg)  
+Figure 5: The tasks we consider in this paper. Each task is a form of navigation. The agent must navigate itself (or a small red block in ‘Block’ tasks) to the target location (green arrow). We also show an example top-down view image (from an episode on the Ant Maze task). The image is centered on the agent and shows walls and blocks (at times split across multiple pixels).
+
+The Ant Block environment puts the ant in a $1 6 \times 1 6$ square room next to a $0 . 8 \times 0 . 8 \times 0 . 4$ small movable block. The agent is rewarded based on negative L2 distance of the block to a desired target location. During training, these target locations are sampled randomly from all possible locations. Evaluation is on a target location diagonally opposite the ant.
+
+The Ant Block Maze environment consists of the same ant and small movable block in a $\supset$ -shaped corridor. During training, these target locations are sampled randomly from all possible locations. Evaluation is on a target location at the end of the corridor.
+
+# C.2 TRAINING DETAILS
+
+We follow the basic training details used in Nachum et al. (2018). Some differences are listed below:
+
+• We input the whole observation to the lower-level policy (Nachum et al. (2018) zero-out the $x , y$ coordinates for the lower-level policy).   
+• We use a Huber function for $D$ , the distance function used to compute the low-level reward.   
+• We use a goal dimension of size 2. We train the higher-level policy to output actions in $[ - 1 0 , 1 0 ] ^ { 2 }$ . These actions correspond to desired deltas in state representation.   
+• We use a Gaussian with standard deviation 5 for high-level exploration.   
+• Additional differences in low-level training (e.g. reward weights and discounting) are implemented according to Section 5.
+
+We parameterize $f _ { \theta }$ with a feed-forward neural network with two hidden layers of dimension 100 using relu activations. The network structure for $\varphi _ { \theta }$ is identical, except using hidden layer dimensions 400 and 300. We also parameterize $\varphi ( s , \pi ) : = f _ { \boldsymbol \theta } ( s ) + \varphi _ { \boldsymbol \theta } ( s , \pi )$ . These networks are trained with the Adam optimizer using learning rate 0.0001.
+
+![](images/fb48edaf2b4a881dcabe74c2ce1e69179d1c19d61947cc59e168081333bbfce1.jpg)  
+D OBJECTIVE FUNCTION EVALUATION   
+Figure 6: For our method, we utilize an objective based on Equation 8. The objective is similar to mutual information maximizing objectives (CPC; van den Oord et al. (2018)). We compare to variants of our method that are implemented more in the style of CPC. Although we find that using a dot product rather than distance function $D$ is detrimental, a number of distance-based variants of our approach may perform similarly.
+
+E $\beta$ -VAE
+
+![](images/3643d17e6b71c137060e7c9d3583c2d71444105a8a2812b4904b92274c11664e.jpg)  
+Figure 7: We provide additional results comparing to variants of $\beta$ -VAE (Higgins et al., 2016). We find that even with this additional hyperparameter, the VAE approach to representation learning does not perform well outside of the simple point mass environment. The drawback of the VAE is that it is encouraged to reconstruct the entire observation, despite the fact that much of it is unimportant and possibly exhibits high variance (e.g. ant joint velocities). This means that outside of environments with high-information state observation features, a VAE approach to representation learning will suffer.
+
+# F GENERALIZATION CAPABILITY
+
+![](images/24a8e1ee82e49154c2fe07f4789cf0496368ffa1029bc153094dd33aef279825.jpg)  
+Figure 8: We evaluate the ability of our learned representations to transfer from one task to another. For these experiments, we took a representation function $f$ learned on Ant Maze, fixed it, and then used it to learn a hierarchical policy on a completely different task. We evaluated the ability of the representation to transfer to “Reflected Ant Maze” (same as Ant Maze but the maze shape is changed from $\cdot \supset '$ to $\bullet _ { \bigcap } ,$ ) and “Ant Push”. We find that the representations are robust these changes to the environment and can generalize successfully. We are able to learn well-performing policies in these distinct environments even though the representation used was learned with respect to a different task.
+
+# G ADDITIONAL QUALITATIVE RESULTS
+
+![](images/f241a55943b7179ee271acd9ebe3cbd368f9e363ba8f168d5c279b3c9ae3f08d.jpg)  
+Figure 9: We replicate the results of Figure 2 but with representations learned according to data collected by a random higher-level policy. In this setting, when there is even less of a connection between the representation learning objective and the task objective, our method is able to recover near-ideal representations.
+
+# H COMPARISON TO HIRO
+
+![](images/6f91b431e3ccac99bfcb47c8b5227be2f60406c570af3091e578df4e3195dfc7.jpg)  
+Figure 10: Results of our method compared to the original formulation of HIRO (Nachum et al., 2018). The representation used in the original formulation of HIRO is a type of oracle - sub-goals are defined as only the position-based (i.e., not velocity-based) components of the agent observation. In our own experiments, we found this method to perform similarly to the XY oracle in non-image tasks. However, when the state observation is more complex (images) performance is much worse.
+
+Algorithm 1 Representation learning for hierarchical RL.
+
+Input: Replay buffer $\mathcal { D }$ , number of training steps $N$ , batch size $B$ , parameterizations $f _ { \theta } , \varphi _ { \theta } , \pi _ { \mathrm { h i } } ^ { \phi } , \bar { \pi } _ { \mathrm { l o } } ^ { \phi }$ y
+
+function $E s t L o g P a r t ( \widetilde { S } , s _ { t } , a _ { t : t + c - 1 } )$ ## Equation 15 Return $\begin{array} { r } { \log \frac { 1 } { | \widetilde { S } | } \sum _ { \widetilde { s } \in \widetilde { S } } \exp ( - D ( f _ { \theta } ( \widetilde { s } ) , \varphi _ { \theta } ( s _ { t } , a _ { t : t + c - 1 } ) ) ) } \end{array}$ ).
+
+# end function
+
+function CompLowRewar $d ( g , s _ { t } , s ^ { \prime } , a _ { t : t + c - 1 } , L )$ ## Equation 18 Return $- D ( f _ { \theta } ( s ^ { \prime } ) , g ) + D ( f _ { \theta } ( s ^ { \prime } ) , \varphi _ { \theta } ( s _ { t } , a _ { t : t + c - 1 } ) ) + L$ .
+
+# end function
+
+function CompReprLoss $\ : \ : \beta ( s _ { t } , s ^ { \prime } , a _ { t : t + c - 1 } , \tilde { s } , L ) \ :$ ## Equation $^ { l 4 }$ Compute attractive term $J _ { \mathrm { { a t t } } } = D ( f _ { \theta } ( s ^ { \prime } ) , \varphi _ { \theta } ( s _ { t } , a _ { t : t + c - 1 } ) )$ . Compute repulsive term $J _ { \mathrm { r e p } } = \exp ( - D ( f _ { \theta } ( \tilde { s } ) , \varphi _ { \theta } ( s _ { t } , a _ { t : t + c - 1 } ) ) - \mathrm { s t o p g r a d } ( L ) ) .$ Return Jatt + Jrep.
+
+# end function
+
+for $T = 1$ to $N$ do
+
+Sample experience $g , s , a , r , s ^ { \prime }$ and add to replay buffer $\mathcal { D }$ (Nachum et al., 2018).   
+Sample batch of $c$ -step transitions $\{ ( g ^ { ( i ) } , s _ { t : t + c } ^ { ( i ) } , a _ { t : t + c - 1 } ^ { ( i ) } , r _ { t : t + c - 1 } ^ { ( i ) } ) \} _ { i = 1 } ^ { B } \sim \mathcal { D }$ .   
+Sample indices into transition: $\{ k ^ { ( i ) } \} _ { i = 1 } ^ { B } \sim [ 1 , c ] ^ { B }$ .   
+Sample batch of states $\widetilde { S } = \{ \tilde { s } ^ { ( i ) } \} _ { i = 1 } ^ { B } \sim \mathcal { D }$ .   
+Estimate log-partitions $\{ L ^ { ( i ) } \} _ { i = 1 } ^ { B } = \{ E s t L o g P a r t ( \widetilde { S } , s _ { t } ^ { ( i ) } , a _ { t : t + c - 1 } ^ { ( i ) } ) \} _ { i = 1 } ^ { B } .$
+
+// Reinforcement learning
+
+Update Compute low-level rewards $\pi _ { \mathrm { l o } } ^ { \phi }$ i=1  (Nachum et al., 2018) with experience $\{ \tilde { r } ^ { ( i ) } \} _ { i = 1 } ^ { B } = \{ C o m p L o w R e w a r d ( g ^ { ( i ) } , s _ { t } ^ { ( i ) } , s _ { t + k ^ { ( i ) } } ^ { ( i ) } , a _ { t : t + c - 1 } ^ { ( i ) } , L ^ { ( i ) } ) \} _ { i = 1 } ^ { B } .$ $\{ ( g ^ { ( i ) } , s _ { t + k ^ { ( i ) } - 1 } ^ { ( i ) } , a _ { t + k ^ { ( i ) } - 1 } ^ { ( i ) } , \tilde { r } ^ { ( i ) } , s _ { t + k ^ { ( i ) } } ^ { ( i ) } ) \} _ { i = 1 } ^ { B } .$ i Update $\pi _ { \mathrm { h i } } ^ { \phi }$ (Nachum et al., 2018) with experience $\{ ( g ^ { ( i ) } , s _ { t : t + c } ^ { ( i ) } , a _ { t : t + c - 1 } ^ { ( i ) } , r _ { t : t + c - 1 } ^ { ( i ) } ) \} _ { i = 1 } ^ { B }$ .
+
+// RepresentaCompute los $\begin{array} { r } { \mathfrak { s } J = \frac { 1 } { B } \sum _ { i = 1 } ^ { \tilde { B } } w _ { k ^ { ( i ) } } \gamma ^ { k ^ { ( i ) } - 1 } C o m p R e p r L o s s ( k ^ { ( i ) } , \mathfrak { s } _ { t } ^ { ( i ) } , \mathfrak { s } _ { t + k ^ { ( i ) } } ^ { ( i ) } , \mathfrak { a } _ { t : t + c - 1 } ^ { ( i ) } , \tilde { \mathfrak { s } } ^ { ( i ) } , L ^ { ( i ) } ) . } \end{array}$
+
+Update $\theta$ based on $\nabla _ { \boldsymbol { \theta } } J$ .
+
+# end for

parse/train/SktLlGbRZ/SktLlGbRZ.md

@@ -0,0 +1,312 @@
+# CYCADA: CYCLE-CONSISTENT ADVERSARIAL DOMAIN ADAPTATION
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Domain adaptation is critical for success in new, unseen environments. Adversarial adaptation models applied in feature spaces discover domain invariant representations, but are difficult to visualize and sometimes fail to capture pixel-level and low-level domain shifts. Recent work has shown that generative adversarial networks combined with cycle-consistency constraints are surprisingly effective at mapping images between domains, even without the use of aligned image pairs. We propose a novel discriminatively-trained Cycle-Consistent Adversarial Domain Adaptation model. CyCADA adapts representations at both the pixel-level and feature-level, enforces cycle-consistency while leveraging a task loss, and does not require aligned pairs. Our model can be applied in a variety of visual recognition and prediction settings. We show new state-of-the-art results across multiple adaptation tasks, including digit classification and semantic segmentation of road scenes demonstrating transfer from synthetic to real world domains.
+
+# 1 INTRODUCTION
+
+Deep neural networks excel at learning from large amounts of data, but can be poor at generalizing learned knowledge to new datasets or environments. Even a slight departure from a network’s training domain can cause it to make spurious predictions and significantly hurt its performance (Tzeng et al., 2017). The visual domain shift from non-photorealistic synthetic data to real images presents an even more significant challenge. While we would like to train models on large amounts of synthetic data such as data collected from graphics game engines, such models fail to generalize to real-world imagery. For example, a state-of-the-art semantic segmentation model trained on synthetic dashcam data fails to segment the road in real images, and its overall per-pixel label accuracy drops from $93 \%$ (if trained on real imagery) to $54 \%$ (if trained only on synthetic data, see Table 5).
+
+Feature-level unsupervised domain adaptation methods address this problem by aligning the features extracted from the network across the source (e.g. synthetic) and target (e.g. real) domains, without any labeled target samples. Alignment typically involves minimizing some measure of distance between the source and target feature distributions, such as maximum mean discrepancy (Long & Wang, 2015), correlation distance (Sun & Saenko, 2016), or adversarial discriminator accuracy (Ganin & Lempitsky, 2015; Tzeng et al., 2017). This class of techniques suffers from two main limitations. First, aligning marginal distributions does not enforce any semantic consistency, e.g. target features of a car may be mapped to source features of a bicycle. Second, alignment at higher levels of a deep representation can fail to model aspects of low-level appearance variance which are crucial for the end visual task.
+
+Generative pixel-level domain adaptation models perform similar distribution alignment—not in feature space but rather in raw pixel space—translating source data to the “style” of a target domain. Recent methods can learn to translate images given only unsupervised data from both domains (Bousmalis et al., 2017b; Liu & Tuzel, 2016b; Shrivastava et al., 2017). The results are visually compelling, but such image-space models have only been shown to work for small image sizes and limited domain shifts. A more recent approach (Bousmalis et al., 2017a) was applied to larger (but still not high resolution) images, but in a controlled environment with visually simple images for robotic applications. Furthermore, they also do not necessarily preserve content: while the translated image may “look” like it came from the right domain, crucial semantic information may be lost. For example, a model adapting from line-drawings to photos could learn to make a line-drawing of a cat look like a photo of a dog.
+
+![](images/c8c6d6b6c25017e0b5fc2f1561ac7a86acb647cb836c719750cf4f0e1bf1e791.jpg)  
+Figure 1: We propose CyCADA, an adversarial unsupervised adaptation algorithm which uses cycle and semantic consistency to perform adaptation at multiple levels in a deep network. Our model provides significant performance improvements over source model baselines.
+
+Table 1: Our model, CyCADA, may use pixel, feature, and semantic information during adaptation while learning an invertible mapping through cycle consistency.   
+
+<table><tr><td></td><td>Pixel Loss</td><td>Feature Loss</td><td>Semantic Loss</td><td>Cycle Consistent</td></tr><tr><td>CycleGAN (Zhu et al., 2017)</td><td>√</td><td></td><td></td><td>√</td></tr><tr><td>Feature Adapt (Ganin &amp; Lempitsky,2015; Tzeng et al., 2017)</td><td></td><td>1</td><td>√</td><td></td></tr><tr><td>Pixel Adapt (Taigman et al.,2017a; Bousmalis et al., 2017b)</td><td></td><td></td><td></td><td></td></tr><tr><td>CyCADA</td><td>?</td><td>√</td><td>√</td><td>√</td></tr></table>
+
+How can we encourage the model to preserve semantic information in the process of distribution alignment? In this paper, we explore a simple yet powerful idea: give an additional objective to the model to reconstruct the original data from the adapted version. Cycle-consistency was recently proposed in a cross-domain image generation GAN model, CycleGAN (Zhu et al., 2017), which showed transformative image-to-image generation results, but was agnostic to any particular task.
+
+We propose Cycle-Consistent Adversarial Domain Adaptation (CyCADA), which adapts representations at both the pixel-level and feature-level while enforcing pixel and semantic consistency. We use a reconstruction (cycle-consistency) loss to enforce the cross-domain transformation to preserve pixel information and a semantic labeling loss to enforce semantic consistency. CyCADA unifies prior feature-level (Ganin & Lempitsky, 2015; Tzeng et al., 2017) and image-level (Liu & Tuzel, 2016b; Bousmalis et al., 2017b; Shrivastava et al., 2017) adversarial domain adaptation methods together with cycle-consistent image-to-image translation techniques (Zhu et al., 2017), as illustrated in Table 1. It is applicable across a range of deep architectures and/or representation levels, and has several advantages over existing unsupervised domain adaptation methods.
+
+We apply our CyCADA model to the task of digit recognition across domains and the task of semantic segmentation of urban scenes across domains. Experiments show that our model achieves state of the art results on digit adaptation, cross-season adaptation in synthetic data, and on the challenging synthetic-to-real scenario. In the latter case, it improves per-pixel accuracy from $54 \%$ to $83 \%$ , nearly closing the gap to the target-trained model.
+
+Our experiments confirm that domain adaptation can benefit greatly from cycle-consistent pixel transformations, and that this is especially important for pixel-level semantic segmentation with contemporary FCN architectures. We demonstrate that enforcing semantic consistency between input and stylized images prevents label flipping on the large shift between SVHN and MNIST (example, prevents a SVHN 9 from being mapped into an MNIST 2). Interestingly, on our semantic segmentation tasks (GTA to CityScapes) we did not observe label flipping to be a major source of error, even without the semantic consistency loss. Because of this, and due to memory constraints, we do not include this loss for the segmentation tasks. Further, we show that adaptation at both the pixel and representation level can offer complementary improvements with joint pixel-space and feature adaptation leading to the highest performing model for digit classification tasks.
+
+# 2 RELATED WORK
+
+The problem of visual domain adaptation was introduced along with a pairwise metric transform solution by Saenko et al. (2010) and was further popularized by the broad study of visual dataset bias (Torralba & Efros, 2011). Early deep adaptive works focused on feature space alignment through minimizing the distance between first or second order feature space statistics of the source and target (Tzeng et al., 2014; Long & Wang, 2015). These latent distribution alignment approaches were further improved through the use of domain adversarial objectives whereby a domain classifier is trained to distinguish between the source and target representations while the domain representation is learned so as to maximize the error of the domain classifier. The representation is optimized using the standard minimax objective (Ganin & Lempitsky, 2015), the symmetric confusion objective (Tzeng et al., 2015), or the inverted label objective (Tzeng et al., 2017). Each of these objectives is related to the literature on generative adversarial networks (Goodfellow et al., 2014) and follow-up work for improved training procedures for these networks (Salimans et al., 2016b; Arjovsky et al., 2017).
+
+The feature-space adaptation methods described above focus on modifications to the discriminative representation space. In contrast, other recent methods have sought adaptation in the pixel-space using various generative approaches. One advantage of pixel-space adaptation, as we have shown, is that the result may be more human interpretable, since an image from one domain can now be visualized in a new domain. CoGANs (Liu & Tuzel, 2016b) jointly learn a source and target representation through explicit weight sharing of certain layers while each source and target has a unique generative adversarial objective. Ghifary et al. (2016) uses an additional reconstruction objective in the target domain to encourage alignment in the unsupervised adaptation setting.
+
+In contrast, another approach is to directly convert the target image into a source style image (or visa versa), largely based on Generative Adversarial Networks (GANs) (Goodfellow et al., 2014). Researchers have successfully applied GANs to various applications such as image generation (Denton et al., 2015; Radford et al., 2015; Zhao et al., 2016), image editing (Zhu et al., 2016) and feature learning (Salimans et al., 2016a; Donahue et al., 2017). Recent work (Isola et al., 2016; Sangkloy et al., 2016; Karacan et al., 2016) adopt conditional GANs (Mirza & Osindero, 2014) for these image-to-image translation problems (Isola et al., 2016), but they require input-output image pairs for training, which is in general not available in domain adaptation problems.
+
+There also exist lines of work where such training pairs are not given. Yoo et al. (2016) learns a source to target encoder-decoder along with a generative adversarial objective on the reconstruction which is is applied for predicting the clothing people are wearing. The Domain Transfer Network (Taigman et al., 2017b) trains a generator to transform a source image into a target image by enforcing consistency in the embedding space. Shrivastava et al. (2017) instead uses an L1 reconstruction loss to force the generated target images to be similar to their original source images.This works well for limited domain shifts where the domains are similar in pixel-space, but can be too limiting for settings with larger domain shifts. Bousmalis et al. (2017b) use a content similarity loss to ensure the generated target image is similar to the original source image; however, this requires prior knowledge about which parts of the image stay the same across domains (e.g. foreground). Our method does not require pre-defining what content is shared between domains and instead simply translates images back to their original domains while ensuring that they remain identical to their original versions. BiGAN (Donahue et al., 2017) and ALI (Dumoulin et al., 2016) take an approach of simultaneously learning the transformations between the pixel and the latent space. More recently, Cycle-consistent Adversarial Networks (CycleGAN) (Zhu et al., 2017) produced compelling image translation results such as generating photorealistic images from impressionism paintings or transforming horses into zebras at high resolution using the cycle-consistency loss. This loss was simultaneously proposed by Yi et al. (2017) and Kim et al. (2017) to great effect as well. Our motivation comes from such findings about the effectiveness of the cycle-consistency loss.
+
+Few works have explicitly studied visual domain adaptation for the semantic segmentation task. Adaptation across weather conditions in simple road scenes was first studied by Levinkov & Fritz (2013). More recently, a convolutional domain adversarial based approached was proposed for more general drive cam scenes and for adaptation from simulated to real environments (Hoffman et al., 2016). Ros et al. (2016b) learns a multi-source model through concatenating all available labeled data and learning a single large model and then transfers to a sparsely labeled target domain through distillation (Hinton et al., 2015). Chen et al. (2017) use an adversarial objective to align both global and class-specific statistics, while mining additional temporal data from street view datasets to learn a static object prior. Zhang et al. (2017) instead perform segmentation adaptation by aligning label distributions both globally and across superpixels in an image.
+
+![](images/00e18ca8e6ced489878ab90e305256d2cd6149ed73cdf9e4e2731ca7f2db7919.jpg)  
+Figure 2: Cycle-consistent adversarial adaptation overview. By directly remapping source training data into the target domain, we remove the low-level differences between the domains, ensuring that our task model is well-conditioned on target data. We depict here the image-level adaptation as composed of the pixel GAN loss (green), the source cycle loss (red), and the source and target semantic consistency losses (black dashed) – used when needed to prevent label flipping. For clarity the target cycle is omitted. The feature-level adaptation is depicted as the feature GAN loss (orange) and the source task loss (purple).
+
+# 3 CYCLE-CONSISTENT ADVERSARIAL DOMAIN ADAPTION
+
+We consider the problem of unsupervised adaptation, where we are provided source data $X _ { S }$ , source labels $Y _ { S }$ , and target data $X _ { T }$ , but no target labels. The goal is to learn a model $f _ { T }$ that correctly predicts the label for the target data $X _ { T }$ .
+
+Pretrain Source Task Model. We begin by simply learning a source model $f _ { S }$ that can perform the task on the source data. For $K$ -way classification with a cross-entropy loss, this corresponds to
+
+$$
+\mathcal { L } _ { \mathrm { t a s k } } ( f _ { S } , X _ { S } , Y _ { S } ) = - \mathbb { E } _ { ( x _ { s } , y _ { s } ) \sim ( X _ { S } , Y _ { S } ) } \sum _ { k = 1 } ^ { K } \mathbb { 1 } _ { [ k = y _ { s } ] } \log \Big ( \sigma \big ( f _ { S } ^ { ( k ) } ( x _ { s } ) \big ) \Big )
+$$
+
+where $\sigma$ denotes the softmax function. However, while the learned model $f _ { S }$ will perform well on the source data, typically domain shift between the source and target domain leads to reduced performance when evaluating on target data.
+
+Pixel-level Adaptation. To mitigate the effects of domain shift, we follow previous adversarial adaptation approaches and learn to map samples across domains such that an adversarial discriminator is unable to distinguish the domains. By mapping samples into a common space, we enable our model to learn on source data while still generalizing to target data.
+
+To this end, we introduce a mapping from source to target $G _ { S  T }$ and train it to produce target samples that fool an adversarial discriminator $D _ { T }$ . Conversely, the adversarial discriminator attempts to classify the real target data from the source target data. This corresponds to the loss function
+
+$$
+\mathscr { L } _ { \mathrm { G A N } } ( G _ { S  T } , D _ { T } , X _ { T } , X _ { S } ) = \mathbb { E } _ { x _ { t } \sim X _ { T } } [ \log D _ { T } ( x _ { t } ) ] + \mathbb { E } _ { x _ { s } \sim X _ { S } } [ \log ( 1 - D _ { T } ( G _ { S  T } ( x _ { s } ) ) ) ] .
+$$
+
+This objective ensures that $G _ { S  T }$ , given source samples, produces convincing target samples. In turn, this ability to directly map samples between domains allows us to learn a target model $f _ { T }$ by minimizing $\tilde { \mathcal { L } } _ { \mathrm { t a s k } } ( f _ { T } , G _ { S  T } ( \bar { X _ { S } } ) , \bar { Y _ { S } } )$ (see Figure 2 green portion).
+
+However, while previous approaches that optimized similar objectives have shown effective results, in practice they can often be unstable and prone to failure. Although the GAN loss in Equation 2 ensures that $G _ { S \to T } ( x _ { s } )$ for some $x _ { s }$ will resemble data drawn from $X _ { T }$ , there is no way to guarantee that $G _ { S \to T } ( x _ { s } )$ preserves the structure or content of the original sample $x _ { s }$ .
+
+In order to encourage the source content to be preserved during the conversion process, we impose a cycle-consistency constraint on our adaptation method (Zhu et al., 2017; Yi et al., 2017; Kim et al., 2017) (see Figure 2 red portion). To this end, we introduce another mapping from target to source $G _ { T  S }$ and train it according to the same GAN loss $\mathcal { L } _ { \mathrm { G A N } } ( G _ { T  S } , D _ { S } , \mathbf { \bar { \boldsymbol { X } } } _ { S } , \mathbf { \bar { \boldsymbol { X } } } _ { T } )$ . We then require that mapping a source sample from source to target and back to the source reproduces the original sample, thereby enforcing cycle-consistency. In other words, we want $G _ { T  S } ( \bar { G } _ { S  T } ( x _ { s } ) ) \approx x _ { s }$ and $G _ { S  T } ( G _ { T  S } ( x _ { t } ) ) \approx x _ { t }$ . This is done by imposing an L1 penalty on the reconstruction error, which is referred to as the cycle-consistency loss:
+
+$$
+\begin{array} { r } { \mathcal { L } _ { \mathrm { c y c } } ( G _ { S  T } , G _ { T  S } , X _ { S } , X _ { T } ) = \mathbb { E } _ { x _ { s } \sim X _ { S } } [ | | G _ { T  S } ( G _ { S  T } ( x _ { s } ) ) - x _ { s } | | _ { 1 } ] } \\ { + \mathbb { E } _ { x _ { t } \sim X _ { T } } [ | | G _ { S  T } ( G _ { T  S } ( x _ { t } ) ) - x _ { t } | | _ { 1 } ] . } \end{array}
+$$
+
+Additionally, as we have access to source labeled data, we explicitly encourage high semantic consistency before and after image translation. We used the pretrained source task model $f _ { S }$ , as a noisy labeler by which we encourage an image to be classified in the same way after translation as it was before translation according to this classifier. Let us define the predicted label from a fixed classifier, $f$ , for a given input $X$ as $p ( f , X ) = \arg \operatorname* { m a x } ( f ( X ) )$ . Then we can define the semantic consistency before and after image translation as follows:
+
+$$
+\begin{array} { r } { \mathcal { L } _ { \mathrm { s e m } } ( G _ { S  T } , G _ { T  S } , X _ { S } , X _ { T } , f _ { S } ) = \mathcal { L } _ { \mathrm { t a s k } } ( f _ { S } , G _ { T  S } ( X _ { T } ) , p ( f _ { S } , X _ { T } ) ) } \\ { + \mathcal { L } _ { \mathrm { t a s k } } ( f _ { S } , G _ { S  T } ( X _ { S } ) , p ( f _ { S } , X _ { S } ) ) } \end{array}
+$$
+
+See Figure 2 black portion. This can be viewed as analogously to content losses in style transfer (Gatys et al., 2016) or in pixel adaptation (Taigman et al., 2017a), where the shared content to preserve is dictated by the source task model $f _ { S }$ .
+
+Feature-level Adaptation. We have thus far described an adaptation method which combines cycle consistency, semantic consistency, and adversarial objectives to produce a final target model. As a pixel-level method, the adversarial objective consists of a discriminator which distinguishes between two image sets, e.g. transformed source and real target image. Note that we could also consider a feature-level method which discriminates between the features or semantics from two image sets as viewed under a task network. This would amount to an additional feature level GAN loss (see Figure 2 orange portion):
+
+$$
+\mathcal { L } _ { \mathrm { G A N } } ( f _ { T } , D _ { \mathrm { f e a t } } , f _ { S } ( G _ { S  T } ( X _ { S } ) ) , X _ { T } ) .
+$$
+
+Taken together, these loss functions form our complete objective:
+
+$$
+\begin{array} { r l } & { \mathcal { L } _ { \mathrm { C y C A D A } } ( f _ { T } , X _ { S } , X _ { T } , Y _ { S } , G _ { S  T } , G _ { T  S } , D _ { S } , D _ { T } ) } \\ & { \qquad = \mathcal { L } _ { \mathrm { u s k } } ( f _ { T } , G _ { S  T } ( X _ { S } ) , Y _ { S } ) } \\ & { \qquad + \mathcal { L } _ { \mathrm { G A N } } ( G _ { S  T } , D _ { T } , X _ { T } , X _ { S } ) + \mathcal { L } _ { \mathrm { G A N } } ( G _ { T  S } , D _ { S } , X _ { S } , X _ { T } ) } \\ & { \qquad + \mathcal { L } _ { \mathrm { G A N } } ( f _ { T } , D _ { \mathrm { f e a t } } , f _ { S } ( G _ { S  T } ( X _ { S } ) ) , X _ { T } ) } \\ & { \qquad + \mathcal { L } _ { \mathrm { c y c } } ( G _ { S  T } , G _ { T  S } , X _ { S } , X _ { T } ) + \mathcal { L } _ { \mathrm { s e m } } ( G _ { S  T } , G _ { T  S } , X _ { S } , X _ { T } , f _ { S } ) . } \end{array}
+$$
+
+This ultimately corresponds to solving for a target model $f _ { T }$ according to the optimization problem
+
+$$
+f _ { T } ^ { * } = \underset { f _ { T } } { \arg \operatorname* { m i n } } \ \underset { G _ { S  T } } { \operatorname* { m i n } } \ \underset { D _ { S } , D _ { T } } { \operatorname* { m a x } } \ \mathcal { L } _ { \mathrm { C y C A D A } } ( f _ { T } , X _ { S } , X _ { T } , Y _ { S } , G _ { S  T } , G _ { T  S } , D _ { S } , D _ { T } ) .
+$$
+
+We have introduced a method for unsupervised adaptation which views prior adversarial objectives as operating at the pixel or feature level and generalizes to a method which may benefit from both approaches. In addition, we introduce the combination of cycle-consistency together with semantic transformation constraints to regularize the mapping from one domain to another. We apply CyCADA to both digit classification and to semantic segmentation. We implement $G _ { S }$ and $G _ { T }$ as a pixel-topixel convnet, $f _ { S }$ and $f _ { T }$ as a convnet classifier or a Fully-Convolutional Net (FCN), and $D _ { S } , D _ { T }$ and $D _ { \mathrm { f e a t } }$ as a convnet with binary outputs.
+
+# 4 EXPERIMENTS
+
+We evaluate CyCADA on several unsupervised adaptation scenarios. We first focus on adaptation for digit classification using the MNIST (LeCun et al., 1998), USPS, and Street View House Numbers
+
+<table><tr><td>Model</td><td>MNIST → USPSUSPS</td><td></td><td>→MNISTSVHN→MNIST</td></tr><tr><td>Source only</td><td>82.2 ±0.8</td><td>69.6 ± 3.8</td><td>67.1 ± 0.6</td></tr><tr><td>DANN (Ganin et al., 2016)</td><td></td><td>1</td><td>73.6</td></tr><tr><td>DTN (Taigman et al.,2017a)</td><td></td><td>=</td><td>84.4</td></tr><tr><td>CoGAN (Liu&amp; Tuzel,2016a)</td><td>91.2</td><td>89.1</td><td>-</td></tr><tr><td>ADDA (Tzeng et al., 2017)</td><td>89.4±0.2</td><td>90.1 ± 0.8</td><td>76.0 ± 1.8</td></tr><tr><td>CyCADA pixel only</td><td>95.6 ± 0.2</td><td>96.4 ± 0.1</td><td>70.3 ±0.2</td></tr><tr><td>CyCADA pixel+feat</td><td>95.6± 0.2</td><td>96.5 ± 0.1</td><td>90.4 ± 0.4</td></tr><tr><td>Target only</td><td>96.3± 0.1</td><td>99.2 ± 0.1</td><td>99.2 ±0.1</td></tr></table>
+
+![](images/cb731ed55e26a50aeacddb7117151655696d5fd16aad02a1d44332eb8e2cf8dd.jpg)  
+Table 2: Unsupervised domain adaptation across digit datasets. Our model is competitive with or outperforms state-of-the-art models for each shift. For the difficult shift of SVHN to MNIST we also note that feature space adaptation provides additional benefit beyond the pixel-only adaptation.   
+Figure 3: Ablation: Effect of Semantic or Cycle Consistency Examples of translation failures without the semantic consistency loss. Each triple contains the original SVHN image (left), the image translated into MNIST style (middle), and the image reconstructed back into SVHN (right). (a) Without semantic loss, both the GAN and cycle constraints are satisfied (translated image matches MNIST style and reconstructed image matches original), but the image translated to the target domain lacks the proper semantics. (b) Without cycle loss, the reconstruction is not satisfied and though the semantic consistency leads to some successful semantic translations (top) there are still cases of label flipping (bottom).
+
+(SVHN) (Netzer et al., 2011) datasets. After which we present results for the task of semantic image segmentation, using the GTA (Richter et al., 2016) and CityScapes (Cordts et al., 2016) datasets, see Appendix A.1.2 for an additional experiment with the SYNTHIA (Ros et al., 2016a) dataset.
+
+# 4.1 DIGIT ADAPTATION
+
+We evaluate our method across the adaptation shifts of USPS to MNIST, MNIST to USPS, and SVHN to MNIST, using the full training sets during learning phases and evaluating on the standard test sets. We report classification accuracy for each shift in Table 2 and find that our method outperforms competing approaches on average. The classifier for our method for all digit shifts uses a variant of the LeNet architecture (see A.1.1 for full implementation details). Note that the recent pixel-da method by Bousmalis et al. (2017b) presents results for only the MNIST to USPS shift and reports $9 5 . 9 \%$ accuracy, while our method achieves $9 5 . 6 \%$ accuracy. However, the pixel-da approach cross validates with some labeled data which is not an equivalent evaluation setting.
+
+Ablation: Pixel vs Feature Level Transfer. We begin by evaluating the contribution of the pixel space and feature space transfer. We find that in the case of the small domain shifts between USPS and MNIST, the pixel space adaptation by which we train a classifier using images translated using CycleGAN (Zhu et al., 2017), performs very well, outperforming or comparable to prior adaptation approaches. Feature level adaptation offers a small benefit in this case of a small pixel shift. However, for the more difficult shift of SVHN to MNIST, we find that feature level adaptation outperforms the pixel level adaptation, and importantly, both may be combined to produce an overall model which outperforms all competing methods.
+
+Ablation: No Semantic Consistency. We experiment without the addition of our semantic consistency loss and find that the standard unsupervised CycleGAN approach diverged when training SVHN to MNIST often suffering from random label flipping. Figure 3(a) demonstrates two examples where cycle constraints alone fail to have the desired behavior for our end task. An SVHN image is mapped to a convincing MNIST type image and back to a SVHN image with correct semantics. However, the MNIST-like image has mismatched semantics. Our modified version, which uses the source labels to train a weak classification model which can be used to enforce semantic consistency before and after translation, resolves this issue and produces strong performance.
+
+![](images/7643efed9d27a54f76ba16653b4cfd002fcb0abef2414cedfb529b6b75fa7e50.jpg)  
+Figure 4: GTA5 to CityScapes Semantic Segmentation. Each test CityScapes image (a) along with the corresponding predictions from the source only model (b) and our CyCADA model (c) are shown and may be compared against the ground truth annotation (d).
+
+Ablation: No Cycle Consistency. We study the result when learning without the cycle consistency loss. First note that there is no reconstruction guarantee in this case, thus in Figure 3(b) we see that the translation back to SVHN fails. In addition, we find that while the semantic loss does encourage correct semantics it relies on the weak source labeler and thus label flipping still occurs (see right image triple).
+
+# 4.2 SEMANTIC SEGMENTATION ADAPTATION
+
+The task is to assign a semantic label to each pixel in the input image, e.g. road, building, etc. We limit our evaluation to the unsupervised adaptation setting, where labels are only available in the source domain, but we are evaluated solely on our performance in the target domain.
+
+For each experiment, we use three metrics to evaluate performance. Let $n _ { i j }$ be the number of pixels of class $i$ predicted as class $j$ , let $t _ { i } = \textstyle \sum _ { j } n _ { i j }$ be the total number of pixels of class $i$ , and let $N$ be the number of classes. Our three evaluation metrics are, mean intersection-over-union (mIoU), frequency weighted intersection-over-union (fwIoU), and pixel accuracy, which are defined as follows:
+
+Cycle-consistent adversarial adaptation is general and can be applied at any layer of a network. Since optimizing the full CyCADA objective in Equation 6 end-to-end is memory-intensive in practice, we train our model in stages. First, we perform image-space adaptation and map our source data into the target domain. Next, using the adapted source data with the original source labels, we learn a task model that is suited to operating on target data. Finally, we perform another round of adaptation between the adapted source data and the target data in feature-space, using one of the intermediate layers of the task model. Additionally, we do not use the semantic loss for the segmentation experiments as it would require loading generators, discriminators, and an additional semantic segmenter into memory all at once for two images. We did not have the required memory for this at the time of submission, but leave it to future work to deploy model parallelism or experiment with larger GPU memory.
+
+To demonstrate our method’s applicability to real-world adaptation scenarios, we also evaluate our model in a challenging synthetic-to-real adaptation setting. For our synthetic source domain, we use the GTA5 dataset (Richter et al., 2016) extracted from the game Grand Theft Auto V, which contains 24966 images. We consider adaptation from GTA5 to the real-world Cityscapes dataset (Cordts et al., 2016), from which we used 19998 images without annotation for training and 500 images for validation. Both of these datasets are evaluated on the same set of 19 classes, allowing for
+
+<table><tr><td rowspan=1 colspan=6>GTA5→ Cityscapes</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>eeree</td><td rowspan=1 colspan=4>iorensaeaartBuiplingursorien Veneee                                  morirrtt             Prre rectirrnuos.iadaatiie0NOIMJ对u</td></tr><tr><td rowspan=2 colspan=1>Source onlyFCNs in the wild*CyCADA feat-onlyCyCADA pixel-onlyCyCADA pixel+feat</td><td rowspan=2 colspan=1>AAAA</td><td rowspan=2 colspan=3>A|26.0 14.9 65.15.512.98.96.02.570.02.947.0 24.50.040.012.11.50.00.00.070.4 32.4 62.114.95.410.9 14.22.779.2 21.3 64.6 44.14.270.48.07.30.03.50.085.6 30.7 74.714.4 13.0 17.6 13.75.874.6 15.8 69.9 38.23.572.3 16.05.00.13.60.083.538.376.4220.616.522.226.221.980.4 28.7 65.7 49.44.274.6 16.0 26.62.08.00.085.2 37.2 76.5 21.8 15.0 23.8 22.9 21.5880.5 31.3 60.7 50.59.076.917.128.24.59.80.0</td><td rowspan=2 colspan=1>17.9 41.9 54.027.129.2 71.5 82.534.8 73.1 82.835.4 73.8 83.6</td></tr><tr><td rowspan=1 colspan=1>34.8 73.1 82.835.4 73.8 83.6</td></tr><tr><td rowspan=1 colspan=2>Oracle - Target Super|</td><td rowspan=1 colspan=4>|A|96.4 74.5 87.1 35.337.8 36.4 46.9 60.189.0 54.3 89.8 65.6 35.9 89.4 38.6 64.1 38.6 40.5 65.160.3 87.6 93.1</td></tr><tr><td rowspan=4 colspan=1>Source onlyCyCADA feat-onlyCyCADA pixel-onlyCyCADA pixel+feat</td><td rowspan=1 colspan=1>B</td><td rowspan=4 colspan=4>42.7 26.3 51.75.56.813.8 23.6 6.9 75.511.5 36.8 49.30.946.73.45.00.05.01.421.7 47.4 62.578.1 31.171.210.314.129.8 28.120.9 74.0 16.8 51.9 53.66.165.4 8.2 20.91.813.9 5.931.7 67.4 78.463.7 24.7 69.3 21.2 17.0 30.3 33.0 32.0 80.5 25.3 62.3 62.0 15.1 73.1119.8 23.65.516.2 28.737.0 63.8 75.479.133.1 77.9 23.417.332.133.331.881.526.7 69.0 62.814.774.520.9 25.66.918.8 20.439.5 72.4 82.3</td></tr><tr><td rowspan=2 colspan=1>BB</td></tr><tr><td rowspan=1 colspan=1>5.5</td></tr><tr><td rowspan=1 colspan=1>B</td></tr><tr><td rowspan=1 colspan=1>Oracle - Target Super|</td><td rowspan=1 colspan=1>B</td><td rowspan=1 colspan=4>Bl97.379.8 88.6 32.5 48.2 56.3 63.6 73.3 89.0 58.9 93.0 78.2 55.2 92.2 45.067.339.649.973.667.489.6 94.3</td></tr></table>
+
+Table 3: Adaptation between GTA5 and Cityscapes, showing IoU for each class and mean IoU, freqweighted IoU and pixel accuracy. CyCADA significantly outperforms baselines, nearly closing the gap to the target-trained oracle on pixel accuracy. ${ } ^ { * } \mathrm { F C N s }$ in the wild is by Hoffman et al. (2016). We compare our model using two base semantic segmentation architectures (A) VGG16-FCN8s (Long et al., 2015) base network and (B) DRN-26 (Yu et al., 2017).
+
+![](images/c1ebd165b65576a5bb30ce1a2131979e40f77574234df9deeff59fccc176e169.jpg)  
+Figure 5: GTA5 to CityScapes Image Translation. Example images from the GTA5 (a) and Cityscapes (c) datasets, alongside their image-space conversions to the opposite domain, (b) and (d), respectively. Our model achieves highly realistic domain conversions.
+
+straightforward adaptation between the two domains. For an additional experiment evaluating cross-season adaptation in synthetic environments see the Appendix.
+
+Image-space adaptation also affords us the ability to visually inspect the results of the adaptation method. This is a distinct advantage over opaque feature-space adaptation methods, especially in truly unsupervised settings—without labels, there is no way to empirically evaluate the adapted model, and thus no way to verify that adaptation is improving task performance. Visually confirming that the conversions between source and target images are reasonable, while not a guarantee of improved task performance, can serve as a sanity check to ensure that adaptation is not completely diverging. This process is diagrammed in Figure 2. For implementation details please see Appendix A.1.2.
+
+# 4.2.1 SYNTHETIC TO REAL ADAPTATION
+
+To evaluate our method’s applicability to real-world adaptation settings, we investigate adaptation from synthetic to real-world imagery. The results of this evaluation are presented in Table 3 with qualitative results shown in Figure 4. Once again, CyCADA achieves state-of-the-art results, recovering approximately $40 \%$ of the performance lost to domain shift. CyCADA also improves or maintains performance on all 19 classes. Examination of fwIoU and pixel accuracy as well as individual class IoUs reveals that our method performs well on most of the common classes. Although some classes such as train and bicycle see little or no improvement, we note that those classes are poorly represented in the GTA5 data, making recognition very difficult. We compare our model against Shrivastava et al. (2017) for this setting, but found this approach did not converge and resulted in worse performance than the source only model (see Appendix for full details).
+
+We visualize the results of image-space adaptation between GTA5 and Cityscapes in Figure 5. The most obvious difference between the original images and the adapted images is the saturation levels— the GTA5 imagery is much more vivid than the Cityscapes imagery, so adaptation adjusts the colors to compensate. We also observe texture changes, which are perhaps most apparent in the road: in-game, the roads appear rough with many blemishes, but Cityscapes roads tend to be fairly uniform in appearance, so in converting from GTA5 to Cityscapes, our model removes most of the texture. Somewhat amusingly, our model has a tendency to add a hood ornament to the bottom of the image, which, while likely irrelevant to the segmentation task, serves as a further indication that image-space adaptation is producing reasonable results.
+
+# 5 CONCLUSION
+
+We presented a cycle-consistent adversarial domain adaptation method that unifies cycle-consistent adversarial models with adversarial adaptation methods. CyCADA is able to adapt even in the absence of target labels and is broadly applicable at both the pixel-level and in feature space. An image-space adaptation instantiation of CyCADA also provides additional interpretability and serves as a useful way to verify successful adaptation. Finally, we experimentally validated our model on a variety of adaptation tasks: state-of-the-art results in multiple evaluation settings indicate its effectiveness, even on challenging synthetic-to-real tasks.
+
+# REFERENCES
+
+Martin Arjovsky, Soumith Chintala, and Léon Bottou. Wasserstein gan. CoRR, abs/1701.07875, 2017. URL http://arxiv.org/abs/1701.07875.
+
+Konstantinos Bousmalis, Alex Irpan, Paul Wohlhart, Yunfei Bai, Matthew Kelcey, Mrinal Kalakrishnan, Laura Downs, Julian Ibarz, Peter Pastor, Kurt Konolige, Sergey Levine, and Vincent Vanhoucke. Using simulation and domain adaptation to improve efficiency of deep robotic grasping. CoRR, abs/1709.07857, 2017a. URL http://arxiv.org/abs/1709.07857.
+
+Konstantinos Bousmalis, Nathan Silberman, David Dohan, Dumitru Erhan, and Dilip Krishnan. Unsupervised pixel-level domain adaptation with generative adversarial networks. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), July 2017b.
+
+Yi-Hsin Chen, Wei-Yu Chen, Yu-Ting Chen, Bo-Cheng Tsai, Yu-Chiang Frank Wang, and Min Sun. No more discrimination: Cross city adaptation of road scene segmenters. In The IEEE International Conference on Computer Vision (ICCV), Oct 2017.
+
+Marius Cordts, Mohamed Omran, Sebastian Ramos, Timo Rehfeld, Markus Enzweiler, Rodrigo Benenson, Uwe Franke, Stefan Roth, and Bernt Schiele. The Cityscapes dataset for semantic urban scene understanding. In Proc. of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2016.
+
+Emily L Denton, Soumith Chintala, Rob Fergus, et al. Deep generative image models using a laplacian pyramid of adversarial networks. In Neural Information Processing Systems (NIPS), pp. 1486–1494, 2015.
+
+Jeff Donahue, Philipp Krähenbühl, and Trevor Darrell. Adversarial feature learning. In ICLR, 2017.
+
+Vincent Dumoulin, Ishmael Belghazi, Ben Poole, Alex Lamb, Martin Arjovsky, Olivier Mastropietro, and Aaron Courville. Adversarially learned inference. arXiv preprint arXiv:1606.00704, 2016.
+
+Y. Ganin, E. Ustinova, H. Ajakan, P. Germain, H. Larochelle, F. Laviolette, M. Marchand, and V. Lempitsky. Domain-adversarial training of neural networks. Journal of Machine Learning Research, 2016.
+
+Yaroslav Ganin and Victor Lempitsky. Unsupervised domain adaptation by backpropagation. In David Blei and Francis Bach (eds.), Proceedings of the 32nd International Conference on Machine Learning (ICML-15), pp. 1180–1189. JMLR Workshop and Conference Proceedings, 2015. URL http://jmlr.org/proceedings/papers/v37/ganin15.pdf.
+
+Leon A Gatys, Alexander S Ecker, and Matthias Bethge. Image style transfer using convolutional neural networks. In Computer Vision and Pattern Recognition (CVPR), pp. 2414–2423, 2016.
+
+Muhammad Ghifary, W Bastiaan Kleijn, Mengjie Zhang, David Balduzzi, and Wen Li. Deep reconstruction-classification networks for unsupervised domain adaptation. In European Conference on Computer Vision (ECCV), pp. 597–613. Springer, 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 27. 2014. URL http://papers.nips.cc/paper/ 5423-generative-adversarial-nets.pdf.
+
+G. Hinton, O. Vinyals, and J. Dean. Distilling the knowledge in a neural network. 2015.
+
+Judy Hoffman, Dequan Wang, Fisher Yu, and Trevor Darrell. FCNs in the wild: Pixel-level adversarial and constraint-based adaptation. CoRR, abs/1612.02649, 2016. URL http://arxiv.org/ abs/1612.02649.
+
+Phillip Isola, Jun-Yan Zhu, Tinghui Zhou, and Alexei A Efros. Image-to-image translation with conditional adversarial networks. arXiv preprint arXiv:1611.07004, 2016.
+
+Levent Karacan, Zeynep Akata, Aykut Erdem, and Erkut Erdem. Learning to generate images of outdoor scenes from attributes and semantic layouts. arXiv preprint arXiv:1612.00215, 2016.
+
+Taeksoo Kim, Moonsu Cha, Hyunsoo Kim, Jung Kwon Lee, and Jiwon Kim. Learning to discover cross-domain relations with generative adversarial networks. arXiv preprint arXiv:1703.05192, 2017.
+
+Y. LeCun, L. Bottou, Y. Bengio, and P. Haffner. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11):2278–2324, November 1998.
+
+Evgeny Levinkov and Mario Fritz. Sequential bayesian model update under structured scene prior for semantic road scenes labeling. In IEEE International Conference on Computer Vision (ICCV), 2013. URL http://scalable.mpi-inf.mpg.de/files/2013/10/levinkov13iccv. pdfhttp://www.d2.mpi-inf.mpg.de/sequential-bayesian-update.
+
+M.-Y. Liu and O. Tuzel. Coupled generative adversarial networks. In Advances in Neural Information Processing Systems, 2016a.
+
+Ming-Yu Liu and Oncel Tuzel. Coupled generative adversarial networks. In Neural Information Processing Systems (NIPS), 2016b.
+
+Jonathan Long, Evan Shelhamer, and Trevor Darrell. Fully convolutional networks for semantic segmentation. CVPR (to appear), November 2015.
+
+Mingsheng Long and Jianmin Wang. Learning transferable features with deep adaptation networks. In International Conference on Machine Learning (ICML), 2015.
+
+Mehdi Mirza and Simon Osindero. Conditional generative adversarial nets. CoRR, abs/1411.1784, 2014. URL http://arxiv.org/abs/1411.1784.
+
+Yuval Netzer, Tao Wang, Adam Coates, Alessandro Bissacco, Bo Wu, and Andrew Y. Ng. Reading digits in natural images with unsupervised feature learning. In NIPS Workshop on Deep Learning and Unsupervised Feature Learning 2011, 2011. URL http://ufldl.stanford.edu/ housenumbers/nips2011_housenumbers.pdf.
+
+Alec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. arXiv preprint arXiv:1511.06434, 2015.
+
+Stephan R. Richter, Vibhav Vineet, Stefan Roth, and Vladlen Koltun. Playing for data: Ground truth from computer games. In Bastian Leibe, Jiri Matas, Nicu Sebe, and Max Welling (eds.), European Conference on Computer Vision (ECCV), volume 9906 of LNCS, pp. 102–118. Springer International Publishing, 2016.
+
+German Ros, Laura Sellart, Joanna Materzynska, David Vazquez, and Antonio Lopez. The SYNTHIA Dataset: A large collection of synthetic images for semantic segmentation of urban scenes. In Proc. of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2016a.
+
+Germán Ros, Simon Stent, Pablo F. Alcantarilla, and Tomoki Watanabe. Training constrained deconvolutional networks for road scene semantic segmentation. CoRR, abs/1604.01545, 2016b. URL http://arxiv.org/abs/1604.01545.
+
+Kate Saenko, Brian Kulis, Mario Fritz, and Trevor Darrell. Adapting visual category models to new domains. In European conference on computer vision, pp. 213–226. Springer, 2010.
+
+Tim Salimans, Ian Goodfellow, Wojciech Zaremba, Vicki Cheung, Alec Radford, and Xi Chen. Improved techniques for training gans. arXiv preprint arXiv:1606.03498, 2016a.
+
+Tim Salimans, Ian J. Goodfellow, Wojciech Zaremba, Vicki Cheung, Alec Radford, and Xi Chen. Improved techniques for training gans. CoRR, abs/1606.03498, 2016b. URL http://arxiv. org/abs/1606.03498.
+
+Patsorn Sangkloy, Jingwan Lu, Chen Fang, Fisher Yu, and James Hays. Scribbler: Controlling deep image synthesis with sketch and color. arXiv preprint arXiv:1612.00835, 2016.
+
+Ashish Shrivastava, Tomas Pfister, Oncel Tuzel, Joshua Susskind, Wenda Wang, and Russell Webb. Learning from simulated and unsupervised images through adversarial training. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), July 2017.
+
+Baochen Sun and Kate Saenko. Deep CORAL: correlation alignment for deep domain adaptation. In ICCV workshop on Transferring and Adapting Source Knowledge in Computer Vision (TASK-CV), 2016.
+
+Y. Taigman, A. Polyak, and L. Wolf. Unsupervised cross-domain image generation. In International Conference on Learning Representations, 2017a.
+
+Yaniv Taigman, Adam Polyak, and Lior Wolf. Unsupervised cross-domain image generation. In International Conference on Learning Representations (ICLR), 2017b.
+
+Antonio Torralba and Alexei A. Efros. Unbiased look at dataset bias. In CVPR’11, June 2011.
+
+Eric Tzeng, Judy Hoffman, Ning Zhang, Kate Saenko, and Trevor Darrell. Deep domain confusion: Maximizing for domain invariance. CoRR, abs/1412.3474, 2014. URL http://arxiv.org/ abs/1412.3474.
+
+Eric Tzeng, Judy Hoffman, Trevor Darrell, and Kate Saenko. Simultaneous deep transfer across domains and tasks. In International Conference in Computer Vision (ICCV), 2015.
+
+Eric Tzeng, Judy Hoffman, Kate Saenko, and Trevor Darrell. Adversarial discriminative domain adaptation. In Computer Vision and Pattern Recognition (CVPR), 2017. URL http://arxiv. org/abs/1702.05464.
+
+Zili Yi, Hao Zhang, Ping Tan Gong, et al. Dualgan: Unsupervised dual learning for image-to-image translation. arXiv preprint arXiv:1704.02510, 2017.
+
+Donggeun Yoo, Namil Kim, Sunggyun Park, Anthony S. Paek, and In-So Kweon. Pixel-level domain transfer. In European Conference on Computer Vision (ECCV), 2016. URL http: //arxiv.org/abs/1603.07442.
+
+Fisher Yu, Vladlen Koltun, and Thomas Funkhouser. Dilated residual networks. In Computer Vision and Pattern Recognition (CVPR), 2017.
+
+Yang Zhang, Philip David, and Boqing Gong. Curriculum domain adaptation for semantic segmentation of urban scenes. In The IEEE International Conference on Computer Vision (ICCV), Oct 2017.
+
+Junbo Zhao, Michael Mathieu, and Yann LeCun. Energy-based generative adversarial network. arXiv preprint arXiv:1609.03126, 2016.
+
+Jun-Yan Zhu, Philipp Krähenbühl, Eli Shechtman, and Alexei A. Efros. Generative visual manipulation on the natural image manifold. In European Conference on Computer Vision (ECCV), 2016.
+
+Jun-Yan Zhu, Taesung Park, Phillip Isola, and Alexei A Efros. Unpaired image-to-image translation using cycle-consistent adversarial networks. In International Conference on Computer Vision (ICCV), 2017.
+
+![](images/6a62b2f45c133b0831590e2645f5857eaac1ec09e212af78a26171f5f7284713.jpg)  
+Figure 6: Network architectures used for digit experiments. We show here the task net $( f )$ , discriminator for feature level adaptation $( D ^ { f e a t } )$ , discriminator for image level adaptation $( D ^ { i m a g e } )$ , and generator for source to target $( G )$ – same network used for target to source.
+
+# A APPENDIX
+
+# A.1 IMPLEMENTATION DETAILS
+
+We begin by pretraining the source task model, $f _ { S }$ , using the task loss on the labeled source data. Next, we perform pixel-level adaptation using our image space GAN losses together with semantic consistency and cycle consistency losses. This yeilds learned parameters for the image transformations, $G _ { S  T }$ and $G _ { T  S }$ , image discriminators, $D _ { S }$ and $D _ { T }$ , as well as an initial setting of the task model, $f _ { T }$ , which is trained using pixel transformed source images and the corresponding source pixel labels. Finally, we perform feature space adpatation in order to update the target semantic model, $f _ { T }$ , to have features which are aligned between the source images mapped into target style and the real target images. During this phase, we learn the feature discriminator, $D _ { \mathrm { f e a t } }$ and use this to guide the representation update to $f _ { T }$ . In general, our method could also perform phases 2 and 3 simultaneously, but this would require more GPU memory then available at the time of these experiments.
+
+For all feature space adaptation we equally weight the generator and discriminator losses. We only update the generator when the discriminator accuracy is above $60 \%$ over the last batch (digits) or last 100 iterations (semantic segmentation) – this reduces the potential for volatile training. If after an epoch (entire pass over dataset) no suitable discriminator is found, the feature adaptation stops, otherwise it continues until max iterations are reached.
+
+# A.1.1 DIGIT EXPERIMENTS
+
+For all digit experiments we use a variant of the LeNet architecture as the task net (Figure 6 left). Our feature discriminator network consists of 3 fully connected layers (Figure 6 mid left). The image discriminator network consists of 6 convolutional layers culminating in a single value per pixel (Figure 6 mid right). Finally, to generate one image domain from another we use a multilayer network which consists of convolution layers followed by two residual blocks and then deconvolution layers (Figure 6 right). All stages are trained using the Adam optimizer.
+
+Hyperparameters. For training the source task net model, we use learning rate 1e-4 and train for 100 epochs over the data with batch size 128. For feature space adaptation we use learning rate 1e-5 and train for max 200 epochs over the data. For pixel space adaptation we train our generators and discriminators with equal weighting on all losses, use batch size 100, learning rate 2e-4 (default from CycleGAN), and trained for 50 epochs. We ran each experiment 4 times and report the average and standard error across the runs.
+
+# A.1.2 SEMANTIC SEGMENTATION
+
+![](images/a197c643d43f9e197cb05caf7e52e2370d9faa7358f944ebbb47559618aeba29.jpg)  
+Figure 7: GTA5 to CityScapes Image Translation. Example images from the GTA5 (a) and Cityscapes (c) datasets, alongside their image-space conversions to the opposite domain, (b) and (d), respectively. Our model achieves highly realistic domain conversions.
+
+We experiment with both the VGG16-FCN8s Long et al. (2015) architecture as well as the DRN-26 Yu et al. (2017) architecture. For FCN8s, we train our source semantic segmentation model for 100k iterations using SGD with learning rate 1e-3 and momentum 0.9. For the DRN-26 architecture, we train our source semantic segmentation model for 115K iterations using SGD with learning rate 1e-3 and momentum 0.9. We use a crop size of $6 0 0 \times 6 0 0$ and a batch size of 8 for this training. For cycle-consistent image level adaptation, we followed the network architecture and hyperparameters of CycleGAN(Zhu et al., 2017). All images were resized to have width of 1024 pixels while keeping the aspect ratio, and the training was performed with randomly cropped patches of size 400 by 400. Also, due to large size of the dataset, we trained only 20 epochs. For feature level adaptation, we train using SGD with momentum, 0.99, and learning rate 1e-5. We weight the representation loss ten times less than the discriminator loss as a convenience since otherwise the discriminator did not learn a suitable model within a single epoch. Then the segmentation model was trained separately using the adapted source images and the ground truth labels of the source data. Due to memory limitations we can only include a single source and single target image at a time (crops of size $7 6 8 x 7 6 8 $ ), this small batch is one of the main reasons for using a high momentum parameter.
+
+![](images/60aaff8c5fc6dd32b469c9dcc3291ec0e6952bea2ba405ea120ad0fe4a1cc068.jpg)  
+Figure 8: Cross Season Image Translation. Example image-space conversions for the SYNTHIA seasons adaptation setting. We show real samples from each domain (Fall and Winter) alongside conversions to the opposite domain.
+
+Table 4: Adaptation between seasons in the SYNTHIA dataset. We report IoU for each class and mean IoU, freq-weighted IoU and pixel accuracy. Our CyCADA method achieves state-of-the-art performance on average across all categories. ${ } ^ { * } \mathrm { F C N s }$ in the wild is by Hoffman et al. (2016).   
+
+<table><tr><td></td><td colspan="13">SYNTHIA Fall -→Winter</td></tr><tr><td></td><td>多</td><td>Buipping</td><td></td><td>seeare</td><td></td><td>Vegeeee</td><td></td><td>u</td><td>us ogen</td><td>uerrespad</td><td>elair</td><td>Brraiiaa</td><td>naiggee</td><td></td><td>Prrr pxecs NOIMJ</td></tr><tr><td>Source only</td><td>91.7</td><td>80.6</td><td>79.7</td><td>12.1</td><td>71.8</td><td>44.2</td><td>26.1</td><td>42.8</td><td>49.0</td><td>38.7</td><td>45.1</td><td>41.3 24.5</td><td>49.8</td><td>71.7</td><td>82.3</td></tr><tr><td>FCNs in the wild</td><td>92.1</td><td>86.7</td><td>91.3</td><td>20.8</td><td>72.7</td><td>52.9</td><td>46.5</td><td>64.3</td><td>50.0</td><td>59.5</td><td>54.6 57.5</td><td>26.1</td><td>59.6</td><td>一</td><td></td></tr><tr><td>CyCADA pixel-only</td><td>92.5</td><td>90.1</td><td>91.9</td><td>79.9</td><td>85.7</td><td>47.1</td><td>36.9</td><td>82.6</td><td>45.0</td><td>49.1</td><td>46.2 54.6</td><td>21.5</td><td>63.3</td><td>85.7</td><td>92.1</td></tr><tr><td>Oracle (Train on target)</td><td>93.8</td><td>92.2</td><td>94.7</td><td>90.7</td><td>90.2</td><td>64.4</td><td>38.1</td><td>88.5</td><td>55.4</td><td>51.0</td><td>52.0</td><td>68.9 37.3</td><td></td><td></td><td>70.589.9 94.5</td></tr></table>
+
+# A.1.3 CROSS-SEASON ADAPTATION
+
+As an additional semantic segmentation evaluation, we consider the SYNTHIA dataset (Ros et al., 2016a), which contains synthetic renderings of urban scenes. We use the SYNTHIA video sequences, which are rendered across a variety of environments, weather conditions, and lighting conditions. This provides a synthetic testbed for evaluating adaptation techniques. For comparison with previous work, in this work we focus on adaptation between seasons. We use only the front-facing views in the sequences so as to mimic dashcam imagery, and adapt from fall to winter. The subset of the dataset we use contains 13 classes and consists of 10,852 fall images and 7,654 winter images.
+
+We start by exploring the abilities of pixel space adaptation alone (using FCN8s architecture) for the setting of adapting across seasons in synthetic data. For this we use the SYNTHIA dataset and adapt from fall to winter weather conditions. Typically in unsupervised adaptation settings it is difficult to interpret what causes the performance improvement after adaptation. Therefore, we use this setting as an example where we may directly visualize the shift from fall to winter and inspect the intermediate pixel level adaptation result from our algorithm. In Figure 8 we show the result of pixel only adaptation as we generate a winter domain image (b) from a fall domain image (a), and visa versa (c-d). We may clearly see the changes of adding or removing snow. This visually interpretable result matches our expectation of the true shift between these domains and indeed results in favorable final semantic segmentation performance from fall to winter as shown in Table 4. We find that CyCADA achieves state-of-the-art performance on this task with image space adaptation alone, however does not recover full supervised learning performance (train on target). Some example errors includes adding snow to the sidewalks, but not to the road, while in the true winter domain snow appears in both locations. However, even this mistake is interesting as it implies that the model is learning to distinguish road from sidewalk during pixel adaptation, despite the lack of pixel annotations.
+
+Cycle-consistent adversarial adaptation achieves state-of-the-art adaptation performance. We see that under the fwIoU and pixel accuracy metrics, CyCADA approaches oracle performance, falling short by only a few points, despite being entirely unsupervised. This indicates that CyCADA is extremely effective at correcting the most common classes in the dataset. This conclusion is supported by inspection of the individual classes in Table 4, where we see the largest improvement on common classes such as road and sidewalk.
+
+![](images/d835f66b2d3512ee3908e754ebeaafdf6ffb7f8b1aecabdbb74336155ddf2cb0.jpg)  
+Figure 9: Image transformation results from Shrivastava et al. (2017) applied to GTA to CityScapes transformation. We demonstrate results using three different settings for $\lambda$ .
+
+![](images/5e43524349abcba7b23192a72138d24d40cb64d2f8b73caf10d4cdcc6e14b30e.jpg)  
+Figure 10: Confusion matrices for SVHN MNIST experiment.
+
+# A.2 COMPARISON TO SHRIVASTAVA ET AL. (2017) FOR SEMANTIC SEGMENTATION
+
+We illustrate the performance of a recent pixel level adaptation approach proposed by Shrivastava et al. (2017) on our semantic segmentation data – GTA to Cityscapes. These images are significantly larger and more complex than those shown in the experiments in the original paper. We show image to image translation results under three different settings of the model hyperparameter, $\lambda$ , which controls the tradeoff between the reconstruction loss and the visual style loss. When $\lambda = 1 0$ (Figure 9 right), the resulting image converges to a near replica of the original image, thus preserving content but lacking the correct target style. When $\lambda = 1$ or $\lambda = 2 . 5$ (Figure 9 left), the results lack any consistent semantics making it difficult to perceive the style of the transformed image. Thus, the resulting performance for this model is 11.6 mIoU for FCN8s with VGG, well below the performance of the corresponding source model of 17.9 mIoU.
+
+# A.3 EXPERIMENT ANALYSIS
+
+To understand the types of mistakes which are improved upon and those which still persist after adaptation, we present the confusion matrices before and after our approach for the digit experiment of SVHN to MNIST (Figure 10). Before adaptation we see common confusions are 0s with 2s, 4s, and 7s. 6 with 4, 8 with 3, and 9 with 4. After adaptation all errors are reduced, but we still find that 7s are confused with 1s and 0s with 2s. These errors make some sense as with hand written digits, these digits sometimes resemble one another. It remains an open question to produce a model which may overcome these types of errors between highly similar classes.

parse/train/SktLlGbRZ/SktLlGbRZ_content_list.json

@@ -0,0 +1,1719 @@
+[
+    {
+        "type": "text",
+        "text": "CYCADA: CYCLE-CONSISTENT ADVERSARIAL DOMAIN ADAPTATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            750,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            170,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Domain adaptation is critical for success in new, unseen environments. Adversarial adaptation models applied in feature spaces discover domain invariant representations, but are difficult to visualize and sometimes fail to capture pixel-level and low-level domain shifts. Recent work has shown that generative adversarial networks combined with cycle-consistency constraints are surprisingly effective at mapping images between domains, even without the use of aligned image pairs. We propose a novel discriminatively-trained Cycle-Consistent Adversarial Domain Adaptation model. CyCADA adapts representations at both the pixel-level and feature-level, enforces cycle-consistency while leveraging a task loss, and does not require aligned pairs. Our model can be applied in a variety of visual recognition and prediction settings. We show new state-of-the-art results across multiple adaptation tasks, including digit classification and semantic segmentation of road scenes demonstrating transfer from synthetic to real world domains. ",
+        "bbox": [
+            233,
+            270,
+            766,
+            450
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            486,
+            334,
+            502
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep neural networks excel at learning from large amounts of data, but can be poor at generalizing learned knowledge to new datasets or environments. Even a slight departure from a network’s training domain can cause it to make spurious predictions and significantly hurt its performance (Tzeng et al., 2017). The visual domain shift from non-photorealistic synthetic data to real images presents an even more significant challenge. While we would like to train models on large amounts of synthetic data such as data collected from graphics game engines, such models fail to generalize to real-world imagery. For example, a state-of-the-art semantic segmentation model trained on synthetic dashcam data fails to segment the road in real images, and its overall per-pixel label accuracy drops from $93 \\%$ (if trained on real imagery) to $54 \\%$ (if trained only on synthetic data, see Table 5). ",
+        "bbox": [
+            174,
+            520,
+            825,
+            646
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Feature-level unsupervised domain adaptation methods address this problem by aligning the features extracted from the network across the source (e.g. synthetic) and target (e.g. real) domains, without any labeled target samples. Alignment typically involves minimizing some measure of distance between the source and target feature distributions, such as maximum mean discrepancy (Long & Wang, 2015), correlation distance (Sun & Saenko, 2016), or adversarial discriminator accuracy (Ganin & Lempitsky, 2015; Tzeng et al., 2017). This class of techniques suffers from two main limitations. First, aligning marginal distributions does not enforce any semantic consistency, e.g. target features of a car may be mapped to source features of a bicycle. Second, alignment at higher levels of a deep representation can fail to model aspects of low-level appearance variance which are crucial for the end visual task. ",
+        "bbox": [
+            174,
+            652,
+            825,
+            791
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Generative pixel-level domain adaptation models perform similar distribution alignment—not in feature space but rather in raw pixel space—translating source data to the “style” of a target domain. Recent methods can learn to translate images given only unsupervised data from both domains (Bousmalis et al., 2017b; Liu & Tuzel, 2016b; Shrivastava et al., 2017). The results are visually compelling, but such image-space models have only been shown to work for small image sizes and limited domain shifts. A more recent approach (Bousmalis et al., 2017a) was applied to larger (but still not high resolution) images, but in a controlled environment with visually simple images for robotic applications. Furthermore, they also do not necessarily preserve content: while the translated image may “look” like it came from the right domain, crucial semantic information may be lost. For example, a model adapting from line-drawings to photos could learn to make a line-drawing of a cat look like a photo of a dog. ",
+        "bbox": [
+            174,
+            799,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/c8c6d6b6c25017e0b5fc2f1561ac7a86acb647cb836c719750cf4f0e1bf1e791.jpg",
+        "image_caption": [
+            "Figure 1: We propose CyCADA, an adversarial unsupervised adaptation algorithm which uses cycle and semantic consistency to perform adaptation at multiple levels in a deep network. Our model provides significant performance improvements over source model baselines. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            101,
+            820,
+            236
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "table",
+        "img_path": "images/e029b958a88dfc74292d2f21fe5ad15b9f5c68f617ab5ad439515f78825885f0.jpg",
+        "table_caption": [
+            "Table 1: Our model, CyCADA, may use pixel, feature, and semantic information during adaptation while learning an invertible mapping through cycle consistency. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Pixel Loss</td><td>Feature Loss</td><td>Semantic Loss</td><td>Cycle Consistent</td></tr><tr><td>CycleGAN (Zhu et al., 2017)</td><td>√</td><td></td><td></td><td>√</td></tr><tr><td>Feature Adapt (Ganin &amp; Lempitsky,2015; Tzeng et al., 2017)</td><td></td><td>1</td><td>√</td><td></td></tr><tr><td>Pixel Adapt (Taigman et al.,2017a; Bousmalis et al., 2017b)</td><td></td><td></td><td></td><td></td></tr><tr><td>CyCADA</td><td>?</td><td>√</td><td>√</td><td>√</td></tr></table>",
+        "bbox": [
+            176,
+            305,
+            821,
+            395
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            464,
+            823,
+            492
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "How can we encourage the model to preserve semantic information in the process of distribution alignment? In this paper, we explore a simple yet powerful idea: give an additional objective to the model to reconstruct the original data from the adapted version. Cycle-consistency was recently proposed in a cross-domain image generation GAN model, CycleGAN (Zhu et al., 2017), which showed transformative image-to-image generation results, but was agnostic to any particular task. ",
+        "bbox": [
+            174,
+            500,
+            825,
+            569
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We propose Cycle-Consistent Adversarial Domain Adaptation (CyCADA), which adapts representations at both the pixel-level and feature-level while enforcing pixel and semantic consistency. We use a reconstruction (cycle-consistency) loss to enforce the cross-domain transformation to preserve pixel information and a semantic labeling loss to enforce semantic consistency. CyCADA unifies prior feature-level (Ganin & Lempitsky, 2015; Tzeng et al., 2017) and image-level (Liu & Tuzel, 2016b; Bousmalis et al., 2017b; Shrivastava et al., 2017) adversarial domain adaptation methods together with cycle-consistent image-to-image translation techniques (Zhu et al., 2017), as illustrated in Table 1. It is applicable across a range of deep architectures and/or representation levels, and has several advantages over existing unsupervised domain adaptation methods. ",
+        "bbox": [
+            174,
+            575,
+            825,
+            702
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We apply our CyCADA model to the task of digit recognition across domains and the task of semantic segmentation of urban scenes across domains. Experiments show that our model achieves state of the art results on digit adaptation, cross-season adaptation in synthetic data, and on the challenging synthetic-to-real scenario. In the latter case, it improves per-pixel accuracy from $54 \\%$ to $83 \\%$ , nearly closing the gap to the target-trained model. ",
+        "bbox": [
+            174,
+            708,
+            825,
+            777
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our experiments confirm that domain adaptation can benefit greatly from cycle-consistent pixel transformations, and that this is especially important for pixel-level semantic segmentation with contemporary FCN architectures. We demonstrate that enforcing semantic consistency between input and stylized images prevents label flipping on the large shift between SVHN and MNIST (example, prevents a SVHN 9 from being mapped into an MNIST 2). Interestingly, on our semantic segmentation tasks (GTA to CityScapes) we did not observe label flipping to be a major source of error, even without the semantic consistency loss. Because of this, and due to memory constraints, we do not include this loss for the segmentation tasks. Further, we show that adaptation at both the pixel and representation level can offer complementary improvements with joint pixel-space and feature adaptation leading to the highest performing model for digit classification tasks. ",
+        "bbox": [
+            174,
+            785,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            343,
+            117
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The problem of visual domain adaptation was introduced along with a pairwise metric transform solution by Saenko et al. (2010) and was further popularized by the broad study of visual dataset bias (Torralba & Efros, 2011). Early deep adaptive works focused on feature space alignment through minimizing the distance between first or second order feature space statistics of the source and target (Tzeng et al., 2014; Long & Wang, 2015). These latent distribution alignment approaches were further improved through the use of domain adversarial objectives whereby a domain classifier is trained to distinguish between the source and target representations while the domain representation is learned so as to maximize the error of the domain classifier. The representation is optimized using the standard minimax objective (Ganin & Lempitsky, 2015), the symmetric confusion objective (Tzeng et al., 2015), or the inverted label objective (Tzeng et al., 2017). Each of these objectives is related to the literature on generative adversarial networks (Goodfellow et al., 2014) and follow-up work for improved training procedures for these networks (Salimans et al., 2016b; Arjovsky et al., 2017). ",
+        "bbox": [
+            174,
+            146,
+            825,
+            311
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The feature-space adaptation methods described above focus on modifications to the discriminative representation space. In contrast, other recent methods have sought adaptation in the pixel-space using various generative approaches. One advantage of pixel-space adaptation, as we have shown, is that the result may be more human interpretable, since an image from one domain can now be visualized in a new domain. CoGANs (Liu & Tuzel, 2016b) jointly learn a source and target representation through explicit weight sharing of certain layers while each source and target has a unique generative adversarial objective. Ghifary et al. (2016) uses an additional reconstruction objective in the target domain to encourage alignment in the unsupervised adaptation setting. ",
+        "bbox": [
+            174,
+            319,
+            825,
+            431
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In contrast, another approach is to directly convert the target image into a source style image (or visa versa), largely based on Generative Adversarial Networks (GANs) (Goodfellow et al., 2014). Researchers have successfully applied GANs to various applications such as image generation (Denton et al., 2015; Radford et al., 2015; Zhao et al., 2016), image editing (Zhu et al., 2016) and feature learning (Salimans et al., 2016a; Donahue et al., 2017). Recent work (Isola et al., 2016; Sangkloy et al., 2016; Karacan et al., 2016) adopt conditional GANs (Mirza & Osindero, 2014) for these image-to-image translation problems (Isola et al., 2016), but they require input-output image pairs for training, which is in general not available in domain adaptation problems. ",
+        "bbox": [
+            174,
+            438,
+            825,
+            549
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "There also exist lines of work where such training pairs are not given. Yoo et al. (2016) learns a source to target encoder-decoder along with a generative adversarial objective on the reconstruction which is is applied for predicting the clothing people are wearing. The Domain Transfer Network (Taigman et al., 2017b) trains a generator to transform a source image into a target image by enforcing consistency in the embedding space. Shrivastava et al. (2017) instead uses an L1 reconstruction loss to force the generated target images to be similar to their original source images.This works well for limited domain shifts where the domains are similar in pixel-space, but can be too limiting for settings with larger domain shifts. Bousmalis et al. (2017b) use a content similarity loss to ensure the generated target image is similar to the original source image; however, this requires prior knowledge about which parts of the image stay the same across domains (e.g. foreground). Our method does not require pre-defining what content is shared between domains and instead simply translates images back to their original domains while ensuring that they remain identical to their original versions. BiGAN (Donahue et al., 2017) and ALI (Dumoulin et al., 2016) take an approach of simultaneously learning the transformations between the pixel and the latent space. More recently, Cycle-consistent Adversarial Networks (CycleGAN) (Zhu et al., 2017) produced compelling image translation results such as generating photorealistic images from impressionism paintings or transforming horses into zebras at high resolution using the cycle-consistency loss. This loss was simultaneously proposed by Yi et al. (2017) and Kim et al. (2017) to great effect as well. Our motivation comes from such findings about the effectiveness of the cycle-consistency loss. ",
+        "bbox": [
+            174,
+            555,
+            825,
+            819
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Few works have explicitly studied visual domain adaptation for the semantic segmentation task. Adaptation across weather conditions in simple road scenes was first studied by Levinkov & Fritz (2013). More recently, a convolutional domain adversarial based approached was proposed for more general drive cam scenes and for adaptation from simulated to real environments (Hoffman et al., 2016). Ros et al. (2016b) learns a multi-source model through concatenating all available labeled data and learning a single large model and then transfers to a sparsely labeled target domain through distillation (Hinton et al., 2015). Chen et al. (2017) use an adversarial objective to align both global and class-specific statistics, while mining additional temporal data from street view datasets to learn a static object prior. Zhang et al. (2017) instead perform segmentation adaptation by aligning label distributions both globally and across superpixels in an image. ",
+        "bbox": [
+            174,
+            827,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/00e18ca8e6ced489878ab90e305256d2cd6149ed73cdf9e4e2731ca7f2db7919.jpg",
+        "image_caption": [
+            "Figure 2: Cycle-consistent adversarial adaptation overview. By directly remapping source training data into the target domain, we remove the low-level differences between the domains, ensuring that our task model is well-conditioned on target data. We depict here the image-level adaptation as composed of the pixel GAN loss (green), the source cycle loss (red), and the source and target semantic consistency losses (black dashed) – used when needed to prevent label flipping. For clarity the target cycle is omitted. The feature-level adaptation is depicted as the feature GAN loss (orange) and the source task loss (purple). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            99,
+            820,
+            268
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            406,
+            825,
+            449
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 CYCLE-CONSISTENT ADVERSARIAL DOMAIN ADAPTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            469,
+            681,
+            486
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We consider the problem of unsupervised adaptation, where we are provided source data $X _ { S }$ , source labels $Y _ { S }$ , and target data $X _ { T }$ , but no target labels. The goal is to learn a model $f _ { T }$ that correctly predicts the label for the target data $X _ { T }$ . ",
+        "bbox": [
+            174,
+            500,
+            826,
+            542
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Pretrain Source Task Model. We begin by simply learning a source model $f _ { S }$ that can perform the task on the source data. For $K$ -way classification with a cross-entropy loss, this corresponds to ",
+        "bbox": [
+            173,
+            549,
+            826,
+            579
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/310f74b74a7c9f1ef817c7af3b6a7892d0ae001d390409cc80c023b2db035139.jpg",
+        "text": "$$\n\\mathcal { L } _ { \\mathrm { t a s k } } ( f _ { S } , X _ { S } , Y _ { S } ) = - \\mathbb { E } _ { ( x _ { s } , y _ { s } ) \\sim ( X _ { S } , Y _ { S } ) } \\sum _ { k = 1 } ^ { K } \\mathbb { 1 } _ { [ k = y _ { s } ] } \\log \\Big ( \\sigma \\big ( f _ { S } ^ { ( k ) } ( x _ { s } ) \\big ) \\Big )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            264,
+            584,
+            733,
+            628
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\sigma$ denotes the softmax function. However, while the learned model $f _ { S }$ will perform well on the source data, typically domain shift between the source and target domain leads to reduced performance when evaluating on target data. ",
+        "bbox": [
+            176,
+            633,
+            825,
+            676
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Pixel-level Adaptation. To mitigate the effects of domain shift, we follow previous adversarial adaptation approaches and learn to map samples across domains such that an adversarial discriminator is unable to distinguish the domains. By mapping samples into a common space, we enable our model to learn on source data while still generalizing to target data. ",
+        "bbox": [
+            174,
+            683,
+            825,
+            739
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To this end, we introduce a mapping from source to target $G _ { S  T }$ and train it to produce target samples that fool an adversarial discriminator $D _ { T }$ . Conversely, the adversarial discriminator attempts to classify the real target data from the source target data. This corresponds to the loss function ",
+        "bbox": [
+            174,
+            746,
+            825,
+            789
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a869a1c5721084330a3298371d37b167fe7577862d8c580d8a9ddda8edc4e3f1.jpg",
+        "text": "$$\n\\mathscr { L } _ { \\mathrm { G A N } } ( G _ { S  T } , D _ { T } , X _ { T } , X _ { S } ) = \\mathbb { E } _ { x _ { t } \\sim X _ { T } } [ \\log D _ { T } ( x _ { t } ) ] + \\mathbb { E } _ { x _ { s } \\sim X _ { S } } [ \\log ( 1 - D _ { T } ( G _ { S  T } ( x _ { s } ) ) ) ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            183,
+            795,
+            794,
+            813
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "This objective ensures that $G _ { S  T }$ , given source samples, produces convincing target samples. In turn, this ability to directly map samples between domains allows us to learn a target model $f _ { T }$ by minimizing $\\tilde { \\mathcal { L } } _ { \\mathrm { t a s k } } ( f _ { T } , G _ { S  T } ( \\bar { X _ { S } } ) , \\bar { Y _ { S } } )$ (see Figure 2 green portion). ",
+        "bbox": [
+            174,
+            818,
+            825,
+            862
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "However, while previous approaches that optimized similar objectives have shown effective results, in practice they can often be unstable and prone to failure. Although the GAN loss in Equation 2 ensures that $G _ { S \\to T } ( x _ { s } )$ for some $x _ { s }$ will resemble data drawn from $X _ { T }$ , there is no way to guarantee that $G _ { S \\to T } ( x _ { s } )$ preserves the structure or content of the original sample $x _ { s }$ . ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In order to encourage the source content to be preserved during the conversion process, we impose a cycle-consistency constraint on our adaptation method (Zhu et al., 2017; Yi et al., 2017; Kim et al., 2017) (see Figure 2 red portion). To this end, we introduce another mapping from target to source $G _ { T  S }$ and train it according to the same GAN loss $\\mathcal { L } _ { \\mathrm { G A N } } ( G _ { T  S } , D _ { S } , \\mathbf { \\bar { \\boldsymbol { X } } } _ { S } , \\mathbf { \\bar { \\boldsymbol { X } } } _ { T } )$ . We then require that mapping a source sample from source to target and back to the source reproduces the original sample, thereby enforcing cycle-consistency. In other words, we want $G _ { T  S } ( \\bar { G } _ { S  T } ( x _ { s } ) ) \\approx x _ { s }$ and $G _ { S  T } ( G _ { T  S } ( x _ { t } ) ) \\approx x _ { t }$ . This is done by imposing an L1 penalty on the reconstruction error, which is referred to as the cycle-consistency loss: ",
+        "bbox": [
+            173,
+            103,
+            826,
+            215
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4376a1ed78b44d46ae23d922a7e193a4060e91ae5badc867a3d6aa250b5587e8.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathcal { L } _ { \\mathrm { c y c } } ( G _ { S  T } , G _ { T  S } , X _ { S } , X _ { T } ) = \\mathbb { E } _ { x _ { s } \\sim X _ { S } } [ | | G _ { T  S } ( G _ { S  T } ( x _ { s } ) ) - x _ { s } | | _ { 1 } ] } \\\\ { + \\mathbb { E } _ { x _ { t } \\sim X _ { T } } [ | | G _ { S  T } ( G _ { T  S } ( x _ { t } ) ) - x _ { t } | | _ { 1 } ] . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            254,
+            218,
+            741,
+            257
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Additionally, as we have access to source labeled data, we explicitly encourage high semantic consistency before and after image translation. We used the pretrained source task model $f _ { S }$ , as a noisy labeler by which we encourage an image to be classified in the same way after translation as it was before translation according to this classifier. Let us define the predicted label from a fixed classifier, $f$ , for a given input $X$ as $p ( f , X ) = \\arg \\operatorname* { m a x } ( f ( X ) )$ . Then we can define the semantic consistency before and after image translation as follows: ",
+        "bbox": [
+            173,
+            258,
+            825,
+            342
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/263cda2d8c20f6d629642d5eb45ede155fa63a66e45e7c3d0bc8941753ef2c4a.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathcal { L } _ { \\mathrm { s e m } } ( G _ { S  T } , G _ { T  S } , X _ { S } , X _ { T } , f _ { S } ) = \\mathcal { L } _ { \\mathrm { t a s k } } ( f _ { S } , G _ { T  S } ( X _ { T } ) , p ( f _ { S } , X _ { T } ) ) } \\\\ { + \\mathcal { L } _ { \\mathrm { t a s k } } ( f _ { S } , G _ { S  T } ( X _ { S } ) , p ( f _ { S } , X _ { S } ) ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            259,
+            345,
+            736,
+            383
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "See Figure 2 black portion. This can be viewed as analogously to content losses in style transfer (Gatys et al., 2016) or in pixel adaptation (Taigman et al., 2017a), where the shared content to preserve is dictated by the source task model $f _ { S }$ . ",
+        "bbox": [
+            173,
+            386,
+            825,
+            429
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Feature-level Adaptation. We have thus far described an adaptation method which combines cycle consistency, semantic consistency, and adversarial objectives to produce a final target model. As a pixel-level method, the adversarial objective consists of a discriminator which distinguishes between two image sets, e.g. transformed source and real target image. Note that we could also consider a feature-level method which discriminates between the features or semantics from two image sets as viewed under a task network. This would amount to an additional feature level GAN loss (see Figure 2 orange portion): ",
+        "bbox": [
+            173,
+            435,
+            825,
+            532
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d923edf526397c98a574cabe74c8a56fd549ba0b9547ddf44391a64ef3f7cc87.jpg",
+        "text": "$$\n\\mathcal { L } _ { \\mathrm { G A N } } ( f _ { T } , D _ { \\mathrm { f e a t } } , f _ { S } ( G _ { S  T } ( X _ { S } ) ) , X _ { T } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            367,
+            537,
+            630,
+            555
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Taken together, these loss functions form our complete objective: ",
+        "bbox": [
+            173,
+            565,
+            601,
+            580
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ce9412c141f15fb69b7b8372d7dbc12b2f0bb6ed0722d7da6d0c7aa7e83ff467.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathcal { L } _ { \\mathrm { C y C A D A } } ( f _ { T } , X _ { S } , X _ { T } , Y _ { S } , G _ { S  T } , G _ { T  S } , D _ { S } , D _ { T } ) } \\\\ & { \\qquad = \\mathcal { L } _ { \\mathrm { u s k } } ( f _ { T } , G _ { S  T } ( X _ { S } ) , Y _ { S } ) } \\\\ & { \\qquad + \\mathcal { L } _ { \\mathrm { G A N } } ( G _ { S  T } , D _ { T } , X _ { T } , X _ { S } ) + \\mathcal { L } _ { \\mathrm { G A N } } ( G _ { T  S } , D _ { S } , X _ { S } , X _ { T } ) } \\\\ & { \\qquad + \\mathcal { L } _ { \\mathrm { G A N } } ( f _ { T } , D _ { \\mathrm { f e a t } } , f _ { S } ( G _ { S  T } ( X _ { S } ) ) , X _ { T } ) } \\\\ & { \\qquad + \\mathcal { L } _ { \\mathrm { c y c } } ( G _ { S  T } , G _ { T  S } , X _ { S } , X _ { T } ) + \\mathcal { L } _ { \\mathrm { s e m } } ( G _ { S  T } , G _ { T  S } , X _ { S } , X _ { T } , f _ { S } ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            232,
+            584,
+            764,
+            676
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This ultimately corresponds to solving for a target model $f _ { T }$ according to the optimization problem ",
+        "bbox": [
+            171,
+            684,
+            820,
+            700
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2fc49df3358d085327aadbcf601642c621fa57ab6579785adff2c04df90b83d7.jpg",
+        "text": "$$\nf _ { T } ^ { * } = \\underset { f _ { T } } { \\arg \\operatorname* { m i n } } \\ \\underset { G _ { S  T } } { \\operatorname* { m i n } } \\ \\underset { D _ { S } , D _ { T } } { \\operatorname* { m a x } } \\ \\mathcal { L } _ { \\mathrm { C y C A D A } } ( f _ { T } , X _ { S } , X _ { T } , Y _ { S } , G _ { S  T } , G _ { T  S } , D _ { S } , D _ { T } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            250,
+            703,
+            746,
+            736
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We have introduced a method for unsupervised adaptation which views prior adversarial objectives as operating at the pixel or feature level and generalizes to a method which may benefit from both approaches. In addition, we introduce the combination of cycle-consistency together with semantic transformation constraints to regularize the mapping from one domain to another. We apply CyCADA to both digit classification and to semantic segmentation. We implement $G _ { S }$ and $G _ { T }$ as a pixel-topixel convnet, $f _ { S }$ and $f _ { T }$ as a convnet classifier or a Fully-Convolutional Net (FCN), and $D _ { S } , D _ { T }$ and $D _ { \\mathrm { f e a t } }$ as a convnet with binary outputs. ",
+        "bbox": [
+            173,
+            746,
+            825,
+            845
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            864,
+            326,
+            880
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We evaluate CyCADA on several unsupervised adaptation scenarios. We first focus on adaptation for digit classification using the MNIST (LeCun et al., 1998), USPS, and Street View House Numbers ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/a678bf27e0db2824ca7a28d79667ce92d91b287948cc74ba4783698d7ff75f1d.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>MNIST → USPSUSPS</td><td></td><td>→MNISTSVHN→MNIST</td></tr><tr><td>Source only</td><td>82.2 ±0.8</td><td>69.6 ± 3.8</td><td>67.1 ± 0.6</td></tr><tr><td>DANN (Ganin et al., 2016)</td><td></td><td>1</td><td>73.6</td></tr><tr><td>DTN (Taigman et al.,2017a)</td><td></td><td>=</td><td>84.4</td></tr><tr><td>CoGAN (Liu&amp; Tuzel,2016a)</td><td>91.2</td><td>89.1</td><td>-</td></tr><tr><td>ADDA (Tzeng et al., 2017)</td><td>89.4±0.2</td><td>90.1 ± 0.8</td><td>76.0 ± 1.8</td></tr><tr><td>CyCADA pixel only</td><td>95.6 ± 0.2</td><td>96.4 ± 0.1</td><td>70.3 ±0.2</td></tr><tr><td>CyCADA pixel+feat</td><td>95.6± 0.2</td><td>96.5 ± 0.1</td><td>90.4 ± 0.4</td></tr><tr><td>Target only</td><td>96.3± 0.1</td><td>99.2 ± 0.1</td><td>99.2 ±0.1</td></tr></table>",
+        "bbox": [
+            295,
+            101,
+            702,
+            217
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/cb731ed55e26a50aeacddb7117151655696d5fd16aad02a1d44332eb8e2cf8dd.jpg",
+        "image_caption": [
+            "Table 2: Unsupervised domain adaptation across digit datasets. Our model is competitive with or outperforms state-of-the-art models for each shift. For the difficult shift of SVHN to MNIST we also note that feature space adaptation provides additional benefit beyond the pixel-only adaptation. ",
+            "Figure 3: Ablation: Effect of Semantic or Cycle Consistency Examples of translation failures without the semantic consistency loss. Each triple contains the original SVHN image (left), the image translated into MNIST style (middle), and the image reconstructed back into SVHN (right). (a) Without semantic loss, both the GAN and cycle constraints are satisfied (translated image matches MNIST style and reconstructed image matches original), but the image translated to the target domain lacks the proper semantics. (b) Without cycle loss, the reconstruction is not satisfied and though the semantic consistency leads to some successful semantic translations (top) there are still cases of label flipping (bottom). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            285,
+            285,
+            714,
+            409
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "(SVHN) (Netzer et al., 2011) datasets. After which we present results for the task of semantic image segmentation, using the GTA (Richter et al., 2016) and CityScapes (Cordts et al., 2016) datasets, see Appendix A.1.2 for an additional experiment with the SYNTHIA (Ros et al., 2016a) dataset. ",
+        "bbox": [
+            174,
+            558,
+            825,
+            601
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 DIGIT ADAPTATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            619,
+            351,
+            632
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We evaluate our method across the adaptation shifts of USPS to MNIST, MNIST to USPS, and SVHN to MNIST, using the full training sets during learning phases and evaluating on the standard test sets. We report classification accuracy for each shift in Table 2 and find that our method outperforms competing approaches on average. The classifier for our method for all digit shifts uses a variant of the LeNet architecture (see A.1.1 for full implementation details). Note that the recent pixel-da method by Bousmalis et al. (2017b) presents results for only the MNIST to USPS shift and reports $9 5 . 9 \\%$ accuracy, while our method achieves $9 5 . 6 \\%$ accuracy. However, the pixel-da approach cross validates with some labeled data which is not an equivalent evaluation setting. ",
+        "bbox": [
+            173,
+            645,
+            825,
+            756
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Ablation: Pixel vs Feature Level Transfer. We begin by evaluating the contribution of the pixel space and feature space transfer. We find that in the case of the small domain shifts between USPS and MNIST, the pixel space adaptation by which we train a classifier using images translated using CycleGAN (Zhu et al., 2017), performs very well, outperforming or comparable to prior adaptation approaches. Feature level adaptation offers a small benefit in this case of a small pixel shift. However, for the more difficult shift of SVHN to MNIST, we find that feature level adaptation outperforms the pixel level adaptation, and importantly, both may be combined to produce an overall model which outperforms all competing methods. ",
+        "bbox": [
+            173,
+            762,
+            825,
+            875
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Ablation: No Semantic Consistency. We experiment without the addition of our semantic consistency loss and find that the standard unsupervised CycleGAN approach diverged when training SVHN to MNIST often suffering from random label flipping. Figure 3(a) demonstrates two examples where cycle constraints alone fail to have the desired behavior for our end task. An SVHN image is mapped to a convincing MNIST type image and back to a SVHN image with correct semantics. However, the MNIST-like image has mismatched semantics. Our modified version, which uses the source labels to train a weak classification model which can be used to enforce semantic consistency before and after translation, resolves this issue and produces strong performance. ",
+        "bbox": [
+            176,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/7643efed9d27a54f76ba16653b4cfd002fcb0abef2414cedfb529b6b75fa7e50.jpg",
+        "image_caption": [
+            "Figure 4: GTA5 to CityScapes Semantic Segmentation. Each test CityScapes image (a) along with the corresponding predictions from the source only model (b) and our CyCADA model (c) are shown and may be compared against the ground truth annotation (d). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            166,
+            99,
+            836,
+            253
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            342,
+            825,
+            412
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Ablation: No Cycle Consistency. We study the result when learning without the cycle consistency loss. First note that there is no reconstruction guarantee in this case, thus in Figure 3(b) we see that the translation back to SVHN fails. In addition, we find that while the semantic loss does encourage correct semantics it relies on the weak source labeler and thus label flipping still occurs (see right image triple). ",
+        "bbox": [
+            174,
+            419,
+            825,
+            489
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 SEMANTIC SEGMENTATION ADAPTATION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            515,
+            500,
+            530
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The task is to assign a semantic label to each pixel in the input image, e.g. road, building, etc. We limit our evaluation to the unsupervised adaptation setting, where labels are only available in the source domain, but we are evaluated solely on our performance in the target domain. ",
+        "bbox": [
+            174,
+            545,
+            825,
+            587
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For each experiment, we use three metrics to evaluate performance. Let $n _ { i j }$ be the number of pixels of class $i$ predicted as class $j$ , let $t _ { i } = \\textstyle \\sum _ { j } n _ { i j }$ be the total number of pixels of class $i$ , and let $N$ be the number of classes. Our three evaluation metrics are, mean intersection-over-union (mIoU), frequency weighted intersection-over-union (fwIoU), and pixel accuracy, which are defined as follows: ",
+        "bbox": [
+            174,
+            594,
+            823,
+            651
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Cycle-consistent adversarial adaptation is general and can be applied at any layer of a network. Since optimizing the full CyCADA objective in Equation 6 end-to-end is memory-intensive in practice, we train our model in stages. First, we perform image-space adaptation and map our source data into the target domain. Next, using the adapted source data with the original source labels, we learn a task model that is suited to operating on target data. Finally, we perform another round of adaptation between the adapted source data and the target data in feature-space, using one of the intermediate layers of the task model. Additionally, we do not use the semantic loss for the segmentation experiments as it would require loading generators, discriminators, and an additional semantic segmenter into memory all at once for two images. We did not have the required memory for this at the time of submission, but leave it to future work to deploy model parallelism or experiment with larger GPU memory. ",
+        "bbox": [
+            173,
+            680,
+            825,
+            833
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To demonstrate our method’s applicability to real-world adaptation scenarios, we also evaluate our model in a challenging synthetic-to-real adaptation setting. For our synthetic source domain, we use the GTA5 dataset (Richter et al., 2016) extracted from the game Grand Theft Auto V, which contains 24966 images. We consider adaptation from GTA5 to the real-world Cityscapes dataset (Cordts et al., 2016), from which we used 19998 images without annotation for training and 500 images for validation. Both of these datasets are evaluated on the same set of 19 classes, allowing for ",
+        "bbox": [
+            174,
+            840,
+            825,
+            922
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/4c6a90b78722ffdf12f66f2c793ceb4506309bd5bc1427554adc9ce9c9158c38.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=6>GTA5→ Cityscapes</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>eeree</td><td rowspan=1 colspan=4>iorensaeaartBuiplingursorien Veneee                                  morirrtt             Prre rectirrnuos.iadaatiie0NOIMJ对u</td></tr><tr><td rowspan=2 colspan=1>Source onlyFCNs in the wild*CyCADA feat-onlyCyCADA pixel-onlyCyCADA pixel+feat</td><td rowspan=2 colspan=1>AAAA</td><td rowspan=2 colspan=3>A|26.0 14.9 65.15.512.98.96.02.570.02.947.0 24.50.040.012.11.50.00.00.070.4 32.4 62.114.95.410.9 14.22.779.2 21.3 64.6 44.14.270.48.07.30.03.50.085.6 30.7 74.714.4 13.0 17.6 13.75.874.6 15.8 69.9 38.23.572.3 16.05.00.13.60.083.538.376.4220.616.522.226.221.980.4 28.7 65.7 49.44.274.6 16.0 26.62.08.00.085.2 37.2 76.5 21.8 15.0 23.8 22.9 21.5880.5 31.3 60.7 50.59.076.917.128.24.59.80.0</td><td rowspan=2 colspan=1>17.9 41.9 54.027.129.2 71.5 82.534.8 73.1 82.835.4 73.8 83.6</td></tr><tr><td rowspan=1 colspan=1>34.8 73.1 82.835.4 73.8 83.6</td></tr><tr><td rowspan=1 colspan=2>Oracle - Target Super|</td><td rowspan=1 colspan=4>|A|96.4 74.5 87.1 35.337.8 36.4 46.9 60.189.0 54.3 89.8 65.6 35.9 89.4 38.6 64.1 38.6 40.5 65.160.3 87.6 93.1</td></tr><tr><td rowspan=4 colspan=1>Source onlyCyCADA feat-onlyCyCADA pixel-onlyCyCADA pixel+feat</td><td rowspan=1 colspan=1>B</td><td rowspan=4 colspan=4>42.7 26.3 51.75.56.813.8 23.6 6.9 75.511.5 36.8 49.30.946.73.45.00.05.01.421.7 47.4 62.578.1 31.171.210.314.129.8 28.120.9 74.0 16.8 51.9 53.66.165.4 8.2 20.91.813.9 5.931.7 67.4 78.463.7 24.7 69.3 21.2 17.0 30.3 33.0 32.0 80.5 25.3 62.3 62.0 15.1 73.1119.8 23.65.516.2 28.737.0 63.8 75.479.133.1 77.9 23.417.332.133.331.881.526.7 69.0 62.814.774.520.9 25.66.918.8 20.439.5 72.4 82.3</td></tr><tr><td rowspan=2 colspan=1>BB</td></tr><tr><td rowspan=1 colspan=1>5.5</td></tr><tr><td rowspan=1 colspan=1>B</td></tr><tr><td rowspan=1 colspan=1>Oracle - Target Super|</td><td rowspan=1 colspan=1>B</td><td rowspan=1 colspan=4>Bl97.379.8 88.6 32.5 48.2 56.3 63.6 73.3 89.0 58.9 93.0 78.2 55.2 92.2 45.067.339.649.973.667.489.6 94.3</td></tr></table>",
+        "bbox": [
+            173,
+            103,
+            828,
+            314
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 3: Adaptation between GTA5 and Cityscapes, showing IoU for each class and mean IoU, freqweighted IoU and pixel accuracy. CyCADA significantly outperforms baselines, nearly closing the gap to the target-trained oracle on pixel accuracy. ${ } ^ { * } \\mathrm { F C N s }$ in the wild is by Hoffman et al. (2016). We compare our model using two base semantic segmentation architectures (A) VGG16-FCN8s (Long et al., 2015) base network and (B) DRN-26 (Yu et al., 2017). ",
+        "bbox": [
+            173,
+            330,
+            826,
+            401
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/c1ebd165b65576a5bb30ce1a2131979e40f77574234df9deeff59fccc176e169.jpg",
+        "image_caption": [
+            "Figure 5: GTA5 to CityScapes Image Translation. Example images from the GTA5 (a) and Cityscapes (c) datasets, alongside their image-space conversions to the opposite domain, (b) and (d), respectively. Our model achieves highly realistic domain conversions. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            166,
+            416,
+            836,
+            569
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "straightforward adaptation between the two domains. For an additional experiment evaluating cross-season adaptation in synthetic environments see the Appendix. ",
+        "bbox": [
+            173,
+            651,
+            823,
+            680
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Image-space adaptation also affords us the ability to visually inspect the results of the adaptation method. This is a distinct advantage over opaque feature-space adaptation methods, especially in truly unsupervised settings—without labels, there is no way to empirically evaluate the adapted model, and thus no way to verify that adaptation is improving task performance. Visually confirming that the conversions between source and target images are reasonable, while not a guarantee of improved task performance, can serve as a sanity check to ensure that adaptation is not completely diverging. This process is diagrammed in Figure 2. For implementation details please see Appendix A.1.2. ",
+        "bbox": [
+            174,
+            686,
+            825,
+            785
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.2.1 SYNTHETIC TO REAL ADAPTATION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            801,
+            467,
+            815
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To evaluate our method’s applicability to real-world adaptation settings, we investigate adaptation from synthetic to real-world imagery. The results of this evaluation are presented in Table 3 with qualitative results shown in Figure 4. Once again, CyCADA achieves state-of-the-art results, recovering approximately $40 \\%$ of the performance lost to domain shift. CyCADA also improves or maintains performance on all 19 classes. Examination of fwIoU and pixel accuracy as well as individual class IoUs reveals that our method performs well on most of the common classes. Although some classes such as train and bicycle see little or no improvement, we note that those classes are poorly represented in the GTA5 data, making recognition very difficult. We compare our model against Shrivastava et al. (2017) for this setting, but found this approach did not converge and resulted in worse performance than the source only model (see Appendix for full details). ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We visualize the results of image-space adaptation between GTA5 and Cityscapes in Figure 5. The most obvious difference between the original images and the adapted images is the saturation levels— the GTA5 imagery is much more vivid than the Cityscapes imagery, so adaptation adjusts the colors to compensate. We also observe texture changes, which are perhaps most apparent in the road: in-game, the roads appear rough with many blemishes, but Cityscapes roads tend to be fairly uniform in appearance, so in converting from GTA5 to Cityscapes, our model removes most of the texture. Somewhat amusingly, our model has a tendency to add a hood ornament to the bottom of the image, which, while likely irrelevant to the segmentation task, serves as a further indication that image-space adaptation is producing reasonable results. ",
+        "bbox": [
+            174,
+            152,
+            825,
+            277
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            299,
+            318,
+            315
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We presented a cycle-consistent adversarial domain adaptation method that unifies cycle-consistent adversarial models with adversarial adaptation methods. CyCADA is able to adapt even in the absence of target labels and is broadly applicable at both the pixel-level and in feature space. An image-space adaptation instantiation of CyCADA also provides additional interpretability and serves as a useful way to verify successful adaptation. Finally, we experimentally validated our model on a variety of adaptation tasks: state-of-the-art results in multiple evaluation settings indicate its effectiveness, even on challenging synthetic-to-real tasks. ",
+        "bbox": [
+            174,
+            332,
+            825,
+            429
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            453,
+            285,
+            467
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Martin Arjovsky, Soumith Chintala, and Léon Bottou. Wasserstein gan. CoRR, abs/1701.07875, 2017. URL http://arxiv.org/abs/1701.07875. ",
+        "bbox": [
+            173,
+            477,
+            825,
+            505
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Konstantinos Bousmalis, Alex Irpan, Paul Wohlhart, Yunfei Bai, Matthew Kelcey, Mrinal Kalakrishnan, Laura Downs, Julian Ibarz, Peter Pastor, Kurt Konolige, Sergey Levine, and Vincent Vanhoucke. Using simulation and domain adaptation to improve efficiency of deep robotic grasping. CoRR, abs/1709.07857, 2017a. URL http://arxiv.org/abs/1709.07857. ",
+        "bbox": [
+            174,
+            516,
+            826,
+            573
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Konstantinos Bousmalis, Nathan Silberman, David Dohan, Dumitru Erhan, and Dilip Krishnan. Unsupervised pixel-level domain adaptation with generative adversarial networks. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), July 2017b. ",
+        "bbox": [
+            174,
+            584,
+            825,
+            627
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yi-Hsin Chen, Wei-Yu Chen, Yu-Ting Chen, Bo-Cheng Tsai, Yu-Chiang Frank Wang, and Min Sun. No more discrimination: Cross city adaptation of road scene segmenters. In The IEEE International Conference on Computer Vision (ICCV), Oct 2017. ",
+        "bbox": [
+            176,
+            637,
+            825,
+            681
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Marius Cordts, Mohamed Omran, Sebastian Ramos, Timo Rehfeld, Markus Enzweiler, Rodrigo Benenson, Uwe Franke, Stefan Roth, and Bernt Schiele. The Cityscapes dataset for semantic urban scene understanding. In Proc. of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2016. ",
+        "bbox": [
+            174,
+            691,
+            825,
+            748
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Emily L Denton, Soumith Chintala, Rob Fergus, et al. Deep generative image models using a laplacian pyramid of adversarial networks. In Neural Information Processing Systems (NIPS), pp. 1486–1494, 2015. ",
+        "bbox": [
+            174,
+            761,
+            825,
+            803
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jeff Donahue, Philipp Krähenbühl, and Trevor Darrell. Adversarial feature learning. In ICLR, 2017. ",
+        "bbox": [
+            171,
+            814,
+            825,
+            830
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Vincent Dumoulin, Ishmael Belghazi, Ben Poole, Alex Lamb, Martin Arjovsky, Olivier Mastropietro, and Aaron Courville. Adversarially learned inference. arXiv preprint arXiv:1606.00704, 2016. ",
+        "bbox": [
+            171,
+            840,
+            825,
+            869
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Y. Ganin, E. Ustinova, H. Ajakan, P. Germain, H. Larochelle, F. Laviolette, M. Marchand, and V. Lempitsky. Domain-adversarial training of neural networks. Journal of Machine Learning Research, 2016. ",
+        "bbox": [
+            176,
+            881,
+            825,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yaroslav Ganin and Victor Lempitsky. Unsupervised domain adaptation by backpropagation. In David Blei and Francis Bach (eds.), Proceedings of the 32nd International Conference on Machine Learning (ICML-15), pp. 1180–1189. JMLR Workshop and Conference Proceedings, 2015. URL http://jmlr.org/proceedings/papers/v37/ganin15.pdf. ",
+        "bbox": [
+            176,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Leon A Gatys, Alexander S Ecker, and Matthias Bethge. Image style transfer using convolutional neural networks. In Computer Vision and Pattern Recognition (CVPR), pp. 2414–2423, 2016. ",
+        "bbox": [
+            173,
+            170,
+            820,
+            198
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Muhammad Ghifary, W Bastiaan Kleijn, Mengjie Zhang, David Balduzzi, and Wen Li. Deep reconstruction-classification networks for unsupervised domain adaptation. In European Conference on Computer Vision (ECCV), pp. 597–613. Springer, 2016. ",
+        "bbox": [
+            174,
+            207,
+            826,
+            251
+        ],
+        "page_idx": 9
+    },
+    {
+        "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 27. 2014. URL http://papers.nips.cc/paper/ 5423-generative-adversarial-nets.pdf. ",
+        "bbox": [
+            174,
+            260,
+            826,
+            316
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "G. Hinton, O. Vinyals, and J. Dean. Distilling the knowledge in a neural network. 2015. ",
+        "bbox": [
+            171,
+            325,
+            750,
+            342
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Judy Hoffman, Dequan Wang, Fisher Yu, and Trevor Darrell. FCNs in the wild: Pixel-level adversarial and constraint-based adaptation. CoRR, abs/1612.02649, 2016. URL http://arxiv.org/ abs/1612.02649. ",
+        "bbox": [
+            173,
+            351,
+            825,
+            393
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Phillip Isola, Jun-Yan Zhu, Tinghui Zhou, and Alexei A Efros. Image-to-image translation with conditional adversarial networks. arXiv preprint arXiv:1611.07004, 2016. ",
+        "bbox": [
+            173,
+            402,
+            823,
+            433
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Levent Karacan, Zeynep Akata, Aykut Erdem, and Erkut Erdem. Learning to generate images of outdoor scenes from attributes and semantic layouts. arXiv preprint arXiv:1612.00215, 2016. ",
+        "bbox": [
+            173,
+            440,
+            825,
+            470
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Taeksoo Kim, Moonsu Cha, Hyunsoo Kim, Jung Kwon Lee, and Jiwon Kim. Learning to discover cross-domain relations with generative adversarial networks. arXiv preprint arXiv:1703.05192, 2017. ",
+        "bbox": [
+            176,
+            479,
+            825,
+            522
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Y. LeCun, L. Bottou, Y. Bengio, and P. Haffner. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11):2278–2324, November 1998. ",
+        "bbox": [
+            176,
+            531,
+            823,
+            561
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Evgeny Levinkov and Mario Fritz. Sequential bayesian model update under structured scene prior for semantic road scenes labeling. In IEEE International Conference on Computer Vision (ICCV), 2013. URL http://scalable.mpi-inf.mpg.de/files/2013/10/levinkov13iccv. pdfhttp://www.d2.mpi-inf.mpg.de/sequential-bayesian-update. ",
+        "bbox": [
+            173,
+            570,
+            826,
+            628
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "M.-Y. Liu and O. Tuzel. Coupled generative adversarial networks. In Advances in Neural Information Processing Systems, 2016a. ",
+        "bbox": [
+            174,
+            637,
+            823,
+            665
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ming-Yu Liu and Oncel Tuzel. Coupled generative adversarial networks. In Neural Information Processing Systems (NIPS), 2016b. ",
+        "bbox": [
+            173,
+            674,
+            823,
+            704
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Long, Evan Shelhamer, and Trevor Darrell. Fully convolutional networks for semantic segmentation. CVPR (to appear), November 2015. ",
+        "bbox": [
+            171,
+            713,
+            825,
+            742
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mingsheng Long and Jianmin Wang. Learning transferable features with deep adaptation networks. In International Conference on Machine Learning (ICML), 2015. ",
+        "bbox": [
+            171,
+            752,
+            825,
+            781
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mehdi Mirza and Simon Osindero. Conditional generative adversarial nets. CoRR, abs/1411.1784, 2014. URL http://arxiv.org/abs/1411.1784. ",
+        "bbox": [
+            171,
+            790,
+            825,
+            820
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yuval Netzer, Tao Wang, Adam Coates, Alessandro Bissacco, Bo Wu, and Andrew Y. Ng. Reading digits in natural images with unsupervised feature learning. In NIPS Workshop on Deep Learning and Unsupervised Feature Learning 2011, 2011. URL http://ufldl.stanford.edu/ housenumbers/nips2011_housenumbers.pdf. ",
+        "bbox": [
+            174,
+            829,
+            825,
+            886
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. arXiv preprint arXiv:1511.06434, 2015. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Stephan R. Richter, Vibhav Vineet, Stefan Roth, and Vladlen Koltun. Playing for data: Ground truth from computer games. In Bastian Leibe, Jiri Matas, Nicu Sebe, and Max Welling (eds.), European Conference on Computer Vision (ECCV), volume 9906 of LNCS, pp. 102–118. Springer International Publishing, 2016. ",
+        "bbox": [
+            174,
+            103,
+            826,
+            160
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "German Ros, Laura Sellart, Joanna Materzynska, David Vazquez, and Antonio Lopez. The SYNTHIA Dataset: A large collection of synthetic images for semantic segmentation of urban scenes. In Proc. of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2016a. ",
+        "bbox": [
+            178,
+            170,
+            823,
+            213
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Germán Ros, Simon Stent, Pablo F. Alcantarilla, and Tomoki Watanabe. Training constrained deconvolutional networks for road scene semantic segmentation. CoRR, abs/1604.01545, 2016b. URL http://arxiv.org/abs/1604.01545. ",
+        "bbox": [
+            176,
+            223,
+            823,
+            266
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kate Saenko, Brian Kulis, Mario Fritz, and Trevor Darrell. Adapting visual category models to new domains. In European conference on computer vision, pp. 213–226. Springer, 2010. ",
+        "bbox": [
+            173,
+            276,
+            823,
+            306
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tim Salimans, Ian Goodfellow, Wojciech Zaremba, Vicki Cheung, Alec Radford, and Xi Chen. Improved techniques for training gans. arXiv preprint arXiv:1606.03498, 2016a. ",
+        "bbox": [
+            171,
+            315,
+            823,
+            345
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tim Salimans, Ian J. Goodfellow, Wojciech Zaremba, Vicki Cheung, Alec Radford, and Xi Chen. Improved techniques for training gans. CoRR, abs/1606.03498, 2016b. URL http://arxiv. org/abs/1606.03498. ",
+        "bbox": [
+            174,
+            354,
+            825,
+            397
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Patsorn Sangkloy, Jingwan Lu, Chen Fang, Fisher Yu, and James Hays. Scribbler: Controlling deep image synthesis with sketch and color. arXiv preprint arXiv:1612.00835, 2016. ",
+        "bbox": [
+            173,
+            407,
+            821,
+            438
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ashish Shrivastava, Tomas Pfister, Oncel Tuzel, Joshua Susskind, Wenda Wang, and Russell Webb. Learning from simulated and unsupervised images through adversarial training. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), July 2017. ",
+        "bbox": [
+            173,
+            445,
+            826,
+            491
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Baochen Sun and Kate Saenko. Deep CORAL: correlation alignment for deep domain adaptation. In ICCV workshop on Transferring and Adapting Source Knowledge in Computer Vision (TASK-CV), 2016. ",
+        "bbox": [
+            174,
+            500,
+            825,
+            542
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Y. Taigman, A. Polyak, and L. Wolf. Unsupervised cross-domain image generation. In International Conference on Learning Representations, 2017a. ",
+        "bbox": [
+            171,
+            553,
+            825,
+            583
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yaniv Taigman, Adam Polyak, and Lior Wolf. Unsupervised cross-domain image generation. In International Conference on Learning Representations (ICLR), 2017b. ",
+        "bbox": [
+            171,
+            592,
+            825,
+            622
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Antonio Torralba and Alexei A. Efros. Unbiased look at dataset bias. In CVPR’11, June 2011. ",
+        "bbox": [
+            171,
+            631,
+            792,
+            647
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Eric Tzeng, Judy Hoffman, Ning Zhang, Kate Saenko, and Trevor Darrell. Deep domain confusion: Maximizing for domain invariance. CoRR, abs/1412.3474, 2014. URL http://arxiv.org/ abs/1412.3474. ",
+        "bbox": [
+            173,
+            656,
+            826,
+            699
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Eric Tzeng, Judy Hoffman, Trevor Darrell, and Kate Saenko. Simultaneous deep transfer across domains and tasks. In International Conference in Computer Vision (ICCV), 2015. ",
+        "bbox": [
+            174,
+            710,
+            823,
+            739
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Eric Tzeng, Judy Hoffman, Kate Saenko, and Trevor Darrell. Adversarial discriminative domain adaptation. In Computer Vision and Pattern Recognition (CVPR), 2017. URL http://arxiv. org/abs/1702.05464. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            791
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zili Yi, Hao Zhang, Ping Tan Gong, et al. Dualgan: Unsupervised dual learning for image-to-image translation. arXiv preprint arXiv:1704.02510, 2017. ",
+        "bbox": [
+            168,
+            803,
+            825,
+            832
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Donggeun Yoo, Namil Kim, Sunggyun Park, Anthony S. Paek, and In-So Kweon. Pixel-level domain transfer. In European Conference on Computer Vision (ECCV), 2016. URL http: //arxiv.org/abs/1603.07442. ",
+        "bbox": [
+            173,
+            842,
+            823,
+            885
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Fisher Yu, Vladlen Koltun, and Thomas Funkhouser. Dilated residual networks. In Computer Vision and Pattern Recognition (CVPR), 2017. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yang Zhang, Philip David, and Boqing Gong. Curriculum domain adaptation for semantic segmentation of urban scenes. In The IEEE International Conference on Computer Vision (ICCV), Oct 2017. ",
+        "bbox": [
+            176,
+            103,
+            825,
+            145
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Junbo Zhao, Michael Mathieu, and Yann LeCun. Energy-based generative adversarial network. arXiv preprint arXiv:1609.03126, 2016. ",
+        "bbox": [
+            171,
+            155,
+            823,
+            183
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jun-Yan Zhu, Philipp Krähenbühl, Eli Shechtman, and Alexei A. Efros. Generative visual manipulation on the natural image manifold. In European Conference on Computer Vision (ECCV), 2016. ",
+        "bbox": [
+            173,
+            193,
+            825,
+            234
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jun-Yan Zhu, Taesung Park, Phillip Isola, and Alexei A Efros. Unpaired image-to-image translation using cycle-consistent adversarial networks. In International Conference on Computer Vision (ICCV), 2017. ",
+        "bbox": [
+            173,
+            244,
+            825,
+            286
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/6a62b2f45c133b0831590e2645f5857eaac1ec09e212af78a26171f5f7284713.jpg",
+        "image_caption": [
+            "Figure 6: Network architectures used for digit experiments. We show here the task net $( f )$ , discriminator for feature level adaptation $( D ^ { f e a t } )$ , discriminator for image level adaptation $( D ^ { i m a g e } )$ , and generator for source to target $( G )$ – same network used for target to source. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            99,
+            803,
+            400
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            489,
+            297,
+            505
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.1 IMPLEMENTATION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            526,
+            410,
+            540
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We begin by pretraining the source task model, $f _ { S }$ , using the task loss on the labeled source data. Next, we perform pixel-level adaptation using our image space GAN losses together with semantic consistency and cycle consistency losses. This yeilds learned parameters for the image transformations, $G _ { S  T }$ and $G _ { T  S }$ , image discriminators, $D _ { S }$ and $D _ { T }$ , as well as an initial setting of the task model, $f _ { T }$ , which is trained using pixel transformed source images and the corresponding source pixel labels. Finally, we perform feature space adpatation in order to update the target semantic model, $f _ { T }$ , to have features which are aligned between the source images mapped into target style and the real target images. During this phase, we learn the feature discriminator, $D _ { \\mathrm { f e a t } }$ and use this to guide the representation update to $f _ { T }$ . In general, our method could also perform phases 2 and 3 simultaneously, but this would require more GPU memory then available at the time of these experiments. ",
+        "bbox": [
+            173,
+            556,
+            825,
+            709
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "For all feature space adaptation we equally weight the generator and discriminator losses. We only update the generator when the discriminator accuracy is above $60 \\%$ over the last batch (digits) or last 100 iterations (semantic segmentation) – this reduces the potential for volatile training. If after an epoch (entire pass over dataset) no suitable discriminator is found, the feature adaptation stops, otherwise it continues until max iterations are reached. ",
+        "bbox": [
+            174,
+            717,
+            825,
+            785
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.1.1 DIGIT EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            811,
+            379,
+            825
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "For all digit experiments we use a variant of the LeNet architecture as the task net (Figure 6 left). Our feature discriminator network consists of 3 fully connected layers (Figure 6 mid left). The image discriminator network consists of 6 convolutional layers culminating in a single value per pixel (Figure 6 mid right). Finally, to generate one image domain from another we use a multilayer network which consists of convolution layers followed by two residual blocks and then deconvolution layers (Figure 6 right). All stages are trained using the Adam optimizer. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Hyperparameters. For training the source task net model, we use learning rate 1e-4 and train for 100 epochs over the data with batch size 128. For feature space adaptation we use learning rate 1e-5 and train for max 200 epochs over the data. For pixel space adaptation we train our generators and discriminators with equal weighting on all losses, use batch size 100, learning rate 2e-4 (default from CycleGAN), and trained for 50 epochs. We ran each experiment 4 times and report the average and standard error across the runs. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.1.2 SEMANTIC SEGMENTATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            207,
+            421,
+            222
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/a197c643d43f9e197cb05caf7e52e2370d9faa7358f944ebbb47559618aeba29.jpg",
+        "image_caption": [
+            "Figure 7: GTA5 to CityScapes Image Translation. Example images from the GTA5 (a) and Cityscapes (c) datasets, alongside their image-space conversions to the opposite domain, (b) and (d), respectively. Our model achieves highly realistic domain conversions. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            166,
+            241,
+            836,
+            666
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We experiment with both the VGG16-FCN8s Long et al. (2015) architecture as well as the DRN-26 Yu et al. (2017) architecture. For FCN8s, we train our source semantic segmentation model for 100k iterations using SGD with learning rate 1e-3 and momentum 0.9. For the DRN-26 architecture, we train our source semantic segmentation model for 115K iterations using SGD with learning rate 1e-3 and momentum 0.9. We use a crop size of $6 0 0 \\times 6 0 0$ and a batch size of 8 for this training. For cycle-consistent image level adaptation, we followed the network architecture and hyperparameters of CycleGAN(Zhu et al., 2017). All images were resized to have width of 1024 pixels while keeping the aspect ratio, and the training was performed with randomly cropped patches of size 400 by 400. Also, due to large size of the dataset, we trained only 20 epochs. For feature level adaptation, we train using SGD with momentum, 0.99, and learning rate 1e-5. We weight the representation loss ten times less than the discriminator loss as a convenience since otherwise the discriminator did not learn a suitable model within a single epoch. Then the segmentation model was trained separately using the adapted source images and the ground truth labels of the source data. Due to memory limitations we can only include a single source and single target image at a time (crops of size $7 6 8 x 7 6 8 $ ), this small batch is one of the main reasons for using a high momentum parameter. ",
+        "bbox": [
+            173,
+            743,
+            826,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/60aaff8c5fc6dd32b469c9dcc3291ec0e6952bea2ba405ea120ad0fe4a1cc068.jpg",
+        "image_caption": [
+            "Figure 8: Cross Season Image Translation. Example image-space conversions for the SYNTHIA seasons adaptation setting. We show real samples from each domain (Fall and Winter) alongside conversions to the opposite domain. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            101,
+            820,
+            191
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/3af9a94504e99cb95e61067aa27cf6277af2effcd895c10049d428af1b67e545.jpg",
+        "table_caption": [
+            "Table 4: Adaptation between seasons in the SYNTHIA dataset. We report IoU for each class and mean IoU, freq-weighted IoU and pixel accuracy. Our CyCADA method achieves state-of-the-art performance on average across all categories. ${ } ^ { * } \\mathrm { F C N s }$ in the wild is by Hoffman et al. (2016). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"13\">SYNTHIA Fall -→Winter</td></tr><tr><td></td><td>多</td><td>Buipping</td><td></td><td>seeare</td><td></td><td>Vegeeee</td><td></td><td>u</td><td>us ogen</td><td>uerrespad</td><td>elair</td><td>Brraiiaa</td><td>naiggee</td><td></td><td>Prrr pxecs NOIMJ</td></tr><tr><td>Source only</td><td>91.7</td><td>80.6</td><td>79.7</td><td>12.1</td><td>71.8</td><td>44.2</td><td>26.1</td><td>42.8</td><td>49.0</td><td>38.7</td><td>45.1</td><td>41.3 24.5</td><td>49.8</td><td>71.7</td><td>82.3</td></tr><tr><td>FCNs in the wild</td><td>92.1</td><td>86.7</td><td>91.3</td><td>20.8</td><td>72.7</td><td>52.9</td><td>46.5</td><td>64.3</td><td>50.0</td><td>59.5</td><td>54.6 57.5</td><td>26.1</td><td>59.6</td><td>一</td><td></td></tr><tr><td>CyCADA pixel-only</td><td>92.5</td><td>90.1</td><td>91.9</td><td>79.9</td><td>85.7</td><td>47.1</td><td>36.9</td><td>82.6</td><td>45.0</td><td>49.1</td><td>46.2 54.6</td><td>21.5</td><td>63.3</td><td>85.7</td><td>92.1</td></tr><tr><td>Oracle (Train on target)</td><td>93.8</td><td>92.2</td><td>94.7</td><td>90.7</td><td>90.2</td><td>64.4</td><td>38.1</td><td>88.5</td><td>55.4</td><td>51.0</td><td>52.0</td><td>68.9 37.3</td><td></td><td></td><td>70.589.9 94.5</td></tr></table>",
+        "bbox": [
+            199,
+            262,
+            797,
+            390
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            473,
+            823,
+            502
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "A.1.3 CROSS-SEASON ADAPTATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            522,
+            434,
+            536
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "As an additional semantic segmentation evaluation, we consider the SYNTHIA dataset (Ros et al., 2016a), which contains synthetic renderings of urban scenes. We use the SYNTHIA video sequences, which are rendered across a variety of environments, weather conditions, and lighting conditions. This provides a synthetic testbed for evaluating adaptation techniques. For comparison with previous work, in this work we focus on adaptation between seasons. We use only the front-facing views in the sequences so as to mimic dashcam imagery, and adapt from fall to winter. The subset of the dataset we use contains 13 classes and consists of 10,852 fall images and 7,654 winter images. ",
+        "bbox": [
+            174,
+            547,
+            825,
+            646
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We start by exploring the abilities of pixel space adaptation alone (using FCN8s architecture) for the setting of adapting across seasons in synthetic data. For this we use the SYNTHIA dataset and adapt from fall to winter weather conditions. Typically in unsupervised adaptation settings it is difficult to interpret what causes the performance improvement after adaptation. Therefore, we use this setting as an example where we may directly visualize the shift from fall to winter and inspect the intermediate pixel level adaptation result from our algorithm. In Figure 8 we show the result of pixel only adaptation as we generate a winter domain image (b) from a fall domain image (a), and visa versa (c-d). We may clearly see the changes of adding or removing snow. This visually interpretable result matches our expectation of the true shift between these domains and indeed results in favorable final semantic segmentation performance from fall to winter as shown in Table 4. We find that CyCADA achieves state-of-the-art performance on this task with image space adaptation alone, however does not recover full supervised learning performance (train on target). Some example errors includes adding snow to the sidewalks, but not to the road, while in the true winter domain snow appears in both locations. However, even this mistake is interesting as it implies that the model is learning to distinguish road from sidewalk during pixel adaptation, despite the lack of pixel annotations. ",
+        "bbox": [
+            174,
+            654,
+            825,
+            861
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Cycle-consistent adversarial adaptation achieves state-of-the-art adaptation performance. We see that under the fwIoU and pixel accuracy metrics, CyCADA approaches oracle performance, falling short by only a few points, despite being entirely unsupervised. This indicates that CyCADA is extremely effective at correcting the most common classes in the dataset. This conclusion is supported by inspection of the individual classes in Table 4, where we see the largest improvement on common classes such as road and sidewalk. ",
+        "bbox": [
+            174,
+            868,
+            823,
+            924
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/d835f66b2d3512ee3908e754ebeaafdf6ffb7f8b1aecabdbb74336155ddf2cb0.jpg",
+        "image_caption": [
+            "Figure 9: Image transformation results from Shrivastava et al. (2017) applied to GTA to CityScapes transformation. We demonstrate results using three different settings for $\\lambda$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            104,
+            848,
+            203
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/5e43524349abcba7b23192a72138d24d40cb64d2f8b73caf10d4cdcc6e14b30e.jpg",
+        "image_caption": [
+            "Figure 10: Confusion matrices for SVHN MNIST experiment. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            194,
+            261,
+            802,
+            446
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            500,
+            825,
+            527
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "A.2 COMPARISON TO SHRIVASTAVA ET AL. (2017) FOR SEMANTIC SEGMENTATION ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            544,
+            763,
+            559
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "We illustrate the performance of a recent pixel level adaptation approach proposed by Shrivastava et al. (2017) on our semantic segmentation data – GTA to Cityscapes. These images are significantly larger and more complex than those shown in the experiments in the original paper. We show image to image translation results under three different settings of the model hyperparameter, $\\lambda$ , which controls the tradeoff between the reconstruction loss and the visual style loss. When $\\lambda = 1 0$ (Figure 9 right), the resulting image converges to a near replica of the original image, thus preserving content but lacking the correct target style. When $\\lambda = 1$ or $\\lambda = 2 . 5$ (Figure 9 left), the results lack any consistent semantics making it difficult to perceive the style of the transformed image. Thus, the resulting performance for this model is 11.6 mIoU for FCN8s with VGG, well below the performance of the corresponding source model of 17.9 mIoU. ",
+        "bbox": [
+            173,
+            570,
+            825,
+            709
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "A.3 EXPERIMENT ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            727,
+            387,
+            741
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "To understand the types of mistakes which are improved upon and those which still persist after adaptation, we present the confusion matrices before and after our approach for the digit experiment of SVHN to MNIST (Figure 10). Before adaptation we see common confusions are 0s with 2s, 4s, and 7s. 6 with 4, 8 with 3, and 9 with 4. After adaptation all errors are reduced, but we still find that 7s are confused with 1s and 0s with 2s. These errors make some sense as with hand written digits, these digits sometimes resemble one another. It remains an open question to produce a model which may overcome these types of errors between highly similar classes. ",
+        "bbox": [
+            173,
+            752,
+            825,
+            851
+        ],
+        "page_idx": 15
+    }
+]

parse/train/SyJS-OgR-/SyJS-OgR-.md

@@ -0,0 +1,352 @@
+# MULTI-LEVEL RESIDUAL NETWORKS FROM DYNAMICAL SYSTEMS VIEW
+
+Bo Chang∗, Lili Meng∗ & Eldad Haber   
+University of British Columbia & Xtract Technologies Inc.   
+Vancouver, Canada   
+{bchang@stat, menglili@cs, haber@math}.ubc.ca
+
+Frederick Tung Simon Fraser University Burnaby, Canada ftung@sfu.ca
+
+David Begert Xtract Technologies Inc. Vancouver, Canada david@xtract.ai
+
+# ABSTRACT
+
+Deep residual networks (ResNets) and their variants are widely used in many computer vision applications and natural language processing tasks. However, the theoretical principles for designing and training ResNets are still not fully understood. Recently, several points of view have emerged to try to interpret ResNet theoretically, such as unraveled view, unrolled iterative estimation and dynamical systems view. In this paper, we adopt the dynamical systems point of view, and analyze the lesioning properties of ResNet both theoretically and experimentally. Based on these analyses, we additionally propose a novel method for accelerating ResNet training. We apply the proposed method to train ResNets and Wide ResNets for three image classification benchmarks, reducing training time by more than $40 \%$ with superior or on-par accuracy.
+
+# 1 INTRODUCTION
+
+Deep neural networks have powered many research areas from computer vision (He et al., 2016; Huang et al., 2017b), natural language processing (Cho et al., 2014) to biology (Esteva et al., 2017) and e-commerce (Ha et al., 2016). Deep Residual Networks (ResNets) (He et al., 2016), and their variants such as Wide ResNets (Zagoruyko & Komodakis, 2016) and DenseNets (Huang et al., 2017b), are among the most successful architectures. In ResNets, the authors employ identity skipconnections that bypass residual layers, allowing data to flow from previous layers directly to any subsequent layers.
+
+With the success of ResNet and its variants on various applications (He et al., 2016; 2017; Pohlen et al., 2017; Xiong et al., 2017; Oord et al., 2016; Wu et al., 2016), several views such as unraveled view (Veit et al., 2016), unrolled iterative estimation view (Greff et al., 2017) and dynamical systems view (Haber et al., 2017; E, 2017; Chang et al., 2017) have emerged to try to interpret ResNets through theoretical analysis and empirical results. These views provide preliminary interpretations, however, deep understanding of ResNets is still an active on-going research topic (Jastrzebski et al., 2017; Li et al., 2016; Hardt & Ma, 2017; Li & Yuan, 2017).
+
+The dynamical systems view interprets ResNets as ordinary differential equations (ODEs), a special kind of dynamical systems (Haber et al., 2017; E, 2017), opening up possibilities of exploiting the computational and theoretical success from dynamical systems to ResNets. From this point of view, stable and reversible architectures (Haber & Ruthotto, 2017; Chang et al., 2017) are developed. However, few empirical analysis of this view has been done and many phenomena such as the removing of layers not leading to performance drop are not explained by the dynamical systems view. In this work, we take steps forward to complement this dynamical systems view with empirical analysis of its properties and the lesion studies.
+
+![](images/d377ec59a5d2474336cd6064a296406b03a17fe1677a616c1e25b6ffb7c3dedf.jpg)  
+Figure 1: Dynamical systems view of ResNets. ResNets equally discretize the time interval $[ 0 , T ]$ using time points $T _ { 0 } , T _ { 1 } , \ldots , T _ { d }$ , where $T _ { 0 } = 0$ , $T _ { d } = T$ and $d$ is the total number of blocks.
+
+One challenge of deep ResNets is the long training time. It is extremely time-consuming to train on large datasets such as ImageNet or with very deep ResNets such as 1000-layer networks, which may Yjtake several days or even weeks on high-performance hardware with GPU acceleration. Recently Identitythe reversible residual networks (Gomez et al., 2017; Chang et al., 2017) consumes $50 \%$ more comG(Yj ) Yjputational time for reducing memory usage by reconstructing the activations, which exposes training time to be a more severe problem. Inspired by the dynamical systems interpretation, we additionally G(Y )+Ypropose a simple yet effective multi-level method for accelerating ResNets training.
+
+In summary, the main contributions of this work are:
+
+• We study the dynamical systems view and explain the lesion studies from this view through empirical analysis.   
+• We propose a simple yet efficient multi-level training method for ResNets based on dynamical systems view.   
+• We demonstrate the proposed multi-level training method on ResNets (He et al., 2016)  Stage 3 and Wide ResNets (Zagoruyko & Komodakis, 2016) across three widely used datasets, achieving more than $40 \%$ training time reduction with superior or on-par accuracy.
+
+# 2 RELATED WORKblock 1
+
+# 2.1 RESNETS AND VARIANTS
+
+ResNets (He et al., 2016) are deep neural networks of stacking simple residual blocks, which contain identity skip-connections that bypass the residual layers. A residual block, as shown in Fig. 2, can be written as
+
+$$
+\mathbf { Y } _ { j + 1 } = \mathbf { Y } _ { j } + G ( \mathbf { Y } _ { j } , \theta _ { j } ) \quad \mathrm { f o r } \quad j = 0 , . . . , N - 1 ,
+$$
+
+where $\mathbf { Y } _ { j }$ is the feature map at the $j$ th layer, $\theta _ { j }$ represents the jth layer’s network parameters. $G$ is referred to as a residual module, consisting of two convolutional layers. As shown in Fig. 1, the network is divided into several stages; each consists of a number of residual blocks. In the first block of each stage, the feature map size is halved, and the number of filters is doubled. The feature map remains the same dimensionality for subsequent blocks in a stage.
+
+![](images/1c1898bacb1675fcece0856e7935f6b61d37049480a1ec1e5cd0e5a91cd0ca65.jpg)  
+Figure 2: A residual block. Each residual block has two components: the residual module $G$ and the identity skip-connection, which add up to the output of a block.
+
+After the success of ResNets in popular competitions such as ImageNet (Russakovsky et al., 2015), Pascal VOC (Everingham et al.,
+
+2010) and Microsoft COCO (Lin et al., 2014), there emerged many successors (Huang et al., 2016; 2017b; Chang et al., 2017; Gomez et al., 2017; Targ et al., 2016; Hardt & Ma, 2017; Zagoruyko & Komodakis, 2016). For instance, DenseNet (Huang et al., 2017b) connects between any two layers with the same feature-map size. ResNxt (Xie et al., 2017) introduces a homogeneous, multi-branch architecture to increase the accuracy.
+
+# 2.2 INTERPRETATIONS OF RESNETS
+
+Unraveled view In Veit et al. (2016), ResNets are interpreted from an unraveled view in which ResNets are viewed as a collection of many paths which data flow along from input to output. Each residual block consists of a residual module and an identity skip-connection; a path is defined as a configuration of which residual module to enter and which to skip. For a ResNet with $n$ residual blocks, there are $2 ^ { n }$ unique paths. Through lesion studies, Veit et al. (2016) further demonstrate that paths in ResNets do not strongly depend on each other and behave like an ensemble. When a residual block is removed, the number of paths is reduced from $2 ^ { n }$ to $2 ^ { n - 1 }$ , leaving half of the paths still valid, which explains why ResNets are resilient to dropping blocks. Besides the explicit ensemble view, training ResNets with stochastic depth (Huang et al., 2016) can be viewed as an ensemble of networks with varying depths implicitly.
+
+Unrolled iterative estimation view ResNets are interpreted as unrolled iterative estimation in Greff et al. (2017). From this view, the level of representation stays the same within each stage. The residual blocks in a stage work together to estimate and iteratively refine a single level of representation: the first layer in a stage provides a rough estimate for the representation, and subsequent layers refine that estimate. An implication of this view is that processing in each block is incremental and removing blocks only has a mild effect on the final results. Based on this view, Jastrzebski et al. (2017) provide more analytical and empirical results.
+
+Dynamical systems view ResNets can be interpreted as a discretization of dynamical systems (Haber et al., 2017; E, 2017). The basic dynamics at each step is a linear transformation followed by component-wise nonlinear activation function. The behavior of large dynamical systems is often a notoriously difficult problem in mathematics, particularly for discrete dynamical systems. This is similar to the gradient exploding/vanishing problem for deep neural networks or recurrent neural networks. Imposing structural constraints on dynamical systems such as Hamiltonian systems to conserve the energy is explored in Haber & Ruthotto (2017); Chang et al. (2017). However, no interpretation on the phenomenon of deleting layers is studied from this point of view.
+
+# 2.3 RESNETS EFFICIENT TRAINING METHODS
+
+One major challenge of deep ResNets is their long training time. To alleviate this issue, several attempts have been made. Stochastic depth (Huang et al., 2016) randomly drops entire residual blocks during training and bypassing their transformations through identity skip-connections; during testing, all the blocks are in use. When a block is bypassed for a specific iteration, there is no need to perform forward-backward computation. With stochastic depth, approximately $2 5 \%$ of training time could be saved. Figurnov et al. (2017) reduce the inference time of residual networks by learning to predict early halting scores based on the image content. Huang et al. (2017a) investigate image classification with computational resource limits at test time. SparseNets (Zhu et al., 2018) is a simple feature aggregation structure with shortcut paths bypassing exponentially growing number of layers. Mollifying networks (Gulcehre et al., 2016) start the optimization with an easier (possibly convex) objective function and let it evolve during the training, until it eventually goes back to being the original, difficult to optimize, objective function. It can also be interpreted as a form adaptive noise injection that only depends on a single hyperparameter.
+
+# 3 RESNETS FROM DYNAMICAL SYSTEMS VIEW
+
+In this section, we first provide a brief introduction to the dynamical systems view in which ResNets are considered as ODEs. Based on this view, we provide empirical analysis to explain some intriguing properties and phenomena of ResNets.
+
+# 3.1 DYNAMICAL SYSTEMS VIEW
+
+For the pre-activation ResNets $\mathbf { Y } _ { j + 1 } = \mathbf { Y } _ { j } + G ( \mathbf { Y } _ { j } , \pmb { \theta } _ { j } )$ , the residual module $G$ consists of two sets of batch normalization, ReLU and convolutional layers. Without loss of generality, we can conceptually add a parameter $h$ and rewrite the residual module as $G = h F$ . The residual block becomes
+
+$$
+{ \displaystyle { \bf Y } _ { j + 1 } = { \bf Y } _ { j } + h F ( { \bf Y } _ { j } , { \boldsymbol { \theta } } _ { j } ) } ,
+$$
+
+![](images/b76403ac46f23ec11d3699307bf14560f45112056f406b3dd7fc089c6c3887dc.jpg)  
+Figure 3: The average $L ^ { 2 }$ -norm of the residual modules γ vs the number of residual blocks $d$ . The curve resembles a reciprocal function, which is consistent with Eq. (5) and the dynamical systems view.
+
+which can be further rewritten as
+
+$$
+\frac { { \bf Y } _ { j + 1 } - { \bf Y } _ { j } } { h } = F ( { \bf Y } _ { j } , \theta _ { j } ) .
+$$
+
+For a sufficiently small $h$ , Eq. (3) can be regarded as a forward Euler discretization of the initial value ODE
+
+$$
+\dot { \mathbf { Y } } ( t ) = F ( \mathbf { Y } ( t ) , \theta ( t ) ) , \mathbf { Y } ( 0 ) = \mathbf { Y } _ { 0 } , \mathrm { f o r } 0 \leq t \leq T ,
+$$
+
+where time $t$ corresponds to the direction from input to output, $\mathbf { Y } ( 0 )$ is the input feature map after the initial convolution, and $\mathbf { Y } ( T )$ is the output feature map before the softmax classifier. Thus, the problem of learning the network parameters, $\theta$ , is equivalent to solving a parameter estimation problem or optimal control problem involving the ODE in Eq. (4).
+
+# 3.2 TIME STEP SIZE
+
+The new parameter $h$ is called the step size of discretization. In the original formulation of ResNets in Eq. (1), $h$ does not exist, and is implicitly absorbed by the residual module $G$ . We call it the implicit step size. The step size $h$ can also be explicitly expressed in the model: the output of the residual module is multiplied by $h$ before being added to the identity mapping. In this case, $h$ is a hyper-parameter and we name it the explicit step size. In this section, we only consider implicit step size.
+
+We assume that $\mathbf { Y } ( 0 )$ and $\mathbf { Y } ( T )$ correspond to the input and output feature maps of the network respectively, where the time length $T$ is fixed. As illustrated in Fig. 1, ResNets equally discretize $[ 0 , { \bar { T } } ]$ using time points $T _ { 0 } , T _ { 1 } , \dots , T _ { j } , \dots , T _ { d }$ , where $T _ { 0 } = 0$ , $T _ { d } = T$ and $d$ is the number of blocks. Thus each time step is $h = T _ { j + 1 } - T _ { j } = T / d$ .
+
+Thus, we can obtain
+
+$$
+\| G ( \mathbf { Y } _ { j } ) \| = \| h F ( \mathbf { Y } _ { j } ) \| = { \frac { T } { d } } \| F ( \mathbf { Y } _ { j } ) \| ,
+$$
+
+where $F$ in the underlying ODE in Eq. (4) does not depend on $d$ . In other words, $d$ is inversely proportional to the norm of the residual modules $G ( Y _ { j } )$ .
+
+Empirical analysis To verify the above statement, we run experiments on ResNets with varying depths. If our theory is correct, the norm of the residual module $\| G ( \mathbf { Y } _ { j } ) \|$ should be inversely proportional to the number of residual blocks. Take ResNet-32 with 15 residual blocks in total as an example. We calculate the average $L ^ { 2 }$ -norm of the residual modules $\begin{array} { r } { \gamma = \frac { 1 } { 1 5 } \sum _ { j = 1 } ^ { 1 5 } \| G ( \mathbf { Y } _ { j } ) \| } \end{array}$ . Figure 3 shows $\gamma$ for different ResNet models. The curve resembles a reciprocal function, which is consistent with Eq. (5) and the dynamical system point of view.
+
+![](images/9140354a839c0425bc0d3733b46363ba220cecb260153a4ddf7b7cc7ca58f3d9.jpg)  
+Figure 4: $L ^ { 2 }$ -norm of the input and output of the residual module $G$ . ResNet-110 models are trained on CIFAR-10 and CIFAR-100. The norms are evaluated at test time. It shows that within a residual block, the identity mapping contributes much more than the residual module. In other words, $G ( \mathbf { Y } _ { j } )$ is relatively small for most residual blocks.
+
+# 3.3 LESION STUDY
+
+Lesion studies for ResNets in Veit et al. (2016) remove single or multiple residual blocks, and shuffle the residual blocks at test time. Surprisingly, only removing downsampling blocks has a modest impact on performance, no other block removal leads to a noticeable effect.
+
+According to the dynamical systems view, removing one residual block is equivalent to skipping one time step and squeezing two adjacent steps into one. This operation may change the dynamical system. However, we will show in the following that the effect is negligible when the output of residual module $G ( \mathbf { Y } _ { j } )$ is small enough.
+
+Let $t _ { 0 } , t _ { 1 } , t _ { 2 }$ be three consecutive time points such that $t _ { 1 } = t _ { 0 } + h$ and $t _ { 2 } = t _ { 0 } + 2 h$ . Suppose the removed block corresponds to time point $t _ { 1 }$ . Before the removal of the time point, the discretization is
+
+$$
+\begin{array} { r l } & { { \mathbf Y } ( t _ { 1 } ) = { \mathbf Y } ( t _ { 0 } ) + h F ( { \mathbf Y } ( t _ { 0 } ) ) , } \\ & { { \mathbf Y } ( t _ { 2 } ) = { \mathbf Y } ( t _ { 1 } ) + h F ( { \mathbf Y } ( t _ { 1 } ) ) = { \mathbf Y } ( t _ { 0 } ) + h F ( { \mathbf Y } ( t _ { 0 } ) ) + h F ( { \mathbf Y } ( t _ { 1 } ) ) . } \end{array}
+$$
+
+After $t _ { 1 }$ is removed, the time interval $[ t _ { 0 } , t _ { 2 } ]$ is squeezed to $[ t _ { 0 } , t _ { 2 } ^ { \prime } ]$ , where $t _ { 2 } ^ { \prime } = t _ { 0 } + h$ is the new time point after $t _ { 0 }$ . The new discretization is
+
+$$
+\mathbf { Y } ( t _ { 2 } ^ { \prime } ) = \mathbf { Y } ( t _ { 0 } ) + h F ( \mathbf { Y } ( t _ { 0 } ) ) .
+$$
+
+The difference of the feature before and after the removal operation is
+
+$$
+\mathbf { Y } ( t _ { 2 } ^ { \prime } ) - \mathbf { Y } ( t _ { 2 } ) = h F ( \mathbf { Y } ( t _ { 1 } ) ) ,
+$$
+
+which is the output of the residual module $G ( \mathbf { Y } ( t _ { 1 } ) )$ . Therefore, the effect of removing the block is negligible when $\dot { G } ( \mathbf { Y } ( t _ { 1 } ) )$ is small.
+
+Empirical analysis To empirically verify that $G ( \mathbf { Y } ( t ) )$ are small, we train a ResNet-110 model (3 stages with 18 residual blocks per stage) on CIFAR-10/100, and plot the $L ^ { 2 }$ -norm of input $\mathbf { Y } _ { j }$ and output $G ( \mathbf { Y } _ { j } )$ of each residual module at test time. As shown in Figure 4, except for the first block at each stage, later blocks have tiny residual module outputs $G ( \mathbf { Y } _ { j } )$ compared with the inputs $\mathbf { Y } _ { j }$ . This provides an explanation why removing one block does not notably impact the performance.
+
+The effect of shuffling residual blocks can be analyzed in a similar way. When the outputs of the residual modules are small, each block only slightly modifies the feature map. Therefore, we can expect the effect of shuffling to be moderate, especially in later stages.
+
+When the network is deep, the outputs of the residual modules are close to zero. Each residual module can be regarded as feature refinement. The magnitude of change is large only in the first block; the subsequent blocks only slightly refine the features, which is consistent with the unrolled iterative estimation view.
+
+![](images/d53f066a25d3ad1a051641e98389f917831fec011850ffd199bf5c8417a39b31.jpg)  
+Figure 5: An illustration of the interpolation operation for one stage. We insert one residual block right after each existing block in the stage. The model parameters, including convolutional weights and batch normalization parameters, are copied from the adjacent old block to interpolated blocks. After that, the explicit step size $h$ is halved. For example, before interpolation, this stage has three residual blocks, numbered 1 to 3. After interpolation, block 1, 2 and 3 become block 1’, $_ { 3 } ,$ and $_ 5 '$ respectively. Three new blocks are inserted: block $2 ^ { \bullet }$ , $_ 4 \cdot$ and $\mathbf { \omega } _ { 6 } { \mathrm { : } }$ , whose parameters are copied from its previous block respectively.
+
+<table><tr><td></td><td>#Residual Blocks</td><td>Explicit Step Size h# Training Steps</td><td></td></tr><tr><td>Cycle 1</td><td>2-2-2</td><td>1</td><td>N1</td></tr><tr><td>Cycle 2</td><td>4-4-4</td><td>0.5</td><td>N2</td></tr><tr><td>Cycle 3</td><td>8-8-8</td><td>0.25</td><td>N3</td></tr></table>
+
+Table 1: An illustration of the multi-level method with 3 cycles. The ResNet model has 3 stages; # Residual Blocks column represents the number of blocks in each stage. In cycle 1, the training starts with a 2-2-2 model using $h = 1$ . After $N _ { 1 }$ training steps, the first interpolation happens: the model becomes 4-4-4, and the step size is halved to 0.5. Similarly, $N _ { 2 }$ training steps later, the second interpolation doubles the number of blocks to 8-8-8 and halves $h$ to 0.25. Cycle 3 lasts for $N _ { 3 }$ training steps.
+
+# 4 EFFICIENT TRAINING WITH MULTI-LEVEL METHOD
+
+Given the connection between ResNets and ODEs, existing theories and numerical techniques for ODEs can be applied to ResNets. In numerical analysis, multi-grid methods (Hackbusch, 2013) are algorithms for solving differential equations using a hierarchy of discretizations with varying step sizes. Inspired by multi-grid methods, we propose the multi-level training method.
+
+# 4.1 MULTI-LEVEL TRAINING
+
+The idea of the multi-level method is, during training, we start with a shallow network using a large explicit step size $h$ . After a few training steps, we switch to a deeper network, by doubling the number of residual blocks and halving the step size to $h / 2$ . This operation is called interpolation, which applies to all the stages at the same time. Fig. 5 illustrates the interpolation operation for one stage. The interpolation operation inserts a new residual block right after every existing block, and copies the convolutional weights and batch normalization parameters from the adjacent old block to the new block.
+
+In the multi-level training process, interpolations happen several times, thus dividing the training steps into cycles. Table 1 gives an example to illustrate this process. According to our dynamical systems view, by interpolating the residual blocks and halving the step size, we solve exactly the same differential equation. Therefore, the interpolation operation at the beginning of a cycle gives a good initialization of the parameters.
+
+Each cycle itself can be regarded as a training process, thus we need to reset the learning rate to a large value at the beginning of each training cycle and anneal the learning rate during that cycle. Here we adopt the cosine annealing learning rate schedule (Loshchilov & Hutter, 2017). Within
+
+Table 2: Number of interpolations vs theoretical time saved, relative to the full model. Theoretically, time saved is monotonically increasing as the number of interpolation increases, but the marginal benefit is diminishing.   
+
+<table><tr><td># Interpolations</td><td>0</td><td>1</td><td>2</td><td>3</td><td>4</td><td>5</td><td></td></tr><tr><td>Theoretical TimeSaved</td><td>0%</td><td>25%</td><td>42%</td><td>53%</td><td>61%</td><td>67%</td><td>：</td></tr></table>
+
+each cycle, the learning rate is
+
+$$
+\eta = \eta _ { \mathrm { m i n } } + \frac { 1 } { 2 } ( \eta _ { \mathrm { m a x } } - \eta _ { \mathrm { m i n } } ) ( 1 + \cos ( \frac { T _ { \mathrm { c u r } } } { T } \pi ) ) ,
+$$
+
+where $\eta _ { \mathrm { m i n } }$ and $\eta _ { \mathrm { m a x } }$ represent the minimum and maximum learning rate respectively, $T _ { \mathrm { c u r } }$ accounts for how many training steps have been performed in the current cycle, and $T$ denotes the total number of training steps in this cycle. The learning rate starts from $\eta _ { \mathrm { m a x } }$ at the beginning of each cycle and decreases to $\eta _ { \mathrm { m i n } }$ at the end of the cycle.
+
+# 4.2 TRAINING TIME
+
+Since the number of residual blocks in cycle $i$ is half of that in cycle $i + 1$ , theoretically, the running time in cycle $i$ should also be half of that in cycle $i + 1$ . Take a multi-level method with two cycles as an example, it trains a shallow model (2-2-2 blocks) for $N$ steps and switches to a deep model (4-4-4 blocks) for another $N$ steps. Compared with the deep model trained for $2 N$ steps, the multi-level method reduces training time by $1 / 4$ .
+
+More generally, if one uses the multi-level method with $k$ interpolations equally dividing the training steps, theoretically it saves $1 - \frac { 2 ^ { k + 1 } - 1 } { 2 ^ { k } ( k + 1 ) }$ of training time, compared to the full model (model in the last cycle) trained for the same number of total steps. Table 2 shows the theoretical time saved. Time saved is monotonically increasing as the number of interpolation increases, but the marginal time saved is diminishing. Furthermore, when the number of interpolations is large, each cycle might not have enough training steps. Therefore, there is a trade-off between efficiency and accuracy.
+
+# 5 EXPERIMENTS
+
+The empirical results on the dynamical systems view are presented in Sec. 3.2 and 3.3. In this section, we evaluate the efficacy and efficiency of the proposed multi-level method on two state-ofthe art deep learning architectures for image classification: ResNet and Wide ResNet, across three standard benchmarks.
+
+Table 3: Main multi-level method results for ResNets with different depths. The model name with $i$ corresponds to the multi-level method. Our multi-level training method achieves superior or on-par accuracy with the last cycle model while saving about $40 \%$ of training time. The unit of training time is a minute.   
+
+<table><tr><td rowspan=2 colspan=1>Model</td><td rowspan=2 colspan=1># Blocks</td><td rowspan=1 colspan=2>CIFAR-10</td><td rowspan=1 colspan=2>CIFAR-100</td><td rowspan=1 colspan=2>STL-10</td></tr><tr><td rowspan=1 colspan=1>Error</td><td rowspan=1 colspan=1>Time</td><td rowspan=1 colspan=1>Error</td><td rowspan=1 colspan=1>Time</td><td rowspan=1 colspan=1>Error</td><td rowspan=1 colspan=1>Time</td></tr><tr><td rowspan=1 colspan=1>ResNet-14ResNet-50</td><td rowspan=1 colspan=1>2-2-28-8-8</td><td rowspan=1 colspan=1>9.75%7.58%</td><td rowspan=1 colspan=1>38m114m</td><td rowspan=1 colspan=1>33.34%28.64%</td><td rowspan=1 colspan=1>38m115m</td><td rowspan=1 colspan=1>27.78%25.95%</td><td rowspan=1 colspan=1>33m114m</td></tr><tr><td rowspan=1 colspan=1>ResNet-50-i (Ours)</td><td rowspan=1 colspan=1>2-2-2 to8-8-8</td><td rowspan=1 colspan=1>7.10%</td><td rowspan=1 colspan=1>67m</td><td rowspan=1 colspan=1>28.71%</td><td rowspan=1 colspan=1>68m</td><td rowspan=1 colspan=1>25.98%</td><td rowspan=1 colspan=1>68m</td></tr><tr><td rowspan=1 colspan=1>ResNet-32ResNet-122</td><td rowspan=1 colspan=1>5-5-520-20-20</td><td rowspan=1 colspan=1>7.74%6.47%</td><td rowspan=1 colspan=1>76m266m</td><td rowspan=1 colspan=1>29.96%26.74%</td><td rowspan=1 colspan=1>74m266m</td><td rowspan=1 colspan=1>26.02%25.16%</td><td rowspan=1 colspan=1>71m266m</td></tr><tr><td rowspan=1 colspan=1>ResNet-122-i (Ours)</td><td rowspan=1 colspan=1>5-5-5 to20-20-20</td><td rowspan=1 colspan=1>6.56%</td><td rowspan=1 colspan=1>154m</td><td rowspan=1 colspan=1>26.81%</td><td rowspan=1 colspan=1>154m</td><td rowspan=1 colspan=1>24.36%</td><td rowspan=1 colspan=1>162m</td></tr></table>
+
+# 5.1 DATASETS AND NETWORKS
+
+Datasets Three widely used datasets are used for evaluation: CIFAR-10, CIFAR-100 (Krizhevsky & Hinton, 2009), and STL10 (Coates et al., 2011). Details on these datasets and data augmentation methods can be found in Appendix A.
+
+Networks We use ResNets (He et al., 2016) and Wide ResNets (Zagoruyko & Komodakis, 2016) for all the datasets. All the networks have three stages, with the number of filters equal to 16-32-64 for ResNets, and 32-64-128 for Wide ResNets.
+
+# 5.2 EXPERIMENTAL SETTINGS
+
+Based on the analysis in Table 2, we use two interpolations, that is three cycles, for the multi-level method in order to optimize the trade-off between efficiency and accuracy.
+
+For each experiment, we run our multi-level model with three cycles. For comparison, two other models are trained for the same number of steps: a model with the same architecture as the first cycle and a model with the same architecture as the last cycle.
+
+We call them first cycle model and last cycle model respectively. We also use the cyclic learning rate schedule (Loshchilov & Hutter, 2017) for the first cycle model and last cycle model for fair comparison.
+
+All the models are trained for 160 epochs. For our multi-level method, the models are interpolated at the 60th and 110th epochs. For baseline models, the learning rate cycle also restarts at epoch 60 and 110. The maximum and minimum learning rates $\eta _ { \mathrm { m i n } }$ and $\eta _ { \mathrm { m a x } }$ are set 0.001 and 0.5 respectively. For CIFAR-10 and CIFAR-100 experiments, the mini-batch size is 100. For STL-10 experiments, the mini-batch size is 32. We use a weight decay of $2 \times 1 0 ^ { - 4 }$ , and momentum of 0.9. All the experiments are evaluated on machines with a single Nvidia GeForce GTX 1080 GPU. The networks are implemented using TensorFlow library (Abadi et al., 2016).
+
+# 5.3 MAIN RESULTS AND ANALYSIS
+
+We present the main results and analysis in this section. More experimental results can be found in Appendix D. The theoretical time saved for two interpolations is $42 \%$ , which is consistent with the experiment results.
+
+The main results are shown in Table 3 and 4, for ResNets and Wide ResNets respectively. We report the test error rate and training time. Compared with the first cycle model, our multi-level method achieves much lower test error. Compared with the last cycle model, the test error is competitive or slightly lower, but the training time reduction is over $40 \%$ . This result applies to both ResNets and WResNets across three datasets. The interpolation of (Wide) ResNet-50-i from 2-2-2 to 8-8-8 and (Wide) ResNet-122-i from 5-5-5 to 20-20-20 show that our multi-level training method is effective for different network depths.
+
+The train and test curves with both ResNets and Wide ResNets are shown in Fig. 6. Although both training and test accuracy temporarily drops at the start of each cycle, the performance eventually surpasses the previous cycles. ResNets and Wide ResNets have similar train and test curves, indicating that our multi-level training method is effective for different network widths.
+
+# 6 CONCLUSION
+
+In this work, we study ResNets from the dynamical systems view and explain the lesion studies from this view through both theoretical and empirical analyses. Based on these analyses, we develop a simple yet effective multi-level method for accelerating the training of ResNets. The proposed multi-level training method is evaluated on two state-of-the-art residual network architectures across three widely used classification benchmarks, reducing training time by more than $40 \%$ with similar accuracy. For future work, we would like to explore the dynamical systems view on other ResNets variants such as DenseNets.
+
+<table><tr><td rowspan=2 colspan=1>Model</td><td rowspan=2 colspan=1># Blocks</td><td rowspan=1 colspan=2>CIFAR-10</td><td rowspan=1 colspan=2>CIFAR-100</td><td rowspan=1 colspan=2>STL-10</td></tr><tr><td rowspan=1 colspan=1>Error</td><td rowspan=1 colspan=1>Time</td><td rowspan=1 colspan=1>Error</td><td rowspan=1 colspan=1>Time</td><td rowspan=1 colspan=1>Error</td><td rowspan=1 colspan=1>Time</td></tr><tr><td rowspan=1 colspan=1>WResNet-14WResNet-50</td><td rowspan=1 colspan=1>2-2-28-8-8</td><td rowspan=1 colspan=1>7.38%5.87%</td><td rowspan=1 colspan=1>51m174m</td><td rowspan=1 colspan=1>27.92%24.49%</td><td rowspan=1 colspan=1>51m173m</td><td rowspan=1 colspan=1>24.58%23.82%</td><td rowspan=1 colspan=1>63m222m</td></tr><tr><td rowspan=1 colspan=1>WResNet-50-i (Ours)</td><td rowspan=1 colspan=1>2-2-2 to8-8-8</td><td rowspan=1 colspan=1>5.95%</td><td rowspan=1 colspan=1>101m</td><td rowspan=1 colspan=1>24.92%</td><td rowspan=1 colspan=1>101m</td><td rowspan=1 colspan=1>22.82%</td><td rowspan=1 colspan=1>131m</td></tr><tr><td rowspan=1 colspan=1>WResNet-32WResNet-122</td><td rowspan=1 colspan=1>5-5-520-20-20</td><td rowspan=1 colspan=1>6.29%5.38%</td><td rowspan=1 colspan=1>111m406m</td><td rowspan=1 colspan=1>25.32%23.11%</td><td rowspan=1 colspan=1>111m406m</td><td rowspan=1 colspan=1>23.51%22.00%</td><td rowspan=1 colspan=1>136m516m</td></tr><tr><td rowspan=1 colspan=1>WResNet-122-i (0urs)</td><td rowspan=1 colspan=1>5-5-5 to20-20-20</td><td rowspan=1 colspan=1>5.46%</td><td rowspan=1 colspan=1>239m</td><td rowspan=1 colspan=1>23.04%</td><td rowspan=1 colspan=1>237m</td><td rowspan=1 colspan=1>22.65%</td><td rowspan=1 colspan=1>307m</td></tr></table>
+
+![](images/84090e633397d82376e54f505e9c9115c0cf9847f65a46f9fc120ed5a0d3a177.jpg)  
+Table 4: Main multi-level method results for Wide ResNets (WResNets) with different depths. The model name with i corresponds to the multi-level method. Our multi-level training method achieves superior or on-par accuracy with the last cycle model while saving about $40 \%$ of training time. The unit of training time is a minute.   
+Figure 6: Train and test curves using our multi-level method with ResNet-50-i and WResNet50-i on CIFAR-10/100. The models are interpolated at epoch 60 and 110, dividing the training steps to three cycles. Although both training and test accuracy temporarily drops at the start of each cycle, the performance eventually surpasses the previous cycles.
+
+# REFERENCES
+
+Mart´ın Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Greg S Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, et al. Tensorflow: Large-scale machine learning on heterogeneous distributed systems. arXiv preprint arXiv:1603.04467, 2016.
+
+Bo Chang, Lili Meng, Eldad Haber, Lars Ruthotto, David Begert, and Elliot Holtham. Reversible architectures for arbitrarily deep residual neural networks. arXiv preprint arXiv:1709.03698, 2017.
+
+Kyunghyun Cho, Bart Van Merrienboer, Caglar Gulcehre, Dzmitry Bahdanau, Fethi Bougares, Hol- ¨ ger Schwenk, and Yoshua Bengio. Learning phrase representations using rnn encoder-decoder for statistical machine translation. ACL, 2014.
+
+Adam Coates, Andrew Ng, and Honglak Lee. An analysis of single-layer networks in unsupervised feature learning. In Proceedings of the fourteenth international conference on artificial intelligence and statistics, 2011.
+
+Weinan E. A proposal on machine learning via dynamical systems. Communications in Mathematics and Statistics, 5(1):1–11, 3 2017.
+
+Andre Esteva, Brett Kuprel, Roberto A Novoa, Justin Ko, Susan M Swetter, Helen M Blau, and Sebastian Thrun. Dermatologist-level classification of skin cancer with deep neural networks. Nature, 2017.
+
+Mark Everingham, Luc Van Gool, Christopher KI Williams, John Winn, and Andrew Zisserman. The pascal visual object classes (voc) challenge. IJCV, 2010.
+
+Michael Figurnov, Maxwell D Collins, Yukun Zhu, Li Zhang, Jonathan Huang, Dmitry Vetrov, and Ruslan Salakhutdinov. Spatially adaptive computation time for residual networks. CVPR, 2017.
+
+Aidan N Gomez, Mengye Ren, Raquel Urtasun, and Roger B Grosse. The reversible residual network: Backpropagation without storing activations. NIPS, 2017.
+
+Klaus Greff, Rupesh K Srivastava, and Jurgen Schmidhuber. Highway and residual networks learn ¨ unrolled iterative estimation. In ICLR, 2017.
+
+Caglar Gulcehre, Marcin Moczulski, Francesco Visin, and Yoshua Bengio. Mollifying networks. arXiv preprint arXiv:1608.04980, 2016.
+
+Jung-Woo Ha, Hyuna Pyo, and Jeonghee Kim. Large-scale item categorization in e-commerce using multiple recurrent neural networks. In KDD, 2016.
+
+Eldad Haber and Lars Ruthotto. Stable architectures for deep neural networks. arXiv preprint arXiv:1705.03341, 2017.
+
+Eldad Haber, Lars Ruthotto, and Elliot Holtham. Learning across scales-a multiscale method for convolution neural networks. arXiv preprint arXiv:1703.02009, 2017.
+
+Wolfgang Hackbusch. Multi-grid methods and applications, volume 4. Springer Science & Business Media, 2013.
+
+Moritz Hardt and Tengyu Ma. Identity matters in deep learning. ICLR, 2017.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016.
+
+Kaiming He, Georgia Gkioxari, Piotr Dollar, and Ross Girshick. Mask R-CNN. In ´ ICCV, 2017.
+
+Gao Huang, Yu Sun, Zhuang Liu, Daniel Sedra, and Kilian Q Weinberger. Deep networks with stochastic depth. In ECCV, 2016.
+
+Gao Huang, Danlu Chen, Tianhong Li, Felix Wu, Laurens van der Maaten, and Kilian Q Weinberger. Multi-scale dense convolutional networks for efficient prediction. arXiv preprint arXiv:1703.09844, 2017a.
+
+Gao Huang, Zhuang Liu, Kilian Q Weinberger, and Laurens van der Maaten. Densely connected convolutional networks. CVPR, 2017b.
+
+Stanisław Jastrzebski, Devansh Arpit, Nicolas Ballas, Vikas Verma, Tong Che, and Yoshua Bengio. Residual connections encourage iterative inference. arXiv preprint arXiv:1710.04773, 2017.
+
+Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009.
+
+Sihan Li, Jiantao Jiao, Yanjun Han, and Tsachy Weissman. Demystifying resnet. arXiv preprint arXiv:1611.01186, 2016.
+
+Yuanzhi Li and Yang Yuan. Convergence analysis of two-layer neural networks with relu activation. NIPS, 2017.
+
+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 ´ ECCV, 2014.
+
+Ilya Loshchilov and Frank Hutter. SGDR: Stochastic gradient descent with warm restarts. ICLR, 2017.
+
+Aaron van den Oord, Sander Dieleman, Heiga Zen, Karen Simonyan, Oriol Vinyals, Alex Graves, Nal Kalchbrenner, Andrew Senior, and Koray Kavukcuoglu. Wavenet: A generative model for raw audio. arXiv preprint arXiv:1609.03499, 2016.
+
+Tobias Pohlen, Alexander Hermans, Markus Mathias, and Bastian Leibe. Full resolution image compression with recurrent neural networks. CVPR, 2017.
+
+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. IJCV, 2015.
+
+Sasha Targ, Diogo Almeida, and Kevin Lyman. Resnet in resnet: generalizing residual architectures. ICLR Workshop, 2016.
+
+Andreas Veit, Michael J Wilber, and Serge Belongie. Residual networks behave like ensembles of relatively shallow networks. In NIPS, 2016.
+
+Yonghui Wu, Mike Schuster, Zhifeng Chen, Quoc V Le, Mohammad Norouzi, Wolfgang Macherey, Maxim Krikun, Yuan Cao, Qin Gao, Klaus Macherey, et al. Google’s neural machine translation system: Bridging the gap between human and machine translation. arXiv preprint arXiv:1609.08144, 2016.
+
+Saining Xie, Ross Girshick, Piotr Dollar, Zhuowen Tu, and Kaiming He. Aggregated residual trans- ´ formations for deep neural networks. CVPR, 2017.
+
+Wayne Xiong, Jasha Droppo, Xuedong Huang, Frank Seide, Mike Seltzer, Andreas Stolcke, Dong Yu, and Geoffrey Zweig. The microsoft 2016 conversational speech recognition system. In ICASSP, 2017.
+
+Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. BMVC, 2016.
+
+Ligeng Zhu, Ruizhi Deng, Zhiwei Deng, Greg Mori, and Ping Tan. Sparsely connected convolutional networks. arXiv preprint arXiv:1801.05895, 2018.
+
+# A DATASETS AND MODEL DETAILS
+
+CIFAR-10 and CIFAR-100 The CIFAR-10 dataset (Krizhevsky & Hinton, 2009) consists of 50,000 training images and 10,000 testing images in 10 classes with $3 2 \times 3 2$ image resolution. The CIFAR100 dataset has the same number of training and testing images as CIFAR-10, but has 100 classes. We use the common data augmentation techniques including padding four zeros around the image, random cropping, random horizontal flipping and image standardization (Huang et al., 2016).
+
+STL-10 The STL-10 dataset (Coates et al., 2011) is an image classification dataset with 10 classes with image resolutions of $9 6 \times 9 6$ . It contains 5,000 training images and 8,000 testing images. Compared with CIFAR-10/100, each class has fewer training samples but higher image resolution. We use the same data augmentation as the CIFAR-10/100 except for padding 12 zeros around the images.
+
+Number of parameters We list the number of parameters for each model in Table 5.
+
+Table 5: The number of parameters for each network model.   
+
+<table><tr><td rowspan=1 colspan=1>Model</td><td rowspan=1 colspan=1># Blocks</td><td rowspan=1 colspan=1>CIFAR-10</td><td rowspan=1 colspan=1>CIFAR-100</td><td rowspan=1 colspan=1>STL-10</td></tr><tr><td rowspan=1 colspan=1>ResNet-14</td><td rowspan=1 colspan=1>2-2-2</td><td rowspan=1 colspan=1>172,506</td><td rowspan=1 colspan=1>178,356</td><td rowspan=1 colspan=1>172,506</td></tr><tr><td rowspan=1 colspan=1>ResNet-50</td><td rowspan=1 colspan=1>8-8-8</td><td rowspan=1 colspan=1>755,802</td><td rowspan=1 colspan=1>761,652</td><td rowspan=1 colspan=1>755,802</td></tr><tr><td rowspan=1 colspan=1>ResNet-32</td><td rowspan=1 colspan=1>5-5-5</td><td rowspan=1 colspan=1>464,154</td><td rowspan=1 colspan=1>470,004</td><td rowspan=1 colspan=1>464,154</td></tr><tr><td rowspan=1 colspan=1>ResNet-122</td><td rowspan=1 colspan=1>20-20-20</td><td rowspan=1 colspan=1>19,22,394</td><td rowspan=1 colspan=1>1,928,244</td><td rowspan=1 colspan=1>19,22,394</td></tr><tr><td rowspan=1 colspan=1>WResNet-14</td><td rowspan=1 colspan=1>2-2-2</td><td rowspan=1 colspan=1>685,994</td><td rowspan=1 colspan=1>697,604</td><td rowspan=1 colspan=1>685,994</td></tr><tr><td rowspan=1 colspan=1>WResNet-50</td><td rowspan=1 colspan=1>8-8-8</td><td rowspan=1 colspan=1>3,013,802</td><td rowspan=1 colspan=1>3,025,412</td><td rowspan=1 colspan=1>3,013,802</td></tr><tr><td rowspan=1 colspan=1>WResNet-32</td><td rowspan=1 colspan=1>5-5-5</td><td rowspan=1 colspan=1>1,849,898</td><td rowspan=1 colspan=1>1,861,508</td><td rowspan=1 colspan=1>1,849,898</td></tr><tr><td rowspan=1 colspan=1>ResNet-122</td><td rowspan=1 colspan=1>20-20-20</td><td rowspan=1 colspan=1>7,669,418</td><td rowspan=1 colspan=1>7,681,028</td><td rowspan=1 colspan=1>7,669,418</td></tr></table>
+
+# B IMPLEMENTATION DETAILS
+
+Interpolation Figure 5 gives a conceptual illustration of the interpolation operation. When implementing this operation, the first block in each stage requires special treatment. The first block changes the size of the feature map and the number of channels, thus the shapes of convolution and batch normalization parameters are different from those in subsequent blocks. As a result, we cannot simply copy the parameters from block $_ { 1 } \cdot$ to block $_ { 2 } \cdot$ . Instead, the parameters of block $_ { 2 } \cdot$ are copied from block $_ { 3 } ,$ .
+
+# C FURTHER ANALYSIS OF TIME STEP SIZE
+
+Instead of using $h$ as an implicit step size in Sec. 3.2, we can also explicitly express it in the model. That is, a residual block represents the function $F$ instead of $G$ , and $h$ becomes a hyperparameter of the model. In other words, in each residual block, the output of the residual module is multiplied by $h$ before being added to the identity mapping. Now $h$ is the explicit step size that we can control. This enables us to verify the claim that the depth of the network does not affect the underlying differential equation.
+
+Empirical analysis We run the following experiments on CIFAR-10 and CIFAR-100:
+
+• ResNet-32: 15 blocks with $h = 1$ ;   
+• ResNet-62: 30 blocks with $h = 0 . 5$ ;   
+• ResNet-122: 60 blocks with $h = 0 . 2 5$ ;
+
+According to our theory, those three models are different discretizations of the same differential equation in Eq. (2). As a result, the function values $F ( t )$ should be roughly the same across the time interval $[ 0 , T ]$ , which is discretized to 15, 30 and 60 time steps respectively. In Figure 7, we plot the $L ^ { 2 }$ -norm of the residual blocks $F ( \mathbf { Y } _ { j } )$ and scale the block number to the corresponding conceptual time points. It can be seen from the figure that the three curves follow the same trend, which represents the underlying function $F ( t )$ .
+
+![](images/5a47f0c9a837c238beea7a6c4678d97077445b82c4c89ef1af7d0e5d8686e4db.jpg)  
+Figure 7: Comparison of $\| F ( \mathbf { Y } _ { j } ) \|$ among three models: (1) ResNet-32 with $h = 1$ , (2) ResNet-62 with $h = 0 . 5$ , (3) ResNet-122 with $h = 0 . 2 5$ . If the dynamical systems view is correct, the three curves should approximately follow the same trend.
+
+# D MORE EXPERIMENTAL RESULTS
+
+Train and test curves on STL-10 We show the train and test curves using our multi-level training method on ResNet-50-i and Wide ResNet-50-i on STL10 in Fig. 8.
+
+Effect of learning rate To study the effect of $\eta _ { \mathrm { m a x } }$ and $\eta _ { \mathrm { m i n } }$ on the cyclic learning rate in Eq. (9), we plot their effect on test accuracy in Fig. 9. We empirically find that $\eta _ { \mathrm { m a x } } = 0 . 5$ and $\eta _ { \mathrm { m i n } } = 0 . 0 0 1$ achieve the best accuracy. With the increase of maximum learning rate $\eta _ { \mathrm { m a x } }$ , the test accuracy increases first and then decreases. A potential explanation is that with a small learning rate, the system learns slowly, while with a high learning rate, the system contains too much kinetic energy and is unable to reach the deeper and narrower parts of the loss function.
+
+![](images/3691ee2efd14a8807cdc55f077d0959760a55c84b0202b62aea26ec2c280a404.jpg)  
+Figure 8: Train and test curves using our multi-level method with ResNet-50-i and WResNet50-i on STL10. Although both training and testing accuracy temporarily drops at the start of each cycle, the performance eventually surpasses the previous cycles.
+
+![](images/5c8f85e0f20e1faa04236d45541d53cd3f199b49ca630818aad576588fddf629.jpg)  
+Figure 9: Effect of $\eta _ { \mathrm { m a x } }$ and $\eta _ { \mathrm { m i n } }$ in cyclic learning rate. In most cases, as $\eta _ { \mathrm { m a x } }$ increases, the testing accuracy increases first and then decreases.
+
+Effect of resetting the learning rate To study the effect of resetting the learning rate at the beginning of each cycle, we also run the multi-level training method without resetting the learning rate, that is to use Eq. 9 throughout all cycles. The experiment setting is the same as described in Section 5.2. We train Resnet-50-i on CIFAR-10, CIFAR-100 and STL-10. Each setting is repeated 10 times to obtain the confidence intervals. Fig. 10 shows the results: resetting the learning rate at the beginning of each cycle gives better validation accuracy.
+
+![](images/b7eeaef4bf13a0f9912c14647f619a7ca8e3b6b866ba3f64ea3725b7a0c4a114.jpg)  
+Figure 10: Effect of resetting the learning rate. Resetting the learning rate at the beginning of each cycle gives better validation accuracy.
+
+Comparison with shallow and deep ResNets Fig. 11 shows that training accuracy curves for a shallow ResNet (same depth as the starting model) and a deep ResNet (same depth as the final model).
+
+![](images/76a0dd8e2c3626eeeb3a9ab4d0a4b4d3d2b7fd0d6237d33d548499a2dc31b284.jpg)  
+Figure 11: Shallow and deep ResNets. Training accuracy curves for a shallow ResNet (same depth as the starting model) and a deep ResNet (same depth as the final model).

parse/train/SyJS-OgR-/SyJS-OgR-_content_list.json

@@ -0,0 +1,1826 @@
+[
+    {
+        "type": "text",
+        "text": "MULTI-LEVEL RESIDUAL NETWORKS FROM DYNAMICAL SYSTEMS VIEW ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            820,
+            145
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Bo Chang∗, Lili Meng∗ & Eldad Haber   \nUniversity of British Columbia & Xtract Technologies Inc.   \nVancouver, Canada   \n{bchang@stat, menglili@cs, haber@math}.ubc.ca ",
+        "bbox": [
+            184,
+            169,
+            622,
+            226
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Frederick Tung Simon Fraser University Burnaby, Canada ftung@sfu.ca ",
+        "bbox": [
+            184,
+            247,
+            344,
+            303
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "David Begert Xtract Technologies Inc. Vancouver, Canada david@xtract.ai ",
+        "bbox": [
+            506,
+            247,
+            668,
+            303
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            339,
+            544,
+            354
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep residual networks (ResNets) and their variants are widely used in many computer vision applications and natural language processing tasks. However, the theoretical principles for designing and training ResNets are still not fully understood. Recently, several points of view have emerged to try to interpret ResNet theoretically, such as unraveled view, unrolled iterative estimation and dynamical systems view. In this paper, we adopt the dynamical systems point of view, and analyze the lesioning properties of ResNet both theoretically and experimentally. Based on these analyses, we additionally propose a novel method for accelerating ResNet training. We apply the proposed method to train ResNets and Wide ResNets for three image classification benchmarks, reducing training time by more than $40 \\%$ with superior or on-par accuracy. ",
+        "bbox": [
+            233,
+            371,
+            764,
+            523
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            549,
+            336,
+            565
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep neural networks have powered many research areas from computer vision (He et al., 2016; Huang et al., 2017b), natural language processing (Cho et al., 2014) to biology (Esteva et al., 2017) and e-commerce (Ha et al., 2016). Deep Residual Networks (ResNets) (He et al., 2016), and their variants such as Wide ResNets (Zagoruyko & Komodakis, 2016) and DenseNets (Huang et al., 2017b), are among the most successful architectures. In ResNets, the authors employ identity skipconnections that bypass residual layers, allowing data to flow from previous layers directly to any subsequent layers. ",
+        "bbox": [
+            174,
+            582,
+            825,
+            679
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "With the success of ResNet and its variants on various applications (He et al., 2016; 2017; Pohlen et al., 2017; Xiong et al., 2017; Oord et al., 2016; Wu et al., 2016), several views such as unraveled view (Veit et al., 2016), unrolled iterative estimation view (Greff et al., 2017) and dynamical systems view (Haber et al., 2017; E, 2017; Chang et al., 2017) have emerged to try to interpret ResNets through theoretical analysis and empirical results. These views provide preliminary interpretations, however, deep understanding of ResNets is still an active on-going research topic (Jastrzebski et al., 2017; Li et al., 2016; Hardt & Ma, 2017; Li & Yuan, 2017). ",
+        "bbox": [
+            174,
+            685,
+            825,
+            784
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The dynamical systems view interprets ResNets as ordinary differential equations (ODEs), a special kind of dynamical systems (Haber et al., 2017; E, 2017), opening up possibilities of exploiting the computational and theoretical success from dynamical systems to ResNets. From this point of view, stable and reversible architectures (Haber & Ruthotto, 2017; Chang et al., 2017) are developed. However, few empirical analysis of this view has been done and many phenomena such as the removing of layers not leading to performance drop are not explained by the dynamical systems view. In this work, we take steps forward to complement this dynamical systems view with empirical analysis of its properties and the lesion studies. ",
+        "bbox": [
+            174,
+            790,
+            825,
+            901
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/d377ec59a5d2474336cd6064a296406b03a17fe1677a616c1e25b6ffb7c3dedf.jpg",
+        "image_caption": [
+            "Figure 1: Dynamical systems view of ResNets. ResNets equally discretize the time interval $[ 0 , T ]$ using time points $T _ { 0 } , T _ { 1 } , \\ldots , T _ { d }$ , where $T _ { 0 } = 0$ , $T _ { d } = T$ and $d$ is the total number of blocks. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            99,
+            820,
+            207
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "One challenge of deep ResNets is the long training time. It is extremely time-consuming to train on large datasets such as ImageNet or with very deep ResNets such as 1000-layer networks, which may Yjtake several days or even weeks on high-performance hardware with GPU acceleration. Recently Identitythe reversible residual networks (Gomez et al., 2017; Chang et al., 2017) consumes $50 \\%$ more comG(Yj ) Yjputational time for reducing memory usage by reconstructing the activations, which exposes training time to be a more severe problem. Inspired by the dynamical systems interpretation, we additionally G(Y )+Ypropose a simple yet effective multi-level method for accelerating ResNets training. ",
+        "bbox": [
+            173,
+            277,
+            825,
+            376
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In summary, the main contributions of this work are: ",
+        "bbox": [
+            174,
+            382,
+            517,
+            397
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We study the dynamical systems view and explain the lesion studies from this view through empirical analysis.   \n• We propose a simple yet efficient multi-level training method for ResNets based on dynamical systems view.   \n• We demonstrate the proposed multi-level training method on ResNets (He et al., 2016)  Stage 3 and Wide ResNets (Zagoruyko & Komodakis, 2016) across three widely used datasets, achieving more than $40 \\%$ training time reduction with superior or on-par accuracy. ",
+        "bbox": [
+            215,
+            411,
+            825,
+            530
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORKblock 1 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            563,
+            341,
+            579
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 RESNETS AND VARIANTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            597,
+            392,
+            611
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "ResNets (He et al., 2016) are deep neural networks of stacking simple residual blocks, which contain identity skip-connections that bypass the residual layers. A residual block, as shown in Fig. 2, can be written as ",
+        "bbox": [
+            173,
+            625,
+            612,
+            681
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7271103e086b9fac725d0727cf98b1564228b1454f2f122653186ff08b12b78b.jpg",
+        "text": "$$\n\\mathbf { Y } _ { j + 1 } = \\mathbf { Y } _ { j } + G ( \\mathbf { Y } _ { j } , \\theta _ { j } ) \\quad \\mathrm { f o r } \\quad j = 0 , . . . , N - 1 ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            236,
+            693,
+            547,
+            712
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { Y } _ { j }$ is the feature map at the $j$ th layer, $\\theta _ { j }$ represents the jth layer’s network parameters. $G$ is referred to as a residual module, consisting of two convolutional layers. As shown in Fig. 1, the network is divided into several stages; each consists of a number of residual blocks. In the first block of each stage, the feature map size is halved, and the number of filters is doubled. The feature map remains the same dimensionality for subsequent blocks in a stage. ",
+        "bbox": [
+            174,
+            722,
+            614,
+            820
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/1c1898bacb1675fcece0856e7935f6b61d37049480a1ec1e5cd0e5a91cd0ca65.jpg",
+        "image_caption": [
+            "Figure 2: A residual block. Each residual block has two components: the residual module $G$ and the identity skip-connection, which add up to the output of a block. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            632,
+            622,
+            820,
+            720
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "After the success of ResNets in popular competitions such as ImageNet (Russakovsky et al., 2015), Pascal VOC (Everingham et al., ",
+        "bbox": [
+            173,
+            827,
+            612,
+            854
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2010) and Microsoft COCO (Lin et al., 2014), there emerged many successors (Huang et al., 2016; 2017b; Chang et al., 2017; Gomez et al., 2017; Targ et al., 2016; Hardt & Ma, 2017; Zagoruyko & Komodakis, 2016). For instance, DenseNet (Huang et al., 2017b) connects between any two layers with the same feature-map size. ResNxt (Xie et al., 2017) introduces a homogeneous, multi-branch architecture to increase the accuracy. ",
+        "bbox": [
+            174,
+            856,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 INTERPRETATIONS OF RESNETS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            436,
+            117
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Unraveled view In Veit et al. (2016), ResNets are interpreted from an unraveled view in which ResNets are viewed as a collection of many paths which data flow along from input to output. Each residual block consists of a residual module and an identity skip-connection; a path is defined as a configuration of which residual module to enter and which to skip. For a ResNet with $n$ residual blocks, there are $2 ^ { n }$ unique paths. Through lesion studies, Veit et al. (2016) further demonstrate that paths in ResNets do not strongly depend on each other and behave like an ensemble. When a residual block is removed, the number of paths is reduced from $2 ^ { n }$ to $2 ^ { n - 1 }$ , leaving half of the paths still valid, which explains why ResNets are resilient to dropping blocks. Besides the explicit ensemble view, training ResNets with stochastic depth (Huang et al., 2016) can be viewed as an ensemble of networks with varying depths implicitly. ",
+        "bbox": [
+            174,
+            130,
+            825,
+            268
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Unrolled iterative estimation view ResNets are interpreted as unrolled iterative estimation in Greff et al. (2017). From this view, the level of representation stays the same within each stage. The residual blocks in a stage work together to estimate and iteratively refine a single level of representation: the first layer in a stage provides a rough estimate for the representation, and subsequent layers refine that estimate. An implication of this view is that processing in each block is incremental and removing blocks only has a mild effect on the final results. Based on this view, Jastrzebski et al. (2017) provide more analytical and empirical results. ",
+        "bbox": [
+            173,
+            275,
+            825,
+            373
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Dynamical systems view ResNets can be interpreted as a discretization of dynamical systems (Haber et al., 2017; E, 2017). The basic dynamics at each step is a linear transformation followed by component-wise nonlinear activation function. The behavior of large dynamical systems is often a notoriously difficult problem in mathematics, particularly for discrete dynamical systems. This is similar to the gradient exploding/vanishing problem for deep neural networks or recurrent neural networks. Imposing structural constraints on dynamical systems such as Hamiltonian systems to conserve the energy is explored in Haber & Ruthotto (2017); Chang et al. (2017). However, no interpretation on the phenomenon of deleting layers is studied from this point of view. ",
+        "bbox": [
+            174,
+            380,
+            825,
+            491
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.3 RESNETS EFFICIENT TRAINING METHODS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            508,
+            501,
+            522
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "One major challenge of deep ResNets is their long training time. To alleviate this issue, several attempts have been made. Stochastic depth (Huang et al., 2016) randomly drops entire residual blocks during training and bypassing their transformations through identity skip-connections; during testing, all the blocks are in use. When a block is bypassed for a specific iteration, there is no need to perform forward-backward computation. With stochastic depth, approximately $2 5 \\%$ of training time could be saved. Figurnov et al. (2017) reduce the inference time of residual networks by learning to predict early halting scores based on the image content. Huang et al. (2017a) investigate image classification with computational resource limits at test time. SparseNets (Zhu et al., 2018) is a simple feature aggregation structure with shortcut paths bypassing exponentially growing number of layers. Mollifying networks (Gulcehre et al., 2016) start the optimization with an easier (possibly convex) objective function and let it evolve during the training, until it eventually goes back to being the original, difficult to optimize, objective function. It can also be interpreted as a form adaptive noise injection that only depends on a single hyperparameter. ",
+        "bbox": [
+            173,
+            535,
+            825,
+            715
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 RESNETS FROM DYNAMICAL SYSTEMS VIEW ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            737,
+            576,
+            752
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we first provide a brief introduction to the dynamical systems view in which ResNets are considered as ODEs. Based on this view, we provide empirical analysis to explain some intriguing properties and phenomena of ResNets. ",
+        "bbox": [
+            176,
+            767,
+            823,
+            809
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 DYNAMICAL SYSTEMS VIEW ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            827,
+            411,
+            842
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For the pre-activation ResNets $\\mathbf { Y } _ { j + 1 } = \\mathbf { Y } _ { j } + G ( \\mathbf { Y } _ { j } , \\pmb { \\theta } _ { j } )$ , the residual module $G$ consists of two sets of batch normalization, ReLU and convolutional layers. Without loss of generality, we can conceptually add a parameter $h$ and rewrite the residual module as $G = h F$ . The residual block becomes ",
+        "bbox": [
+            173,
+            853,
+            825,
+            895
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/41a9a1fbd58e017fbd3e2d3592a4e8a430068e3e09cbf5aa5f0fb876a24ece3f.jpg",
+        "text": "$$\n{ \\displaystyle { \\bf Y } _ { j + 1 } = { \\bf Y } _ { j } + h F ( { \\bf Y } _ { j } , { \\boldsymbol { \\theta } } _ { j } ) } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            413,
+            907,
+            583,
+            926
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/b76403ac46f23ec11d3699307bf14560f45112056f406b3dd7fc089c6c3887dc.jpg",
+        "image_caption": [
+            "Figure 3: The average $L ^ { 2 }$ -norm of the residual modules γ vs the number of residual blocks $d$ . The curve resembles a reciprocal function, which is consistent with Eq. (5) and the dynamical systems view. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            264,
+            108,
+            717,
+            291
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "which can be further rewritten as ",
+        "bbox": [
+            174,
+            380,
+            392,
+            393
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/dd1d8361ac014662436dca3d9e4cf475014afb8db8306c6f0a8b4e4b0be0fd16.jpg",
+        "text": "$$\n\\frac { { \\bf Y } _ { j + 1 } - { \\bf Y } _ { j } } { h } = F ( { \\bf Y } _ { j } , \\theta _ { j } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            415,
+            400,
+            581,
+            433
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For a sufficiently small $h$ , Eq. (3) can be regarded as a forward Euler discretization of the initial value ODE ",
+        "bbox": [
+            173,
+            439,
+            823,
+            468
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2186f06d9600f4b136fd6bf324da1e90a1b30abf93bd8ac69df2a5f87a80c378.jpg",
+        "text": "$$\n\\dot { \\mathbf { Y } } ( t ) = F ( \\mathbf { Y } ( t ) , \\theta ( t ) ) , \\mathbf { Y } ( 0 ) = \\mathbf { Y } _ { 0 } , \\mathrm { f o r } 0 \\leq t \\leq T ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            336,
+            469,
+            661,
+            488
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where time $t$ corresponds to the direction from input to output, $\\mathbf { Y } ( 0 )$ is the input feature map after the initial convolution, and $\\mathbf { Y } ( T )$ is the output feature map before the softmax classifier. Thus, the problem of learning the network parameters, $\\theta$ , is equivalent to solving a parameter estimation problem or optimal control problem involving the ODE in Eq. (4). ",
+        "bbox": [
+            173,
+            493,
+            825,
+            551
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 TIME STEP SIZE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            570,
+            325,
+            584
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The new parameter $h$ is called the step size of discretization. In the original formulation of ResNets in Eq. (1), $h$ does not exist, and is implicitly absorbed by the residual module $G$ . We call it the implicit step size. The step size $h$ can also be explicitly expressed in the model: the output of the residual module is multiplied by $h$ before being added to the identity mapping. In this case, $h$ is a hyper-parameter and we name it the explicit step size. In this section, we only consider implicit step size. ",
+        "bbox": [
+            173,
+            597,
+            825,
+            681
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We assume that $\\mathbf { Y } ( 0 )$ and $\\mathbf { Y } ( T )$ correspond to the input and output feature maps of the network respectively, where the time length $T$ is fixed. As illustrated in Fig. 1, ResNets equally discretize $[ 0 , { \\bar { T } } ]$ using time points $T _ { 0 } , T _ { 1 } , \\dots , T _ { j } , \\dots , T _ { d }$ , where $T _ { 0 } = 0$ , $T _ { d } = T$ and $d$ is the number of blocks. Thus each time step is $h = T _ { j + 1 } - T _ { j } = T / d$ . ",
+        "bbox": [
+            174,
+            686,
+            825,
+            746
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Thus, we can obtain ",
+        "bbox": [
+            176,
+            751,
+            308,
+            765
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3e41a5aba85b1f3487518a382315d84d8d1e19fdfd62b9cb46c976c1bca3b827.jpg",
+        "text": "$$\n\\| G ( \\mathbf { Y } _ { j } ) \\| = \\| h F ( \\mathbf { Y } _ { j } ) \\| = { \\frac { T } { d } } \\| F ( \\mathbf { Y } _ { j } ) \\| ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            375,
+            766,
+            620,
+            796
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $F$ in the underlying ODE in Eq. (4) does not depend on $d$ . In other words, $d$ is inversely proportional to the norm of the residual modules $G ( Y _ { j } )$ . ",
+        "bbox": [
+            169,
+            801,
+            823,
+            832
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Empirical analysis To verify the above statement, we run experiments on ResNets with varying depths. If our theory is correct, the norm of the residual module $\\| G ( \\mathbf { Y } _ { j } ) \\|$ should be inversely proportional to the number of residual blocks. Take ResNet-32 with 15 residual blocks in total as an example. We calculate the average $L ^ { 2 }$ -norm of the residual modules $\\begin{array} { r } { \\gamma = \\frac { 1 } { 1 5 } \\sum _ { j = 1 } ^ { 1 5 } \\| G ( \\mathbf { Y } _ { j } ) \\| } \\end{array}$ . Figure 3 shows $\\gamma$ for different ResNet models. The curve resembles a reciprocal function, which is consistent with Eq. (5) and the dynamical system point of view. ",
+        "bbox": [
+            173,
+            837,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/9140354a839c0425bc0d3733b46363ba220cecb260153a4ddf7b7cc7ca58f3d9.jpg",
+        "image_caption": [
+            "Figure 4: $L ^ { 2 }$ -norm of the input and output of the residual module $G$ . ResNet-110 models are trained on CIFAR-10 and CIFAR-100. The norms are evaluated at test time. It shows that within a residual block, the identity mapping contributes much more than the residual module. In other words, $G ( \\mathbf { Y } _ { j } )$ is relatively small for most residual blocks. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            106,
+            816,
+            268
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 LESION STUDY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            364,
+            318,
+            380
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Lesion studies for ResNets in Veit et al. (2016) remove single or multiple residual blocks, and shuffle the residual blocks at test time. Surprisingly, only removing downsampling blocks has a modest impact on performance, no other block removal leads to a noticeable effect. ",
+        "bbox": [
+            174,
+            391,
+            823,
+            434
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "According to the dynamical systems view, removing one residual block is equivalent to skipping one time step and squeezing two adjacent steps into one. This operation may change the dynamical system. However, we will show in the following that the effect is negligible when the output of residual module $G ( \\mathbf { Y } _ { j } )$ is small enough. ",
+        "bbox": [
+            173,
+            440,
+            825,
+            498
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Let $t _ { 0 } , t _ { 1 } , t _ { 2 }$ be three consecutive time points such that $t _ { 1 } = t _ { 0 } + h$ and $t _ { 2 } = t _ { 0 } + 2 h$ . Suppose the removed block corresponds to time point $t _ { 1 }$ . Before the removal of the time point, the discretization is ",
+        "bbox": [
+            173,
+            503,
+            825,
+            546
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/eb75f9b73af10f34166e1d758fe54388343a7dee5a29d8c315c74d552f9b3837.jpg",
+        "text": "$$\n\\begin{array} { r l } & { { \\mathbf Y } ( t _ { 1 } ) = { \\mathbf Y } ( t _ { 0 } ) + h F ( { \\mathbf Y } ( t _ { 0 } ) ) , } \\\\ & { { \\mathbf Y } ( t _ { 2 } ) = { \\mathbf Y } ( t _ { 1 } ) + h F ( { \\mathbf Y } ( t _ { 1 } ) ) = { \\mathbf Y } ( t _ { 0 } ) + h F ( { \\mathbf Y } ( t _ { 0 } ) ) + h F ( { \\mathbf Y } ( t _ { 1 } ) ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            292,
+            553,
+            702,
+            590
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "After $t _ { 1 }$ is removed, the time interval $[ t _ { 0 } , t _ { 2 } ]$ is squeezed to $[ t _ { 0 } , t _ { 2 } ^ { \\prime } ]$ , where $t _ { 2 } ^ { \\prime } = t _ { 0 } + h$ is the new time point after $t _ { 0 }$ . The new discretization is ",
+        "bbox": [
+            173,
+            595,
+            825,
+            625
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9a631eb30f2fda96b5eb7cbe43be4d7c45cc4e55ec7369c1a1686e80e805bdff.jpg",
+        "text": "$$\n\\mathbf { Y } ( t _ { 2 } ^ { \\prime } ) = \\mathbf { Y } ( t _ { 0 } ) + h F ( \\mathbf { Y } ( t _ { 0 } ) ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            405,
+            632,
+            591,
+            650
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The difference of the feature before and after the removal operation is ",
+        "bbox": [
+            174,
+            657,
+            632,
+            672
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f64d76a6138293d6aade9f65ce5059ce4b887f760d3e364d10446efa94847cad.jpg",
+        "text": "$$\n\\mathbf { Y } ( t _ { 2 } ^ { \\prime } ) - \\mathbf { Y } ( t _ { 2 } ) = h F ( \\mathbf { Y } ( t _ { 1 } ) ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            405,
+            679,
+            589,
+            698
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "which is the output of the residual module $G ( \\mathbf { Y } ( t _ { 1 } ) )$ . Therefore, the effect of removing the block is negligible when $\\dot { G } ( \\mathbf { Y } ( t _ { 1 } ) )$ is small. ",
+        "bbox": [
+            173,
+            704,
+            825,
+            734
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Empirical analysis To empirically verify that $G ( \\mathbf { Y } ( t ) )$ are small, we train a ResNet-110 model (3 stages with 18 residual blocks per stage) on CIFAR-10/100, and plot the $L ^ { 2 }$ -norm of input $\\mathbf { Y } _ { j }$ and output $G ( \\mathbf { Y } _ { j } )$ of each residual module at test time. As shown in Figure 4, except for the first block at each stage, later blocks have tiny residual module outputs $G ( \\mathbf { Y } _ { j } )$ compared with the inputs $\\mathbf { Y } _ { j }$ . This provides an explanation why removing one block does not notably impact the performance. ",
+        "bbox": [
+            174,
+            739,
+            825,
+            813
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The effect of shuffling residual blocks can be analyzed in a similar way. When the outputs of the residual modules are small, each block only slightly modifies the feature map. Therefore, we can expect the effect of shuffling to be moderate, especially in later stages. ",
+        "bbox": [
+            174,
+            818,
+            825,
+            861
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "When the network is deep, the outputs of the residual modules are close to zero. Each residual module can be regarded as feature refinement. The magnitude of change is large only in the first block; the subsequent blocks only slightly refine the features, which is consistent with the unrolled iterative estimation view. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/d53f066a25d3ad1a051641e98389f917831fec011850ffd199bf5c8417a39b31.jpg",
+        "image_caption": [
+            "Figure 5: An illustration of the interpolation operation for one stage. We insert one residual block right after each existing block in the stage. The model parameters, including convolutional weights and batch normalization parameters, are copied from the adjacent old block to interpolated blocks. After that, the explicit step size $h$ is halved. For example, before interpolation, this stage has three residual blocks, numbered 1 to 3. After interpolation, block 1, 2 and 3 become block 1’, $_ { 3 } ,$ and $_ 5 '$ respectively. Three new blocks are inserted: block $2 ^ { \\bullet }$ , $_ 4 \\cdot$ and $\\mathbf { \\omega } _ { 6 } { \\mathrm { : } }$ , whose parameters are copied from its previous block respectively. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            103,
+            825,
+            252
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/92515b0a13a4be0d9e7ab11d79a9ba25ae20cb510cad52bb0079e38aecebf6bc.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>#Residual Blocks</td><td>Explicit Step Size h# Training Steps</td><td></td></tr><tr><td>Cycle 1</td><td>2-2-2</td><td>1</td><td>N1</td></tr><tr><td>Cycle 2</td><td>4-4-4</td><td>0.5</td><td>N2</td></tr><tr><td>Cycle 3</td><td>8-8-8</td><td>0.25</td><td>N3</td></tr></table>",
+        "bbox": [
+            246,
+            386,
+            751,
+            446
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 1: An illustration of the multi-level method with 3 cycles. The ResNet model has 3 stages; # Residual Blocks column represents the number of blocks in each stage. In cycle 1, the training starts with a 2-2-2 model using $h = 1$ . After $N _ { 1 }$ training steps, the first interpolation happens: the model becomes 4-4-4, and the step size is halved to 0.5. Similarly, $N _ { 2 }$ training steps later, the second interpolation doubles the number of blocks to 8-8-8 and halves $h$ to 0.25. Cycle 3 lasts for $N _ { 3 }$ training steps. ",
+        "bbox": [
+            173,
+            457,
+            825,
+            541
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 EFFICIENT TRAINING WITH MULTI-LEVEL METHOD ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            568,
+            627,
+            583
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Given the connection between ResNets and ODEs, existing theories and numerical techniques for ODEs can be applied to ResNets. In numerical analysis, multi-grid methods (Hackbusch, 2013) are algorithms for solving differential equations using a hierarchy of discretizations with varying step sizes. Inspired by multi-grid methods, we propose the multi-level training method. ",
+        "bbox": [
+            174,
+            599,
+            825,
+            656
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 MULTI-LEVEL TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            674,
+            387,
+            688
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The idea of the multi-level method is, during training, we start with a shallow network using a large explicit step size $h$ . After a few training steps, we switch to a deeper network, by doubling the number of residual blocks and halving the step size to $h / 2$ . This operation is called interpolation, which applies to all the stages at the same time. Fig. 5 illustrates the interpolation operation for one stage. The interpolation operation inserts a new residual block right after every existing block, and copies the convolutional weights and batch normalization parameters from the adjacent old block to the new block. ",
+        "bbox": [
+            173,
+            700,
+            825,
+            797
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In the multi-level training process, interpolations happen several times, thus dividing the training steps into cycles. Table 1 gives an example to illustrate this process. According to our dynamical systems view, by interpolating the residual blocks and halving the step size, we solve exactly the same differential equation. Therefore, the interpolation operation at the beginning of a cycle gives a good initialization of the parameters. ",
+        "bbox": [
+            174,
+            805,
+            825,
+            875
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Each cycle itself can be regarded as a training process, thus we need to reset the learning rate to a large value at the beginning of each training cycle and anneal the learning rate during that cycle. Here we adopt the cosine annealing learning rate schedule (Loshchilov & Hutter, 2017). Within ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/6e9d273d9f61d03b98a3ad5e76f5f59bad82974f5a2ef1a91d85eeb0d73a1eb9.jpg",
+        "table_caption": [
+            "Table 2: Number of interpolations vs theoretical time saved, relative to the full model. Theoretically, time saved is monotonically increasing as the number of interpolation increases, but the marginal benefit is diminishing. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td># Interpolations</td><td>0</td><td>1</td><td>2</td><td>3</td><td>4</td><td>5</td><td></td></tr><tr><td>Theoretical TimeSaved</td><td>0%</td><td>25%</td><td>42%</td><td>53%</td><td>61%</td><td>67%</td><td>：</td></tr></table>",
+        "bbox": [
+            243,
+            101,
+            753,
+            132
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "each cycle, the learning rate is ",
+        "bbox": [
+            173,
+            217,
+            374,
+            232
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/01d63601491faa825ff7fae39350c82b21d8a520534ce931a7f664313fca4b92.jpg",
+        "text": "$$\n\\eta = \\eta _ { \\mathrm { m i n } } + \\frac { 1 } { 2 } ( \\eta _ { \\mathrm { m a x } } - \\eta _ { \\mathrm { m i n } } ) ( 1 + \\cos ( \\frac { T _ { \\mathrm { c u r } } } { T } \\pi ) ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            348,
+            243,
+            648,
+            273
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where $\\eta _ { \\mathrm { m i n } }$ and $\\eta _ { \\mathrm { m a x } }$ represent the minimum and maximum learning rate respectively, $T _ { \\mathrm { c u r } }$ accounts for how many training steps have been performed in the current cycle, and $T$ denotes the total number of training steps in this cycle. The learning rate starts from $\\eta _ { \\mathrm { m a x } }$ at the beginning of each cycle and decreases to $\\eta _ { \\mathrm { m i n } }$ at the end of the cycle. ",
+        "bbox": [
+            174,
+            285,
+            825,
+            342
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 TRAINING TIME ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            364,
+            326,
+            378
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Since the number of residual blocks in cycle $i$ is half of that in cycle $i + 1$ , theoretically, the running time in cycle $i$ should also be half of that in cycle $i + 1$ . Take a multi-level method with two cycles as an example, it trains a shallow model (2-2-2 blocks) for $N$ steps and switches to a deep model (4-4-4 blocks) for another $N$ steps. Compared with the deep model trained for $2 N$ steps, the multi-level method reduces training time by $1 / 4$ . ",
+        "bbox": [
+            173,
+            392,
+            825,
+            463
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "More generally, if one uses the multi-level method with $k$ interpolations equally dividing the training steps, theoretically it saves $1 - \\frac { 2 ^ { k + 1 } - 1 } { 2 ^ { k } ( k + 1 ) }$ of training time, compared to the full model (model in the last cycle) trained for the same number of total steps. Table 2 shows the theoretical time saved. Time saved is monotonically increasing as the number of interpolation increases, but the marginal time saved is diminishing. Furthermore, when the number of interpolations is large, each cycle might not have enough training steps. Therefore, there is a trade-off between efficiency and accuracy. ",
+        "bbox": [
+            173,
+            468,
+            825,
+            561
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            587,
+            326,
+            603
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The empirical results on the dynamical systems view are presented in Sec. 3.2 and 3.3. In this section, we evaluate the efficacy and efficiency of the proposed multi-level method on two state-ofthe art deep learning architectures for image classification: ResNet and Wide ResNet, across three standard benchmarks. ",
+        "bbox": [
+            174,
+            621,
+            825,
+            678
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/98b5576880973ff8b7199bd782be71d9752d6064cd7a898326cc192219b1b0aa.jpg",
+        "table_caption": [
+            "Table 3: Main multi-level method results for ResNets with different depths. The model name with $i$ corresponds to the multi-level method. Our multi-level training method achieves superior or on-par accuracy with the last cycle model while saving about $40 \\%$ of training time. The unit of training time is a minute. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=2 colspan=1>Model</td><td rowspan=2 colspan=1># Blocks</td><td rowspan=1 colspan=2>CIFAR-10</td><td rowspan=1 colspan=2>CIFAR-100</td><td rowspan=1 colspan=2>STL-10</td></tr><tr><td rowspan=1 colspan=1>Error</td><td rowspan=1 colspan=1>Time</td><td rowspan=1 colspan=1>Error</td><td rowspan=1 colspan=1>Time</td><td rowspan=1 colspan=1>Error</td><td rowspan=1 colspan=1>Time</td></tr><tr><td rowspan=1 colspan=1>ResNet-14ResNet-50</td><td rowspan=1 colspan=1>2-2-28-8-8</td><td rowspan=1 colspan=1>9.75%7.58%</td><td rowspan=1 colspan=1>38m114m</td><td rowspan=1 colspan=1>33.34%28.64%</td><td rowspan=1 colspan=1>38m115m</td><td rowspan=1 colspan=1>27.78%25.95%</td><td rowspan=1 colspan=1>33m114m</td></tr><tr><td rowspan=1 colspan=1>ResNet-50-i (Ours)</td><td rowspan=1 colspan=1>2-2-2 to8-8-8</td><td rowspan=1 colspan=1>7.10%</td><td rowspan=1 colspan=1>67m</td><td rowspan=1 colspan=1>28.71%</td><td rowspan=1 colspan=1>68m</td><td rowspan=1 colspan=1>25.98%</td><td rowspan=1 colspan=1>68m</td></tr><tr><td rowspan=1 colspan=1>ResNet-32ResNet-122</td><td rowspan=1 colspan=1>5-5-520-20-20</td><td rowspan=1 colspan=1>7.74%6.47%</td><td rowspan=1 colspan=1>76m266m</td><td rowspan=1 colspan=1>29.96%26.74%</td><td rowspan=1 colspan=1>74m266m</td><td rowspan=1 colspan=1>26.02%25.16%</td><td rowspan=1 colspan=1>71m266m</td></tr><tr><td rowspan=1 colspan=1>ResNet-122-i (Ours)</td><td rowspan=1 colspan=1>5-5-5 to20-20-20</td><td rowspan=1 colspan=1>6.56%</td><td rowspan=1 colspan=1>154m</td><td rowspan=1 colspan=1>26.81%</td><td rowspan=1 colspan=1>154m</td><td rowspan=1 colspan=1>24.36%</td><td rowspan=1 colspan=1>162m</td></tr></table>",
+        "bbox": [
+            189,
+            704,
+            808,
+            853
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 DATASETS AND NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            403,
+            117
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Datasets Three widely used datasets are used for evaluation: CIFAR-10, CIFAR-100 (Krizhevsky & Hinton, 2009), and STL10 (Coates et al., 2011). Details on these datasets and data augmentation methods can be found in Appendix A. ",
+        "bbox": [
+            174,
+            132,
+            825,
+            174
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Networks We use ResNets (He et al., 2016) and Wide ResNets (Zagoruyko & Komodakis, 2016) for all the datasets. All the networks have three stages, with the number of filters equal to 16-32-64 for ResNets, and 32-64-128 for Wide ResNets. ",
+        "bbox": [
+            176,
+            180,
+            825,
+            223
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.2 EXPERIMENTAL SETTINGS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            246,
+            397,
+            260
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Based on the analysis in Table 2, we use two interpolations, that is three cycles, for the multi-level method in order to optimize the trade-off between efficiency and accuracy. ",
+        "bbox": [
+            176,
+            273,
+            823,
+            301
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For each experiment, we run our multi-level model with three cycles. For comparison, two other models are trained for the same number of steps: a model with the same architecture as the first cycle and a model with the same architecture as the last cycle. ",
+        "bbox": [
+            176,
+            309,
+            825,
+            351
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We call them first cycle model and last cycle model respectively. We also use the cyclic learning rate schedule (Loshchilov & Hutter, 2017) for the first cycle model and last cycle model for fair comparison. ",
+        "bbox": [
+            174,
+            358,
+            825,
+            400
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "All the models are trained for 160 epochs. For our multi-level method, the models are interpolated at the 60th and 110th epochs. For baseline models, the learning rate cycle also restarts at epoch 60 and 110. The maximum and minimum learning rates $\\eta _ { \\mathrm { m i n } }$ and $\\eta _ { \\mathrm { m a x } }$ are set 0.001 and 0.5 respectively. For CIFAR-10 and CIFAR-100 experiments, the mini-batch size is 100. For STL-10 experiments, the mini-batch size is 32. We use a weight decay of $2 \\times 1 0 ^ { - 4 }$ , and momentum of 0.9. All the experiments are evaluated on machines with a single Nvidia GeForce GTX 1080 GPU. The networks are implemented using TensorFlow library (Abadi et al., 2016). ",
+        "bbox": [
+            174,
+            406,
+            825,
+            505
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.3 MAIN RESULTS AND ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            527,
+            428,
+            541
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We present the main results and analysis in this section. More experimental results can be found in Appendix D. The theoretical time saved for two interpolations is $42 \\%$ , which is consistent with the experiment results. ",
+        "bbox": [
+            174,
+            556,
+            825,
+            598
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The main results are shown in Table 3 and 4, for ResNets and Wide ResNets respectively. We report the test error rate and training time. Compared with the first cycle model, our multi-level method achieves much lower test error. Compared with the last cycle model, the test error is competitive or slightly lower, but the training time reduction is over $40 \\%$ . This result applies to both ResNets and WResNets across three datasets. The interpolation of (Wide) ResNet-50-i from 2-2-2 to 8-8-8 and (Wide) ResNet-122-i from 5-5-5 to 20-20-20 show that our multi-level training method is effective for different network depths. ",
+        "bbox": [
+            174,
+            604,
+            825,
+            703
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The train and test curves with both ResNets and Wide ResNets are shown in Fig. 6. Although both training and test accuracy temporarily drops at the start of each cycle, the performance eventually surpasses the previous cycles. ResNets and Wide ResNets have similar train and test curves, indicating that our multi-level training method is effective for different network widths. ",
+        "bbox": [
+            176,
+            709,
+            825,
+            765
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            791,
+            318,
+            808
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this work, we study ResNets from the dynamical systems view and explain the lesion studies from this view through both theoretical and empirical analyses. Based on these analyses, we develop a simple yet effective multi-level method for accelerating the training of ResNets. The proposed multi-level training method is evaluated on two state-of-the-art residual network architectures across three widely used classification benchmarks, reducing training time by more than $40 \\%$ with similar accuracy. For future work, we would like to explore the dynamical systems view on other ResNets variants such as DenseNets. ",
+        "bbox": [
+            174,
+            825,
+            825,
+            922
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/7fe5aab34737d3702a86b3f6dc2cb38c34c794188f00acda859359d585b04cb3.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=2 colspan=1>Model</td><td rowspan=2 colspan=1># Blocks</td><td rowspan=1 colspan=2>CIFAR-10</td><td rowspan=1 colspan=2>CIFAR-100</td><td rowspan=1 colspan=2>STL-10</td></tr><tr><td rowspan=1 colspan=1>Error</td><td rowspan=1 colspan=1>Time</td><td rowspan=1 colspan=1>Error</td><td rowspan=1 colspan=1>Time</td><td rowspan=1 colspan=1>Error</td><td rowspan=1 colspan=1>Time</td></tr><tr><td rowspan=1 colspan=1>WResNet-14WResNet-50</td><td rowspan=1 colspan=1>2-2-28-8-8</td><td rowspan=1 colspan=1>7.38%5.87%</td><td rowspan=1 colspan=1>51m174m</td><td rowspan=1 colspan=1>27.92%24.49%</td><td rowspan=1 colspan=1>51m173m</td><td rowspan=1 colspan=1>24.58%23.82%</td><td rowspan=1 colspan=1>63m222m</td></tr><tr><td rowspan=1 colspan=1>WResNet-50-i (Ours)</td><td rowspan=1 colspan=1>2-2-2 to8-8-8</td><td rowspan=1 colspan=1>5.95%</td><td rowspan=1 colspan=1>101m</td><td rowspan=1 colspan=1>24.92%</td><td rowspan=1 colspan=1>101m</td><td rowspan=1 colspan=1>22.82%</td><td rowspan=1 colspan=1>131m</td></tr><tr><td rowspan=1 colspan=1>WResNet-32WResNet-122</td><td rowspan=1 colspan=1>5-5-520-20-20</td><td rowspan=1 colspan=1>6.29%5.38%</td><td rowspan=1 colspan=1>111m406m</td><td rowspan=1 colspan=1>25.32%23.11%</td><td rowspan=1 colspan=1>111m406m</td><td rowspan=1 colspan=1>23.51%22.00%</td><td rowspan=1 colspan=1>136m516m</td></tr><tr><td rowspan=1 colspan=1>WResNet-122-i (0urs)</td><td rowspan=1 colspan=1>5-5-5 to20-20-20</td><td rowspan=1 colspan=1>5.46%</td><td rowspan=1 colspan=1>239m</td><td rowspan=1 colspan=1>23.04%</td><td rowspan=1 colspan=1>237m</td><td rowspan=1 colspan=1>22.65%</td><td rowspan=1 colspan=1>307m</td></tr></table>",
+        "bbox": [
+            181,
+            101,
+            815,
+            251
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/84090e633397d82376e54f505e9c9115c0cf9847f65a46f9fc120ed5a0d3a177.jpg",
+        "image_caption": [
+            "Table 4: Main multi-level method results for Wide ResNets (WResNets) with different depths. The model name with i corresponds to the multi-level method. Our multi-level training method achieves superior or on-par accuracy with the last cycle model while saving about $40 \\%$ of training time. The unit of training time is a minute. ",
+            "Figure 6: Train and test curves using our multi-level method with ResNet-50-i and WResNet50-i on CIFAR-10/100. The models are interpolated at epoch 60 and 110, dividing the training steps to three cycles. Although both training and test accuracy temporarily drops at the start of each cycle, the performance eventually surpasses the previous cycles. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            335,
+            823,
+            492
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            584,
+            285,
+            599
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mart´ın Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Greg S Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, et al. Tensorflow: Large-scale machine learning on heterogeneous distributed systems. arXiv preprint arXiv:1603.04467, 2016. ",
+        "bbox": [
+            174,
+            607,
+            826,
+            650
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Bo Chang, Lili Meng, Eldad Haber, Lars Ruthotto, David Begert, and Elliot Holtham. Reversible architectures for arbitrarily deep residual neural networks. arXiv preprint arXiv:1709.03698, 2017. ",
+        "bbox": [
+            174,
+            657,
+            825,
+            699
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kyunghyun Cho, Bart Van Merrienboer, Caglar Gulcehre, Dzmitry Bahdanau, Fethi Bougares, Hol- ¨ ger Schwenk, and Yoshua Bengio. Learning phrase representations using rnn encoder-decoder for statistical machine translation. ACL, 2014. ",
+        "bbox": [
+            174,
+            708,
+            825,
+            750
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Adam Coates, Andrew Ng, and Honglak Lee. An analysis of single-layer networks in unsupervised feature learning. In Proceedings of the fourteenth international conference on artificial intelligence and statistics, 2011. ",
+        "bbox": [
+            174,
+            757,
+            825,
+            801
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Weinan E. A proposal on machine learning via dynamical systems. Communications in Mathematics and Statistics, 5(1):1–11, 3 2017. ",
+        "bbox": [
+            173,
+            808,
+            823,
+            837
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Andre Esteva, Brett Kuprel, Roberto A Novoa, Justin Ko, Susan M Swetter, Helen M Blau, and Sebastian Thrun. Dermatologist-level classification of skin cancer with deep neural networks. Nature, 2017. ",
+        "bbox": [
+            174,
+            844,
+            825,
+            887
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mark Everingham, Luc Van Gool, Christopher KI Williams, John Winn, and Andrew Zisserman. The pascal visual object classes (voc) challenge. IJCV, 2010. ",
+        "bbox": [
+            174,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Michael Figurnov, Maxwell D Collins, Yukun Zhu, Li Zhang, Jonathan Huang, Dmitry Vetrov, and Ruslan Salakhutdinov. Spatially adaptive computation time for residual networks. CVPR, 2017. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            133
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Aidan N Gomez, Mengye Ren, Raquel Urtasun, and Roger B Grosse. The reversible residual network: Backpropagation without storing activations. NIPS, 2017. ",
+        "bbox": [
+            171,
+            141,
+            821,
+            171
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Klaus Greff, Rupesh K Srivastava, and Jurgen Schmidhuber. Highway and residual networks learn ¨ unrolled iterative estimation. In ICLR, 2017. ",
+        "bbox": [
+            173,
+            179,
+            823,
+            209
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Caglar Gulcehre, Marcin Moczulski, Francesco Visin, and Yoshua Bengio. Mollifying networks. arXiv preprint arXiv:1608.04980, 2016. ",
+        "bbox": [
+            171,
+            218,
+            823,
+            247
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jung-Woo Ha, Hyuna Pyo, and Jeonghee Kim. Large-scale item categorization in e-commerce using multiple recurrent neural networks. In KDD, 2016. ",
+        "bbox": [
+            173,
+            257,
+            823,
+            286
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Eldad Haber and Lars Ruthotto. Stable architectures for deep neural networks. arXiv preprint arXiv:1705.03341, 2017. ",
+        "bbox": [
+            174,
+            295,
+            823,
+            324
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Eldad Haber, Lars Ruthotto, and Elliot Holtham. Learning across scales-a multiscale method for convolution neural networks. arXiv preprint arXiv:1703.02009, 2017. ",
+        "bbox": [
+            174,
+            333,
+            823,
+            363
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Wolfgang Hackbusch. Multi-grid methods and applications, volume 4. Springer Science & Business Media, 2013. ",
+        "bbox": [
+            174,
+            371,
+            823,
+            401
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Moritz Hardt and Tengyu Ma. Identity matters in deep learning. ICLR, 2017. ",
+        "bbox": [
+            173,
+            410,
+            679,
+            426
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016. ",
+        "bbox": [
+            176,
+            434,
+            821,
+            464
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Georgia Gkioxari, Piotr Dollar, and Ross Girshick. Mask R-CNN. In ´ ICCV, 2017. ",
+        "bbox": [
+            174,
+            473,
+            802,
+            488
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Gao Huang, Yu Sun, Zhuang Liu, Daniel Sedra, and Kilian Q Weinberger. Deep networks with stochastic depth. In ECCV, 2016. ",
+        "bbox": [
+            173,
+            497,
+            821,
+            527
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Gao Huang, Danlu Chen, Tianhong Li, Felix Wu, Laurens van der Maaten, and Kilian Q Weinberger. Multi-scale dense convolutional networks for efficient prediction. arXiv preprint arXiv:1703.09844, 2017a. ",
+        "bbox": [
+            173,
+            535,
+            823,
+            579
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Gao Huang, Zhuang Liu, Kilian Q Weinberger, and Laurens van der Maaten. Densely connected convolutional networks. CVPR, 2017b. ",
+        "bbox": [
+            174,
+            588,
+            823,
+            617
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Stanisław Jastrzebski, Devansh Arpit, Nicolas Ballas, Vikas Verma, Tong Che, and Yoshua Bengio. Residual connections encourage iterative inference. arXiv preprint arXiv:1710.04773, 2017. ",
+        "bbox": [
+            173,
+            626,
+            823,
+            656
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009. ",
+        "bbox": [
+            174,
+            665,
+            823,
+            681
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sihan Li, Jiantao Jiao, Yanjun Han, and Tsachy Weissman. Demystifying resnet. arXiv preprint arXiv:1611.01186, 2016. ",
+        "bbox": [
+            173,
+            689,
+            823,
+            718
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yuanzhi Li and Yang Yuan. Convergence analysis of two-layer neural networks with relu activation. NIPS, 2017. ",
+        "bbox": [
+            174,
+            727,
+            823,
+            757
+        ],
+        "page_idx": 9
+    },
+    {
+        "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 ´ ECCV, 2014. ",
+        "bbox": [
+            173,
+            765,
+            823,
+            796
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ilya Loshchilov and Frank Hutter. SGDR: Stochastic gradient descent with warm restarts. ICLR, 2017. ",
+        "bbox": [
+            171,
+            804,
+            823,
+            833
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Aaron van den Oord, Sander Dieleman, Heiga Zen, Karen Simonyan, Oriol Vinyals, Alex Graves, Nal Kalchbrenner, Andrew Senior, and Koray Kavukcuoglu. Wavenet: A generative model for raw audio. arXiv preprint arXiv:1609.03499, 2016. ",
+        "bbox": [
+            176,
+            843,
+            823,
+            886
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tobias Pohlen, Alexander Hermans, Markus Mathias, and Bastian Leibe. Full resolution image compression with recurrent neural networks. CVPR, 2017. ",
+        "bbox": [
+            176,
+            895,
+            820,
+            924
+        ],
+        "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. IJCV, 2015. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sasha Targ, Diogo Almeida, and Kevin Lyman. Resnet in resnet: generalizing residual architectures. ICLR Workshop, 2016. ",
+        "bbox": [
+            173,
+            161,
+            821,
+            190
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Andreas Veit, Michael J Wilber, and Serge Belongie. Residual networks behave like ensembles of relatively shallow networks. In NIPS, 2016. ",
+        "bbox": [
+            171,
+            205,
+            823,
+            234
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yonghui Wu, Mike Schuster, Zhifeng Chen, Quoc V Le, Mohammad Norouzi, Wolfgang Macherey, Maxim Krikun, Yuan Cao, Qin Gao, Klaus Macherey, et al. Google’s neural machine translation system: Bridging the gap between human and machine translation. arXiv preprint arXiv:1609.08144, 2016. ",
+        "bbox": [
+            173,
+            251,
+            825,
+            308
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Saining Xie, Ross Girshick, Piotr Dollar, Zhuowen Tu, and Kaiming He. Aggregated residual trans- ´ formations for deep neural networks. CVPR, 2017. ",
+        "bbox": [
+            173,
+            323,
+            823,
+            352
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Wayne Xiong, Jasha Droppo, Xuedong Huang, Frank Seide, Mike Seltzer, Andreas Stolcke, Dong Yu, and Geoffrey Zweig. The microsoft 2016 conversational speech recognition system. In ICASSP, 2017. ",
+        "bbox": [
+            174,
+            367,
+            825,
+            410
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. BMVC, 2016. ",
+        "bbox": [
+            173,
+            426,
+            707,
+            440
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ligeng Zhu, Ruizhi Deng, Zhiwei Deng, Greg Mori, and Ping Tan. Sparsely connected convolutional networks. arXiv preprint arXiv:1801.05895, 2018. ",
+        "bbox": [
+            176,
+            457,
+            821,
+            486
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A DATASETS AND MODEL DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            518,
+            478,
+            535
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "CIFAR-10 and CIFAR-100 The CIFAR-10 dataset (Krizhevsky & Hinton, 2009) consists of 50,000 training images and 10,000 testing images in 10 classes with $3 2 \\times 3 2$ image resolution. The CIFAR100 dataset has the same number of training and testing images as CIFAR-10, but has 100 classes. We use the common data augmentation techniques including padding four zeros around the image, random cropping, random horizontal flipping and image standardization (Huang et al., 2016). ",
+        "bbox": [
+            174,
+            553,
+            825,
+            622
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "STL-10 The STL-10 dataset (Coates et al., 2011) is an image classification dataset with 10 classes with image resolutions of $9 6 \\times 9 6$ . It contains 5,000 training images and 8,000 testing images. Compared with CIFAR-10/100, each class has fewer training samples but higher image resolution. We use the same data augmentation as the CIFAR-10/100 except for padding 12 zeros around the images. ",
+        "bbox": [
+            174,
+            628,
+            825,
+            700
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Number of parameters We list the number of parameters for each model in Table 5. ",
+        "bbox": [
+            174,
+            705,
+            728,
+            720
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/a52e3e2ba03ea40683a537f997259e11f6a4825627f62332497a267c7bce2200.jpg",
+        "table_caption": [
+            "Table 5: The number of parameters for each network model. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Model</td><td rowspan=1 colspan=1># Blocks</td><td rowspan=1 colspan=1>CIFAR-10</td><td rowspan=1 colspan=1>CIFAR-100</td><td rowspan=1 colspan=1>STL-10</td></tr><tr><td rowspan=1 colspan=1>ResNet-14</td><td rowspan=1 colspan=1>2-2-2</td><td rowspan=1 colspan=1>172,506</td><td rowspan=1 colspan=1>178,356</td><td rowspan=1 colspan=1>172,506</td></tr><tr><td rowspan=1 colspan=1>ResNet-50</td><td rowspan=1 colspan=1>8-8-8</td><td rowspan=1 colspan=1>755,802</td><td rowspan=1 colspan=1>761,652</td><td rowspan=1 colspan=1>755,802</td></tr><tr><td rowspan=1 colspan=1>ResNet-32</td><td rowspan=1 colspan=1>5-5-5</td><td rowspan=1 colspan=1>464,154</td><td rowspan=1 colspan=1>470,004</td><td rowspan=1 colspan=1>464,154</td></tr><tr><td rowspan=1 colspan=1>ResNet-122</td><td rowspan=1 colspan=1>20-20-20</td><td rowspan=1 colspan=1>19,22,394</td><td rowspan=1 colspan=1>1,928,244</td><td rowspan=1 colspan=1>19,22,394</td></tr><tr><td rowspan=1 colspan=1>WResNet-14</td><td rowspan=1 colspan=1>2-2-2</td><td rowspan=1 colspan=1>685,994</td><td rowspan=1 colspan=1>697,604</td><td rowspan=1 colspan=1>685,994</td></tr><tr><td rowspan=1 colspan=1>WResNet-50</td><td rowspan=1 colspan=1>8-8-8</td><td rowspan=1 colspan=1>3,013,802</td><td rowspan=1 colspan=1>3,025,412</td><td rowspan=1 colspan=1>3,013,802</td></tr><tr><td rowspan=1 colspan=1>WResNet-32</td><td rowspan=1 colspan=1>5-5-5</td><td rowspan=1 colspan=1>1,849,898</td><td rowspan=1 colspan=1>1,861,508</td><td rowspan=1 colspan=1>1,849,898</td></tr><tr><td rowspan=1 colspan=1>ResNet-122</td><td rowspan=1 colspan=1>20-20-20</td><td rowspan=1 colspan=1>7,669,418</td><td rowspan=1 colspan=1>7,681,028</td><td rowspan=1 colspan=1>7,669,418</td></tr></table>",
+        "bbox": [
+            264,
+            736,
+            732,
+            883
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "B IMPLEMENTATION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            436,
+            117
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Interpolation Figure 5 gives a conceptual illustration of the interpolation operation. When implementing this operation, the first block in each stage requires special treatment. The first block changes the size of the feature map and the number of channels, thus the shapes of convolution and batch normalization parameters are different from those in subsequent blocks. As a result, we cannot simply copy the parameters from block $_ { 1 } \\cdot$ to block $_ { 2 } \\cdot$ . Instead, the parameters of block $_ { 2 } \\cdot$ are copied from block $_ { 3 } ,$ . ",
+        "bbox": [
+            173,
+            133,
+            825,
+            218
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "C FURTHER ANALYSIS OF TIME STEP SIZE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            241,
+            537,
+            256
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Instead of using $h$ as an implicit step size in Sec. 3.2, we can also explicitly express it in the model. That is, a residual block represents the function $F$ instead of $G$ , and $h$ becomes a hyperparameter of the model. In other words, in each residual block, the output of the residual module is multiplied by $h$ before being added to the identity mapping. Now $h$ is the explicit step size that we can control. This enables us to verify the claim that the depth of the network does not affect the underlying differential equation. ",
+        "bbox": [
+            173,
+            272,
+            825,
+            356
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Empirical analysis We run the following experiments on CIFAR-10 and CIFAR-100: ",
+        "bbox": [
+            174,
+            363,
+            736,
+            377
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "• ResNet-32: 15 blocks with $h = 1$ ;   \n• ResNet-62: 30 blocks with $h = 0 . 5$ ;   \n• ResNet-122: 60 blocks with $h = 0 . 2 5$ ; ",
+        "bbox": [
+            215,
+            390,
+            483,
+            445
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "According to our theory, those three models are different discretizations of the same differential equation in Eq. (2). As a result, the function values $F ( t )$ should be roughly the same across the time interval $[ 0 , T ]$ , which is discretized to 15, 30 and 60 time steps respectively. In Figure 7, we plot the $L ^ { 2 }$ -norm of the residual blocks $F ( \\mathbf { Y } _ { j } )$ and scale the block number to the corresponding conceptual time points. It can be seen from the figure that the three curves follow the same trend, which represents the underlying function $F ( t )$ . ",
+        "bbox": [
+            173,
+            458,
+            825,
+            544
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/5a47f0c9a837c238beea7a6c4678d97077445b82c4c89ef1af7d0e5d8686e4db.jpg",
+        "image_caption": [
+            "Figure 7: Comparison of $\\| F ( \\mathbf { Y } _ { j } ) \\|$ among three models: (1) ResNet-32 with $h = 1$ , (2) ResNet-62 with $h = 0 . 5$ , (3) ResNet-122 with $h = 0 . 2 5$ . If the dynamical systems view is correct, the three curves should approximately follow the same trend. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            564,
+            821,
+            714
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "D MORE EXPERIMENTAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            799,
+            475,
+            815
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Train and test curves on STL-10 We show the train and test curves using our multi-level training method on ResNet-50-i and Wide ResNet-50-i on STL10 in Fig. 8. ",
+        "bbox": [
+            173,
+            832,
+            823,
+            861
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Effect of learning rate To study the effect of $\\eta _ { \\mathrm { m a x } }$ and $\\eta _ { \\mathrm { m i n } }$ on the cyclic learning rate in Eq. (9), we plot their effect on test accuracy in Fig. 9. We empirically find that $\\eta _ { \\mathrm { m a x } } = 0 . 5$ and $\\eta _ { \\mathrm { m i n } } = 0 . 0 0 1$ achieve the best accuracy. With the increase of maximum learning rate $\\eta _ { \\mathrm { m a x } }$ , the test accuracy increases first and then decreases. A potential explanation is that with a small learning rate, the system learns slowly, while with a high learning rate, the system contains too much kinetic energy and is unable to reach the deeper and narrower parts of the loss function. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/3691ee2efd14a8807cdc55f077d0959760a55c84b0202b62aea26ec2c280a404.jpg",
+        "image_caption": [
+            "Figure 8: Train and test curves using our multi-level method with ResNet-50-i and WResNet50-i on STL10. Although both training and testing accuracy temporarily drops at the start of each cycle, the performance eventually surpasses the previous cycles. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            287,
+            198,
+            694,
+            364
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/5c8f85e0f20e1faa04236d45541d53cd3f199b49ca630818aad576588fddf629.jpg",
+        "image_caption": [
+            "Figure 9: Effect of $\\eta _ { \\mathrm { m a x } }$ and $\\eta _ { \\mathrm { m i n } }$ in cyclic learning rate. In most cases, as $\\eta _ { \\mathrm { m a x } }$ increases, the testing accuracy increases first and then decreases. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            285,
+            613,
+            686,
+            791
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            821,
+            132
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Effect of resetting the learning rate To study the effect of resetting the learning rate at the beginning of each cycle, we also run the multi-level training method without resetting the learning rate, that is to use Eq. 9 throughout all cycles. The experiment setting is the same as described in Section 5.2. We train Resnet-50-i on CIFAR-10, CIFAR-100 and STL-10. Each setting is repeated 10 times to obtain the confidence intervals. Fig. 10 shows the results: resetting the learning rate at the beginning of each cycle gives better validation accuracy. ",
+        "bbox": [
+            173,
+            138,
+            825,
+            223
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/b7eeaef4bf13a0f9912c14647f619a7ca8e3b6b866ba3f64ea3725b7a0c4a114.jpg",
+        "image_caption": [
+            "Figure 10: Effect of resetting the learning rate. Resetting the learning rate at the beginning of each cycle gives better validation accuracy. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            236,
+            236,
+            756,
+            486
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Comparison with shallow and deep ResNets Fig. 11 shows that training accuracy curves for a shallow ResNet (same depth as the starting model) and a deep ResNet (same depth as the final model). ",
+        "bbox": [
+            173,
+            541,
+            826,
+            584
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/76a0dd8e2c3626eeeb3a9ab4d0a4b4d3d2b7fd0d6237d33d548499a2dc31b284.jpg",
+        "image_caption": [
+            "Figure 11: Shallow and deep ResNets. Training accuracy curves for a shallow ResNet (same depth as the starting model) and a deep ResNet (same depth as the final model). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            602,
+            825,
+            752
+        ],
+        "page_idx": 13
+    }
+]

parse/train/SygGlIBcel/SygGlIBcel.md

@@ -0,0 +1,296 @@
+# OPENING THE VOCABULARY OF NEURAL LANGUAGE MODELS WITH CHARACTER-LEVEL WORD REPRESENTATIONS
+
+Matthieu Labeau LIMSI-CNRS / Orsay, France labeau@limsi.fr
+
+Alexandre Allauzen LIMSI-CNRS / Orsay, France allauzen@limsi.fr
+
+# ABSTRACT
+
+This paper introduces an architecture for an open-vocabulary neural language model. Word representations are computed on-the-fly by a convolution network followed by pooling layer. This allows the model to consider any word, in the context or for the prediction. The training objective is derived from the NoiseContrastive Estimation to circumvent the lack of vocabulary. We test the ability of our model to build representations of unknown words on the MT task of IWSLT2016 from English to Czech, in a reranking setting. Experimental results show promising results, with a gain up to 0.7 BLEU point. They also emphasize the difficulty and instability when training such models with character-based representations for the predicted words.
+
+# 1 INTRODUCTION
+
+Most of neural language models, such as $n$ -gram models Bengio et al. (2003) are word based and rely on the definition of a finite vocabulary $\nu$ . As a consequence, a Look-up table is associated to $\nu$ in which each word $w \in \mathcal { V }$ is mapped to a vector of $d _ { E }$ real valued features stored in a matrix $\mathbf { L } \in \mathbb { R } ^ { | \mathcal { V } | * d _ { E } }$ . While this approach has proven successful for a variety of tasks and languages, see for instance Schwenk (2007) in speech recognition and Le et al. (2012); Devlin et al. (2014); Bahdanau et al. (2014) in machine translation, it induces several limitations.
+
+For morphologically-rich languages, like Czech or German, the lexical coverage is still an important issue, since there is a combinatorial explosion of word forms, most of which are hardly observed on training data. On the one hand, growing the Look-up table is not a solution, since it would increase the number of parameters without having enough training example for a proper estimation. On the other hand, rare words can be replaced by a special token. Nevertheless, this acts as a word class merging very different words without any distinction and using different word classes to handle outof-vocabulary words Allauzen & Gauvain (2005) does not really solve this issue, since rare words are difficult to classify.
+
+Moreover, for most inflected or agglutinative forms, as well as for compound words, the word structure is overlooked, wasting parameters for modeling forms that could be more efficiently handled by word decomposition. While the use of subword units Botha & Blunsom (2014); Sennrich et al. (2016) could improve the generalization power of such models, it relies on a proper and efficient method to induce these subword units.
+
+To overcome these issues, we propose to investigate a word based language model with an open vocabulary. Since most of existing models and training criteria rely on the assumption of a finite vocabulary, the definition of an open vocabulary model, along with a training criterion, constitutes a scientific challenge. Our goal is to build word representations every words. Word representations are inferred on-the-fly from its character sequence, using convolution filters which implicitly capture subword patterns, as described in section 2. The architecture is based on a neural ngram model inspired from Bengio et al. (2003), while this idea can be extended to other kind of models. By relaxing the normalized constraint, the objective function borrows from the noise contrastive estimation Gutmann & Hyvarinen (2012) to allow our model to consider a possibly infinite vocabulary. ¨ This paper focusses on this challenge and its related training issues. To assess the efficiency of this approach, the experimental setup described in section 3 uses a large scale translation task in a reranking setting. The experimental results summarized in section 4 show promising results as well as training issues.
+
+# 2 MODEL DESCRIPTION
+
+Word embeddings are parameters, stored in a Look-up matrix L. The embedding ${ \bf e } _ { w } ^ { w o r d }$ of a word $w$ is simply the column of $\mathbf { L }$ corresponding to its index in the vocabulary:
+
+$$
+\mathbf { e } _ { w } ^ { w o r d } = [ \mathbf { L } ] _ { w }
+$$
+
+# 2.1 CHARACTER-LEVEL WORD EMBEDDINGS
+
+To infer a word embedding from its character embeddings, we use a convolution layer Waibel et al. (1990); Collobert et al. (2011), similar to layers used in Santos & Zadrozny (2014); Kim et al. (2015). As illustrated in figure 1, a word $w$ is a character sequence $\{ c _ { 1 } , . . , c _ { | w | } \}$ represented by their embeddings $\{ \mathbf { C } _ { c _ { 1 } } , . . , \mathbf { C } _ { c _ { | w | } } \}$ , where $\mathbf { C } _ { c _ { i } }$ denotes the vector associated to the character $c _ { i }$ . A convolution filter $\mathbf { W } ^ { c o n v } \in \mathbb { R } ^ { d _ { e } } \times \mathbb { R } ^ { d _ { c } \ast n _ { c } }$ is applied over a sliding window of $n _ { c }$ characters, producing local features :
+
+$$
+x _ { n } = { \bf W } ^ { c o n v } ( { \bf C } _ { c _ { n - n _ { c } + 1 } } : . . : { \bf C } _ { c _ { n } } ) ^ { T } + { \bf b } ^ { c o n v }
+$$
+
+where $x _ { n }$ is a vector of size $d _ { e }$ obtained for each position $n$ in the word1. The notation $( \mathbf { C } _ { c _ { n - 1 } } : \mathbf { C } _ { c _ { n } } )$ denotes the concatenation of two embeddings. The $i$ -th element of the embedding of $w$ is the mean over the $i$ -th elements of the feature vectors, passed by the activation function $\phi$ :
+
+$$
+[ { \bf e } ^ { c h a r } ] _ { i } = \phi \left( \sum _ { n = 1 } ^ { | w | - n _ { c } + 1 } \frac { [ { \bf x } _ { n } ] _ { i } } { | w | - n _ { c } + 1 } \right)
+$$
+
+Using a mean after a sliding convolution window ensures that the embedding combines local features from the whole word, and that the gradient is redistributed at scale for each character $\mathbf { n }$ -gram. The parameters of the layer are the matrices $\mathbf { C }$ and ${ \bf W } ^ { c o n v }$ and the bias $\mathbf { b } ^ { c o n v }$ .
+
+# 2.2 MODELS
+
+Our model follows the classic $\mathbf { n }$ -gram feedforward architecture. The input of the network is a $n$ - words context $H _ { i } = ( w _ { i - 1 } , \dots , w _ { N - i + 1 } )$ , and its output the probability $P ( w | H _ { i } )$ for each word $w \in \mathcal V$ . The embeddings of the word in the context are concatenated and fed into a hidden layer:
+
+$$
+\mathbf { h } ^ { H _ { i } } = \phi ( \mathbf { W } ^ { h i d d e n } ( \mathbf { e } _ { i - 1 } : . . . : \mathbf { e } _ { N - i + 1 } ) + \mathbf { b } ^ { h i d d e n } )
+$$
+
+A second hidden layer my be added. Finally, the output layer computes scores for each word:
+
+$$
+\mathbf { s } ^ { H _ { i } } = \exp \left( \mathbf { W } ^ { o u t } \mathbf { h } ^ { H _ { i } } + \mathbf { b } ^ { o u t } \right)
+$$
+
+Whidden, $\mathbf { b } ^ { h i d d e n }$ , ${ \bf W } ^ { o u t }$ and $\mathbf { b } ^ { o u t }$ are the parameters of the model. As the input Lookup-matrix $\mathbf { L }$ , the output weight matrix ${ \bf W } ^ { o u t }$ contains word embeddings, that are output representations of the words in the vocabulary:
+
+$$
+\mathbf { e } _ { w } ^ { o u t } = [ \mathbf { W } ^ { o u t } ] _ { w }
+$$
+
+Then, the output probabilities are expressed as:
+
+$$
+P ( w | H _ { i } ) = \frac { \exp { \mathbf { e } _ { w } ^ { o u t } } \mathbf { h } ^ { H _ { i } } } { \displaystyle \sum _ { 1 < j < | \mathcal { V } | } \exp { \mathbf { e } _ { j } ^ { o u t } } \mathbf { h } ^ { H _ { i } } }
+$$
+
+Later, we will use three different input layer to obtain word representations:
+
+![](images/c97618b1879e6c1d79ee353c5f318d490b149538f1805f8146067395a909d2b9.jpg)  
+Figure 1: CWE Model architecture
+
+• A classic NLM using word-level embeddings only, that we will note WE, which uses $| \nu | *$ $d _ { e }$ parameters.   
+• A NLM using embeddings constructed from character n-grams by convolution $^ +$ pooling, that we will note CE, which uses $| \mathcal { V } _ { c } | \ast d _ { c } + d _ { c } \ast n _ { c } \ast d _ { e }$ parameters.   
+• A NLM using a concatenation of these two types of embeddings as word representation, that we will note CWE.
+
+# 2.3 OBJECTIVE FUNCTION FOR OPEN VOCABULARY MODELS
+
+Usually, such a model is trained by maximizing the log-likelihood. For a given word given its context, the model parameters $\theta$ are estimated in order to maximize the following function for all the n-grams observed in the training data:
+
+$$
+L L ( \theta ) = \sum _ { 1 < i < | D | } \log P _ { \theta } ( w _ { i } | H _ { i } ) .
+$$
+
+This objective function raises two important issues. For conventional word models, it implies a very costly summation imposed by the softmax activation of the output layer. More importantly, this objective requires the definition of a finite vocabulary, while the proposed model may use characterbased word embeddings, especially at the output, making the notion of vocabulary obsolete.
+
+Therefore, the parameters estimation relies on Noise Contrastive Estimation (NCE) introduced in Gutmann & Hyvarinen (2012); Mnih & Teh (2012). This criterion allows us to train both types ¨ of models based on conventional word embeddings, along with character-based embeddings. The NCE objective function aims to discriminate between examples sampled from the real data and from a noise distribution. When presented with examples coming from a mixture of one sample from the data distribution $P _ { d }$ and $k$ from the noise distribution $P _ { n }$ , $\bar { P } ^ { H } ( w \in \mathcal { D } )$ denotes the posterior probability of a word $w$ given its context $H$ to be sampled from the training data $\mathcal { D }$ . This probability can be expressed as follows:
+
+$$
+P ^ { H } ( w \in \mathcal { D } ) = \frac { P _ { d } ^ { H } ( w ) } { P _ { d } ^ { H } ( w ) + k P _ { n } ( w ) }
+$$
+
+As suggested in Mnih & Teh (2012), $P _ { n }$ only depends on $w$ here, since we chose the unigram distribution estimated on the training data. If
+
+$$
+s _ { \theta } ^ { H } ( w ) = \exp \left( \mathbf { e } ^ { o u t } \mathbf { h } ^ { H } + \mathbf { b } ^ { o u t } \right)
+$$
+
+denotes the non-normalized score given by the model to a specific word $w$ , as a function of the parameters $\theta$ and the context $H$ , the final NCE objective function has the following form Gutmann
+
+& Hyvarinen (2012): ¨
+
+$$
+J _ { \theta } ^ { H } = E _ { s _ { \theta } ^ { H } } \left[ l o g \frac { s _ { \theta } ^ { H } ( w ) } { s ^ { H } ( w ) + k P _ { n } ( w ) } \right] + k E _ { P _ { n } } \left[ l o g \frac { k P _ { n } ( w ) } { s _ { \theta } ^ { H } ( w ) + k P _ { n } ( w ) } \right] ,
+$$
+
+where $s _ { \theta } ^ { H }$ will tend to $P _ { d } ^ { H }$ without the need for an explicit normalization.
+
+# 2.4 CHARACTER-BASED OUTPUT WEIGHTS WITH NOISE-CONTRASTIVE ESTIMATION
+
+The output weights representing each word in the vocabulary $\mathbf { e } ^ { o u t }$ can also be replaced by embeddings computed by a convolution layer on character $n$ -grams. In this case the model can efficiently represent and infer a score to any word, observed during the training process or not, while with conventional word embeddings, out of vocabulary words only share the same representation and distribution. Instead of using a parameter matrix ${ \bf W } ^ { o u t }$ to estimate the score like in equation 2, the output representation of a word $w$ , $\mathbf { e } _ { w } ^ { o u t }$ can be replaced by a vector $\mathbf { e } _ { w } ^ { c h a r - o u t }$ estimated on the fly based on its character sequence as described in equation 1, using $| \mathcal { V } _ { c } | \ast d _ { c } + d _ { c } \ast n _ { c } \ast d _ { h }$ parameters. With this extension the model does not rely on a vocabulary anymore, hence motivating our choice of the NCE. This unnormalized objective allows us to handle an open vocabulary, since we only need to compute $k + 1$ word representations for each training examples. Models that use character-based embeddings both for input and output words are denoted by CWE-CWE.
+
+Moreover, with this extension, the representations of words sharing character $n$ -grams are tied. This is an important property to let the model generalize to unseen words. However, it can be also an issue: the limited number of updates for output representations $\boldsymbol { k } + \boldsymbol { 1 }$ words) has a “rich get richer” effect: the most frequent words are usually short and will get most of the update. They may therefore ”contaminate” the representation of longer words with which they share character $n$ -grams, even if these words are not related. This issue is further addressed in section 4.1.
+
+# 3 EXPERIMENTAL SET-UP
+
+The impact of the models described in section 2 is evaluated within the machine translation (MT) shared task of IWSLT- $2 0 1 6 ^ { 2 }$ from Englih to Czech. This language pair is highly challenging since Czech is a morphologically-rich language. Neural language models are integrated in a two steps approach: the first step uses a conventional MT system to produce an $n$ -best list (the $n$ most likely translations); in the second step, these hypothesis are re-ranked by adding the score of the neural language model. To better benefit from the open vocabulary models introduced in section 2.1, a more complex system is also used: first an MT system is used to translate from English to a simplified form of Czech which is reinflected. With this pipeline we expect $n$ -best lists with more diversity and also words unseen during the training process. The neural language models are then used to re-rank the reinflected $n$ -best lists.
+
+# 3.1 DATA
+
+The IWSLT16 MT task is focused on the translation of TED talks. The translation systems are trained on parallel data from the TED, QED and europarl. Our Neural language models are trained on the same data, but training examples are sampled from these corpora given weights that are computed to balance between in-domain parallel data (TED), out-of domain parallel data, and additional monolingual data. Finally, we use the concatenation of TED.dev2010, TED.dev2011 and TED.tst2010 as development set, while TED.tst2012 and TED.tst2013 provide the test set.
+
+# 3.2 CZECH RE-INFLECTION
+
+In Czech, a morphologically rich language, each lemma can take a lot of possible word forms. Most of them won’t appear - or with a very low frequency - in training data. For an important part of the words found in test data and unseen during training, their lemmas however can be observed but with a different morphological derivation.
+
+A non-observed word form can’t be generated by the translation system, and one seen too rarely won’t be used in a relevant way. To circumvent this limitation, in a similar fashion as the method described in Marie et al. (2015), each noun, pronoun and adjective is replaced in the training corpora by its lemma along with some morphological features. These word forms are considered in factored way, where some of the POS tags are discarded to reduce the vocabulary. After the translation process, a cascade of Conditional Random Fields (CRF) are used to reintroduce the discarded features, such as gender, number and case, and to generate a new word form.
+
+Formally, the MT system translates English into a simplified version of Czech, that is reinflected. Within this process, the MT system can produce a $n$ -best list, that can be extended to a $n k$ -best list, considering for each translation hypothesis the $k$ -best reinflected sentences given by the factorized CRF. Intuitively, this process can introduce word forms potentially not yet seen in training data, but based on known paradigms, which can give an advantage to language models able to build a word representation from character $n$ -grams.
+
+# 3.3 BASELINE TRANSLATION SYSTEM
+
+Our baseline is built with a Statistical Machine Translation system based on bilingual n-grams, NCODE3, described in Crego et al. (2011). We follow the same setup as in Marie et al. (2015).
+
+# 3.4 NLM TRAINING AND OPTIMIZATION
+
+First, some comparative experiments on a smaller dataset are carried out to better understand how open vocabulary NLM behave and to set the hyper-parameters. First trained using stochastic gradient descent, we observed a quite unstable training process, restricting a proper hyper-parameters choices. We found that especially the embedding dimensions, and the activation functions used could make the NCE-objective hard to optimize. This was aggravated in Czech, which we found more difficult to work with than other morphologically complex languages, like German and Russian. The use of Adagrad Duchi et al. (2010) clearly helps to solve most of these issues, but adds consequent computation time. Following preliminary results on our work with a similar model on a different task Labeau et al. (2015), we made the choice of not implementing LSTMs to obtain character-level word representations. It gave similar results, at the cost of unstable training and extended computation time. We then train using batches of 128, for various context sizes, WE, CWE, and CWE-CWE models. The ReLu activation function is used, along with an embedding size of $d _ { e } = 1 2 8$ . When relevant, we used a character embedding size of $d _ { c } = 3 2$ and a convolution on $n _ { c } = 5$ -grams of characters for all experiments4. Concerning the NCE training, we sampled $k = 2 5$ examples from the unigram distribution obtained from the training data, for each example sampled from the data. The models were implemented using $C { + + } ^ { 5 }$ .
+
+# 3.5 RERANKING
+
+The re-ranking step uses additional features to find a better translation among the $n$ -best generated by the decoder (in our case, $n = 3 0 0$ ): we use the score (probability) of WE, CWE and CWECWE models given to each sentence by our models as such a feature. Tuning for re-ranking was performed with KB-MIRA Cherry & Foster (2012), and evaluation using BLEU score.
+
+# 4 EXPERIMENTAL RESULTS
+
+The first set of experiments investigates the impact of the padding design on the character-level representation followed by a study of the learning behavior of our proposed models and training criterion. Then, the proposed models are evaluated within the MT task. The final set of experiments analyzes the issues of the model based on character-level representation for output words, in order to propose remedies.
+
+Preliminary results on smaller dataset are quite poor for models using character-level representation, and far worse when used for the output layer. We suspect that groups of characters are updated far more together, yielding a ”contamination” of several character n-grams by very frequent short words.
+
+Indeed, our simple padding scheme, as shown in the left part of table 1, makes words sharing first or last letter(s) systematically share at least one character n-gram: we suppose it gives the models more chance to detect similarities in word forms sharing prefixes and suffixes.
+
+The representations of any of the character n-grams that are included in the frequent words will thus be re-used in a large part of the other words in the corpus. A huge number of word forms are affected: a little more than one third of the training data shares its first character n-gram with one of the ten most frequent words, and a little more than one quarter shares its last.
+
+While considering varying size of character n-grams when building our word representation, as in Kim et al. (2015), would certainly help, it would increase our computation time. We thus choose to alleviate our padding scheme, as shown on the right part of table 1. We add only one character token at the beginning of the word, and one at the end6. While it may inhibit the capacity of the model to build links between words sharing prefixes or suffixes, it improves results drastically, especially when using character-level outputs, as shown in figure 3. This limited padding scheme is used for the following experiments.
+
+<table><tr><td>。。。。a·…</td><td colspan="2">ooa..</td></tr><tr><td>ooooa oooon e</td><td>oale. a.</td><td>oona.</td></tr><tr><td>ooooa OOOON by oooobyl</td><td>oaby·</td><td>ooza.</td></tr><tr><td>ooooa 之</td><td>a ooax.</td><td>obyla.</td></tr><tr><td>ooooa1 ni.... oooodva..</td><td>oani.</td><td>odua.</td></tr><tr><td>ooooa si....</td><td>ooootreba. oasi. 1</td><td>otreba.</td></tr></table>
+
+Table 1: Padding for word decomposition in character 5-grams: $\circ$ is a character token indicating the beginning of the word, while $\bullet$ indicates the end of the word. The left part of the table shows our original padding scheme, which makes very different words share character 5-grams, especially with short, frequent words. The right part of the table shows our alleviated padding scheme.
+
+# 4.2 NLM TRAINING
+
+While the perplexity of our language models is not our main focus, it is still related to the quantity that our training seeks to optimize - since the NCE gradient approaches the maximum likelihood gradient Mnih & Teh (2012). On figure 2 are shown perplexity values of each model during training. These values are based on a vocabulary containing the 250K most frequent words on the training data - it is also the vocabulary used in the model when relevant. They are computed on the development set after each epoch. An epoch includes 2,5M N-grams sampled from the training data. On table 2 are shown the best perplexity obtained on the development set by each model, during training.
+
+<table><tr><td>Context size (Number of words)</td><td>3</td><td>6</td></tr><tr><td>WE</td><td>227</td><td>193</td></tr><tr><td>CWE</td><td>207</td><td>185</td></tr><tr><td>CWE-CWE</td><td>308</td><td>243</td></tr></table>
+
+Table 2: Best perplexity reached on the development set, on a 250K output vocabulary, after 15 epochs of 2,5M n-grams
+
+Table 2 shows that a character-level word representation helps to decrease the perplexity, even if a larger context closes the gap. To compute the perplexity of CWE-CWE models, we use the
+
+![](images/3a5686341336b59a9a5a825ca16f0f0be913bb92ab7d17c7401a2c58f012c387.jpg)  
+Figure 2
+
+![](images/0f74ca992fbde46fe5b89e9daa8be833f234890e05ebd3910bb474a6ebabce35.jpg)  
+Figure 3
+
+Figure 4: Model perplexity measured on the development set during training. The context size is 3 words. Figure 3 shows models based on character-level word representations, with and without complete padding. Models are trained on the same data than Figure 2 but on smaller epochs (250K n-grams).
+
+same vocabulary as for other models, and use the ’unknown’ tokens for words and characters-based representations. Hence, the perplexity computed is difficult to interpret. The main downside of Adagrad is that the learning rate determined by accumulating the history of past gradients is usually too aggressive and stops learning rather early. We simply reset this history every five epochs to give the model a chance to improve, which explains the flattening followed by small improvements we see for WE and CWE models. We choose to do that reset 2 times, based on previous experiments. Despite adaptive gradient, training of CWE-CWE models stays unstable.
+
+# 4.3 RERANKING
+
+Table 3: Best BLEU score obtained after n-best reranking of the hypothesis given by the translation and translation $+ \mathrm { k }$ -best reinflection systems. $n$ is the context size (in number of words)   
+
+<table><tr><td rowspan="2"></td><td rowspan="2">System to be re-ranked</td><td rowspan="2">BLEU Reference</td><td colspan="2">CWE</td><td colspan="2">CWE-CWE</td><td colspan="2">WE</td></tr><tr><td>n=3</td><td>n=6</td><td>n=3</td><td>n=6</td><td>n=3</td><td>n=6</td></tr><tr><td>En→Cz</td><td>Baseline system</td><td>19.6</td><td>20.1</td><td>20.3</td><td>19.8</td><td>20.0</td><td>20.0</td><td>20.2</td></tr><tr><td rowspan="3">En → Simplified Cz</td><td>Reinflected baseline system</td><td rowspan="3">19.5</td><td>20.0</td><td>20.2</td><td>19.6</td><td>20.1</td><td>20.1</td><td>20.0</td></tr><tr><td>3-best Reinflected baseline system</td><td>19.9</td><td>20.3</td><td>19.6</td><td>20.0</td><td>20.1</td><td>20.1</td></tr><tr><td>5-best Reinflected baseline system</td><td>19.9</td><td>20.3</td><td>19.5</td><td>19.9</td><td>20.0</td><td>20.1</td></tr></table>
+
+The reranking results are shown in table 3. The first line corresponds to experiments with a direct translation from English to Czech, where $n$ -best lists generated by the MT system are simply rescored by our models. The best result is given by the longest-context CWE model, which produces a $\mathbf { + 0 . 7 }$ BLEU score improvement. CWE models gives on average $+ 0 . 1$ BLEU point compared to WE models, while CWE-CWE are $- 0 . 2$ BLEU point under. Doubling the context size consistently improves results of $+ 0 . 2$ BLEU point.
+
+Experimental results on reinflected Czech seems to follow a similar trend: CWE models behave a little better than WE models, while CWE-CWE models are under. While simply reranking $n$ -best lists is not as efficient as doing it directly in Czech, reranking $n k$ -best lists extended by the factorized CRF gives a small improvement, reaching an improvement of $\mathbf { + 0 . 7 }$ BLEU point. As a general rule, small context models seem to have difficulties with reinflected Czech. The main advantage given by the CWE model is an ability to better rerank $n k$ -best lists. These results suggest that, while the normalization $^ +$ reinflection procedure may introduce diversity in the output to be reranked, our models are not able to draw any significant advantage from it.
+
+# 4.4 ANALYSIS OF CHARACTER-LEVEL OUTPUT REPRESENTATIONS PERFORMANCE
+
+Models using character-level output representations gave sub-par results on re-ranking. It is surprising, especially for re-inflected Czech: such a model is supposed to behave better on unknown words, and thus should benefit from diversity given by generating new words. However, as we can see in table 4, re-inflection doesn’t add that much diversity (About $0 . 1 ~ \%$ of OOV words, and about $0 . 0 0 1 \%$ of words never seen by the model before). Diversity is also inhibited by our training algorithm: while we train open-vocabulary models, the negative examples used with Noise-contrastive estimation come from a closed vocabulary.
+
+Table 4: Ratio of unknown words in system outputs measured on the test set.   
+
+<table><tr><td></td><td>Full training vocabulary</td><td>250K words vocabulary</td></tr><tr><td>Reference</td><td>0.131 %</td><td>0.995 %</td></tr><tr><td>En → Cz (300-best)</td><td>0.566 %</td><td>1.173 %</td></tr><tr><td>En→ Simplified Cz + Reinflection</td><td>0.567 %</td><td>1.263 %</td></tr><tr><td>En→Simplified Cz + 3-Best reinflection</td><td>0.567 %</td><td>1.277 %</td></tr><tr><td>En→ Simplified Cz + 5-Best reinflection</td><td>0.568 %</td><td>1.285 %</td></tr></table>
+
+This can related to the nature of the unigram distribution used to sample negative examples. As explained in section 4.1, it makes frequent short words completely outweigh the others in number of updates, and we are forced to reduce the ability of the model to find common morphological attributes between words to avoid ’contamination’ of character n-gram representations.
+
+# 5 RELATED WORKS
+
+There is a number of different strategies to efficiently train NNLMs with large vocabularies, such as different types of hierarchical softmax Mnih & Hinton (2009); Le et al. (2011), importance sampling Bengio & Sen´ ecal (2003), and Noise contrastive estimation Gutmann & Hyv ´ arinen (2012); Mnih & ¨ Teh (2012). Vaswani et al. (2013) has showed the interest of training a NLM with NCE to re-rank $k$ -best lists, while Devlin et al. (2014) uses a self-normalization. Recently, a comparative study Chen et al. (2016) has been made on how to deal with a large vocabulary. However, the purpose of this paper is to explore models with open vocabulary rather large vocabulary.
+
+There is a surge of interest into using character-level information for a wide range of NLP tasks, with improved results in POS Tagging Santos & Zadrozny (2014), Text classification Zhang & LeCun (2015), Parsing Ballesteros et al. (2015), Named entity recognition Lample et al. (2016).
+
+In language modeling, first applications to language modeling were strictly using characters, and performed less than word-level models Mikolov et al. (2012), while showing impressive results for text generation Sutskever et al. (2011); Graves (2013), using bi-directional LSTM Graves et al. (2013). Recently, Ling et al. (2015) has used bi-directional LSTM to build word representations from characters, with improvements in language modeling and POS-tagging.
+
+The recent work of Kim et al. (2015), that uses convolutional networks and pooling to construct a word representation from character n-grams, coupled with highway networks Srivastava et al. (2015), showed on various languages that using characters improves results on the language modeling task (for a small corpus), even more so for languages with complex morphology. A similar architecture was used Jozefowicz et al. (2016) on a larger dataset, conjointly with bi-directional ´ LSTMs, and trained with importance sampling, showing great results.
+
+On the study of NNLMs in the context of Machine Translation, we can mention the work of Luong et al. (2015) on the effect of the number of layers on reranking $n$ -best lists. Finally, while not directly related to our work, Luong & Manning (2016) very recently showed great improvements on a translation task by handling rare words with character-level recurrent networks, with a neural translation model.
+
+# 6 CONCLUSION
+
+In this work, we addressed the challenge of designing an open vocabulary Neural Language Model. For that purpose, word representations are estimated on-the-fly from n-grams of characters. Two kinds of models are introduced: first, NLMs using word and character-level embeddings to represent the input context (CWE); then its extension to an open-vocabulary even for the predicted words (CWE-CWE). These models were used to re-rank outputs of translation systems from English to Czech. We also carried out experiments on translation systems from English to a simplified Czech, which is then re-inflected into Czech before re-ranking.
+
+We obtained a slight improvement in BLEU score using a CWE model, which, given the little variety of the words generated by translation systems, makes us suppose there is room for more. We plan to investigate with more complex translation systems, as well as with other applications, such as morphological re-inflection.
+
+While the performance of our open-vocabulary models are to some extent disappointing, they open questions about the learned representations we will explore. We also plan to investigate on a more fitted noise distribution to use with NCE when training open-vocabulary models.
+
+# ACKNOWLEDGMENTS
+
+# REFERENCES
+
+A. Allauzen and J.L Gauvain. Open vocabulary asr for audiovisual document indexation. In IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), April 2005.
+
+Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. CoRR, abs/1409.0473, 2014.
+
+Miguel Ballesteros, Chris Dyer, and Noah A. Smith. Improved transition-based parsing by modeling characters instead of words with lstms. In Llus Mrquez, Chris Callison-Burch, Jian Su, Daniele Pighin, and Yuval Marton (eds.), EMNLP, pp. 349–359. The Association for Computational Linguistics, 2015. ISBN 978-1-941643-32-7. URL http://dblp.uni-trier.de/ db/conf/emnlp/emnlp2015.html#BallesterosDS15.
+
+Yoshua Bengio and Jean-Sebastien S ´ en´ ecal. Quick training of probabilistic neural nets by impor- ´ tance sampling. In Proceedings of the conference on Artificial Intelligence and Statistics (AISTATS), 2003.
+
+Yoshua Bengio, Rejean Ducharme, Pascal Vincent, and Christian Jauvin. A neural probabilistic ´ language model. Journal of Machine Learning Research, 3:1137 1155, 2003.
+
+Jan A. Botha and Phil Blunsom. Compositional Morphology for Word Representations and Language Modelling. In Proceedings of the International Conference of Machine Learning (ICML), Beijing, China, jun 2014.
+
+Wenlin Chen, David Grangier, and Michael Auli. Strategies for training large vocabulary neural language models. In Proceedings of the 54th Annual Meeting of the Association for Computational Linguistics, ACL 2016, August 7-12, 2016, Berlin, Germany, Volume 1: Long Papers, 2016. URL http://aclweb.org/anthology/P/P16/P16-1186.pdf.
+
+Colin Cherry and George Foster. Batch tuning strategies for statistical machine translation. In Proceedings of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies (NAACL-HLT), pp. 427–436, Montreal, Canada, June 2012. ´
+
+Ronan Collobert, Jason Weston, Leon Bottou, Michael Karlen, Koray Kavukcuoglu, and Pavel ´ Kuksa. Natural language processing (almost) from scratch. J. Mach. Learn. Res., 12:2493– 2537, November 2011. ISSN 1532-4435. URL http://dl.acm.org/citation.cfm? id=1953048.2078186.
+
+Josep Maria Crego, Franois Yvon, and Jos B. Marino. N-code: an open-source Bilingual N-gram ˜ SMT Toolkit. Prague Bulletin of Mathematical Linguistics, 96:49–58, 2011.
+
+Jacob Devlin, Rabih Zbib, Zhongqiang Huang, Thomas Lamar, Richard M. Schwartz, and John Makhoul. Fast and robust neural network joint models for statistical machine translation. In Proceedings of the 52nd Annual Meeting of the Association for Computational Linguistics, ACL 2014, June 22-27, 2014, Baltimore, MD, USA, Volume 1: Long Papers, pp. 1370–1380, 2014. URL http://aclweb.org/anthology/P/P14/P14-1129.pdf.
+
+John Duchi, Elad Hazan, and Yoram Singer. Adaptive subgradient methods for online learning and stochastic optimization. Technical Report UCB/EECS-2010-24, EECS Department, University of California, Berkeley, Mar 2010. URL http://www2.eecs.berkeley.edu/Pubs/ TechRpts/2010/EECS-2010-24.html.
+
+Alex Graves. Generating sequences with recurrent neural networks. CoRR, abs/1308.0850, 2013. URL http://arxiv.org/abs/1308.0850.
+
+Alex Graves, Navdeep Jaitly, and Abdel-rahman Mohamed. Hybrid speech recognition with deep bidirectional LSTM. In 2013 IEEE Workshop on Automatic Speech Recognition and Understanding, Olomouc, Czech Republic, December 8-12, 2013, pp. 273–278, 2013. doi: 10.1109/ASRU. 2013.6707742. URL http://dx.doi.org/10.1109/ASRU.2013.6707742.
+
+Michael U. Gutmann and Aapo Hyvarinen. Noise-contrastive estimation of unnormalized statistical ¨ models, with applications to natural image statistics. J. Mach. Learn. Res., 13(1):307–361, February 2012. ISSN 1532-4435. URL http://dl.acm.org/citation.cfm?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ 2503308. 2188396.
+
+Rafal Jozefowicz, Oriol Vinyals, Mike Schuster, Noam Shazeer, and Yonghui Wu. Exploring the ´ limits of language modeling. CoRR, abs/1602.02410, 2016. URL http://arxiv.org/abs/ 1602.02410.
+
+Yoon Kim, Yacine Jernite, David Sontag, and Alexander M Rush. Character-aware neural language models. arXiv preprint arXiv:1508.06615, 2015.
+
+Matthieu Labeau, Kevin Loser, and Alexandre Allauzen. Non-lexical neural architecture for fine- ¨ grained pos tagging. In Proceedings of the Conference on Empirical Methods in Natural Language Processing (EMNLP), pp. 232–237, Lisbon, Portugal, September 2015.
+
+Guillaume Lample, Miguel Ballesteros, Kazuya Kawakami, Sandeep Subramanian, and Chris Dyer. Neural architectures for named entity recognition. In In proceedings of NAACL-HLT (NAACL 2016)., San Diego, US, 2016.
+
+Hai Son Le, Ilya Oparin, Alexandre Allauzen, Jean-Luc Gauvain, and Franc¸ois Yvon. Structured output layer neural network language model. In Proceedings of the IEEE International Conference on Acoustics, Speech, and Signal Processing, ICASSP 2011, May 22-27, 2011, Prague Congress Center, Prague, Czech Republic, pp. 5524–5527, 2011. doi: 10.1109/ICASSP.2011. 5947610. URL http://dx.doi.org/10.1109/ICASSP.2011.5947610.
+
+Hai-Son Le, Alexandre Allauzen, and Franc¸ois Yvon. Continuous space translation models with neural networks. In Proceedings of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies (NAACL-HLT), pp. 39–48, Montreal, Canada, ´ June 2012. Association for Computational Linguistics.
+
+Wang Ling, Chris Dyer, Alan W. Black, Isabel Trancoso, Ramon Fermandez, Silvio Amir, Lus Marujo, and Tiago Lus. Finding function in form: Compositional character models for open vocabulary word representation. In EMNLP, pp. 1520–1530. The Association for Computational Linguistics, 2015. ISBN 978-1-941643-32-7. URL http://dblp.uni-trier.de/db/ conf/emnlp/emnlp2015.html#LingDBTFAML15.
+
+Minh-Thang Luong and Christopher D. Manning. Achieving open vocabulary neural machine translation with hybrid word-character models. CoRR, abs/1604.00788, 2016. URL http: //arxiv.org/abs/1604.00788.
+
+Thang Luong, Michael Kayser, and Christopher D. Manning. Deep neural language models for machine translation. In Proceedings of the 19th Conference on Computational Natural Language Learning, CoNLL 2015, Beijing, China, July 30-31, 2015, pp. 305–309, 2015. URL http: //aclweb.org/anthology/K/K15/K15-1031.pdf.
+
+Benjamin Marie, Alexandre Allauzen, Franck Burlot, Quoc-Khanh Do, Julia Ive, elena knyazeva, Matthieu Labeau, Thomas Lavergne, Kevin Loser, Nicolas P ¨ echeux, and Franc¸ois Yvon. ´ Limsi@wmt’15 : Translation task. In Proceedings of the Tenth Workshop on Statistical Machine Translation, pp. 145–151, Lisbon, Portugal, September 2015. Association for Computational Linguistics. URL http://aclweb.org/anthology/W15-3016.
+
+Tomas Mikolov, Ilya Sutskever, Anoop Deoras, Hai-Son Le, Stefan Kombrink, and Jan Cernocky. Subword language modeling with neural networks. 2012. Unpublished.
+
+Andriy Mnih and Geoffrey Hinton. A scalable hierarchical distributed language model. In Advances in Neural Information Processing Systems, volume 21, pp. 1081–1088, 2009.
+
+Andriy Mnih and Yee Whye Teh. A fast and simple algorithm for training neural probabilistic language models. In ICML. icml.cc / Omnipress, 2012. URL http://dblp.uni-trier. de/db/conf/icml/icml2012.html#MnihT12.
+
+Cicero D. Santos and Bianca Zadrozny. Learning character-level representations for part-of-speech tagging. In Tony Jebara and Eric P. Xing (eds.), Proceedings of the 31st International Conference on Machine Learning (ICML-14), pp. 1818–1826. JMLR Workshop and Conference Proceedings, 2014. URL http://jmlr.org/proceedings/papers/v32/santos14.pdf.
+
+Holger Schwenk. Continuous space language models. Computer Speech and Language, 21(3): 492–518, July 2007.
+
+Rico Sennrich, Barry Haddow, and Alexandra Birch. Neural machine translation of rare words with subword units. In Proceedings of the Annual Meeting on Association for Computational Linguistics (ACL), pp. 1715–1725, Berlin, Germany, August 2016.
+
+Rupesh Kumar Srivastava, Klaus Greff, and Jurgen Schmidhuber. Training very deep networks. ¨ CoRR, abs/1507.06228, 2015. URL http://arxiv.org/abs/1507.06228.
+
+Ilya Sutskever, James Martens, and Geoffrey Hinton. Generating text with recurrent neural networks. In Lise Getoor and Tobias Scheffer (eds.), Proceedings of the 28th International Conference on Machine Learning (ICML-11), ICML ’11, pp. 1017–1024, New York, NY, USA, June 2011. ACM.
+
+Ashish Vaswani, Yinggong Zhao, Victoria Fossum, and David Chiang. Decoding with large-scale neural language models improves translation. In EMNLP, pp. 1387–1392. ACL, 2013. ISBN 978- 1-937284-97-8. URL http://dblp.uni-trier.de/db/conf/emnlp/emnlp2013. html#VaswaniZFC13.
+
+Alexander Waibel, Toshiyuki Hanazawa, Geofrey Hinton, Kiyohiro Shikano, and Kevin J. Lang. Readings in Speech Recognition, chapter Phoneme Recognition Using Time-delay Neural Networks, pp. 393–404. Morgan Kaufmann Publishers Inc., San Francisco, CA, USA, 1990.
+
+Xiang Zhang and Yann LeCun. Text understanding from scratch. CoRR, abs/1502.01710, 2015. URL http://arxiv.org/abs/1502.01710.

parse/train/SygGlIBcel/SygGlIBcel_content_list.json

@@ -0,0 +1,1548 @@
+[
+    {
+        "type": "text",
+        "text": "OPENING THE VOCABULARY OF NEURAL LANGUAGE MODELS WITH CHARACTER-LEVEL WORD REPRESENTATIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            101,
+            823,
+            171
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Matthieu Labeau LIMSI-CNRS / Orsay, France labeau@limsi.fr ",
+        "bbox": [
+            183,
+            195,
+            382,
+            237
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Alexandre Allauzen LIMSI-CNRS / Orsay, France allauzen@limsi.fr ",
+        "bbox": [
+            506,
+            195,
+            705,
+            238
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            273,
+            544,
+            289
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "This paper introduces an architecture for an open-vocabulary neural language model. Word representations are computed on-the-fly by a convolution network followed by pooling layer. This allows the model to consider any word, in the context or for the prediction. The training objective is derived from the NoiseContrastive Estimation to circumvent the lack of vocabulary. We test the ability of our model to build representations of unknown words on the MT task of IWSLT2016 from English to Czech, in a reranking setting. Experimental results show promising results, with a gain up to 0.7 BLEU point. They also emphasize the difficulty and instability when training such models with character-based representations for the predicted words. ",
+        "bbox": [
+            233,
+            304,
+            764,
+            443
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            467,
+            336,
+            483
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Most of neural language models, such as $n$ -gram models Bengio et al. (2003) are word based and rely on the definition of a finite vocabulary $\\nu$ . As a consequence, a Look-up table is associated to $\\nu$ in which each word $w \\in \\mathcal { V }$ is mapped to a vector of $d _ { E }$ real valued features stored in a matrix $\\mathbf { L } \\in \\mathbb { R } ^ { | \\mathcal { V } | * d _ { E } }$ . While this approach has proven successful for a variety of tasks and languages, see for instance Schwenk (2007) in speech recognition and Le et al. (2012); Devlin et al. (2014); Bahdanau et al. (2014) in machine translation, it induces several limitations. ",
+        "bbox": [
+            174,
+            497,
+            825,
+            583
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "For morphologically-rich languages, like Czech or German, the lexical coverage is still an important issue, since there is a combinatorial explosion of word forms, most of which are hardly observed on training data. On the one hand, growing the Look-up table is not a solution, since it would increase the number of parameters without having enough training example for a proper estimation. On the other hand, rare words can be replaced by a special token. Nevertheless, this acts as a word class merging very different words without any distinction and using different word classes to handle outof-vocabulary words Allauzen & Gauvain (2005) does not really solve this issue, since rare words are difficult to classify. ",
+        "bbox": [
+            174,
+            589,
+            825,
+            700
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Moreover, for most inflected or agglutinative forms, as well as for compound words, the word structure is overlooked, wasting parameters for modeling forms that could be more efficiently handled by word decomposition. While the use of subword units Botha & Blunsom (2014); Sennrich et al. (2016) could improve the generalization power of such models, it relies on a proper and efficient method to induce these subword units. ",
+        "bbox": [
+            174,
+            708,
+            823,
+            777
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To overcome these issues, we propose to investigate a word based language model with an open vocabulary. Since most of existing models and training criteria rely on the assumption of a finite vocabulary, the definition of an open vocabulary model, along with a training criterion, constitutes a scientific challenge. Our goal is to build word representations every words. Word representations are inferred on-the-fly from its character sequence, using convolution filters which implicitly capture subword patterns, as described in section 2. The architecture is based on a neural ngram model inspired from Bengio et al. (2003), while this idea can be extended to other kind of models. By relaxing the normalized constraint, the objective function borrows from the noise contrastive estimation Gutmann & Hyvarinen (2012) to allow our model to consider a possibly infinite vocabulary. ¨ This paper focusses on this challenge and its related training issues. To assess the efficiency of this approach, the experimental setup described in section 3 uses a large scale translation task in a reranking setting. The experimental results summarized in section 4 show promising results as well as training issues. ",
+        "bbox": [
+            174,
+            785,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 MODEL DESCRIPTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            165,
+            388,
+            181
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Word embeddings are parameters, stored in a Look-up matrix L. The embedding ${ \\bf e } _ { w } ^ { w o r d }$ of a word $w$ is simply the column of $\\mathbf { L }$ corresponding to its index in the vocabulary: ",
+        "bbox": [
+            173,
+            195,
+            823,
+            224
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f488ae73b7526df5f874ce5c5e1568756047d563a0ad3cf238d22a037d59f1d1.jpg",
+        "text": "$$\n\\mathbf { e } _ { w } ^ { w o r d } = [ \\mathbf { L } ] _ { w }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            450,
+            227,
+            545,
+            246
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 CHARACTER-LEVEL WORD EMBEDDINGS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            260,
+            498,
+            275
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To infer a word embedding from its character embeddings, we use a convolution layer Waibel et al. (1990); Collobert et al. (2011), similar to layers used in Santos & Zadrozny (2014); Kim et al. (2015). As illustrated in figure 1, a word $w$ is a character sequence $\\{ c _ { 1 } , . . , c _ { | w | } \\}$ represented by their embeddings $\\{ \\mathbf { C } _ { c _ { 1 } } , . . , \\mathbf { C } _ { c _ { | w | } } \\}$ , where $\\mathbf { C } _ { c _ { i } }$ denotes the vector associated to the character $c _ { i }$ . A convolution filter $\\mathbf { W } ^ { c o n v } \\in \\mathbb { R } ^ { d _ { e } } \\times \\mathbb { R } ^ { d _ { c } \\ast n _ { c } }$ is applied over a sliding window of $n _ { c }$ characters, producing local features : ",
+        "bbox": [
+            173,
+            285,
+            825,
+            375
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/580a28e2800854e403a8f521685a7818dfeef977cb3f84adc15d545675419ed8.jpg",
+        "text": "$$\nx _ { n } = { \\bf W } ^ { c o n v } ( { \\bf C } _ { c _ { n - n _ { c } + 1 } } : . . : { \\bf C } _ { c _ { n } } ) ^ { T } + { \\bf b } ^ { c o n v }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            348,
+            392,
+            648,
+            412
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $x _ { n }$ is a vector of size $d _ { e }$ obtained for each position $n$ in the word1. The notation $( \\mathbf { C } _ { c _ { n - 1 } } : \\mathbf { C } _ { c _ { n } } )$ denotes the concatenation of two embeddings. The $i$ -th element of the embedding of $w$ is the mean over the $i$ -th elements of the feature vectors, passed by the activation function $\\phi$ : ",
+        "bbox": [
+            174,
+            421,
+            825,
+            464
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a026b7075f1c4a95c3329a8fb9ec6d9165727d78c9e6359ddeada5bb226dd3b4.jpg",
+        "text": "$$\n[ { \\bf e } ^ { c h a r } ] _ { i } = \\phi \\left( \\sum _ { n = 1 } ^ { | w | - n _ { c } + 1 } \\frac { [ { \\bf x } _ { n } ] _ { i } } { | w | - n _ { c } + 1 } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            366,
+            479,
+            630,
+            530
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Using a mean after a sliding convolution window ensures that the embedding combines local features from the whole word, and that the gradient is redistributed at scale for each character $\\mathbf { n }$ -gram. The parameters of the layer are the matrices $\\mathbf { C }$ and ${ \\bf W } ^ { c o n v }$ and the bias $\\mathbf { b } ^ { c o n v }$ . ",
+        "bbox": [
+            174,
+            536,
+            825,
+            579
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 MODELS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            594,
+            277,
+            609
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our model follows the classic $\\mathbf { n }$ -gram feedforward architecture. The input of the network is a $n$ - words context $H _ { i } = ( w _ { i - 1 } , \\dots , w _ { N - i + 1 } )$ , and its output the probability $P ( w | H _ { i } )$ for each word $w \\in \\mathcal V$ . The embeddings of the word in the context are concatenated and fed into a hidden layer: ",
+        "bbox": [
+            174,
+            621,
+            825,
+            662
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1ee2d5bb525cad4df80452ec90013ff481e2ac083b57dc345a7947db7e983ed1.jpg",
+        "text": "$$\n\\mathbf { h } ^ { H _ { i } } = \\phi ( \\mathbf { W } ^ { h i d d e n } ( \\mathbf { e } _ { i - 1 } : . . . : \\mathbf { e } _ { N - i + 1 } ) + \\mathbf { b } ^ { h i d d e n } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            323,
+            665,
+            673,
+            684
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A second hidden layer my be added. Finally, the output layer computes scores for each word: ",
+        "bbox": [
+            169,
+            686,
+            779,
+            702
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/85c461f98598d2b052ca4a83bd103e18ca21be34f1d44ff24445cd47d28c3c51.jpg",
+        "text": "$$\n\\mathbf { s } ^ { H _ { i } } = \\exp \\left( \\mathbf { W } ^ { o u t } \\mathbf { h } ^ { H _ { i } } + \\mathbf { b } ^ { o u t } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            395,
+            703,
+            602,
+            722
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Whidden, $\\mathbf { b } ^ { h i d d e n }$ , ${ \\bf W } ^ { o u t }$ and $\\mathbf { b } ^ { o u t }$ are the parameters of the model. As the input Lookup-matrix $\\mathbf { L }$ , the output weight matrix ${ \\bf W } ^ { o u t }$ contains word embeddings, that are output representations of the words in the vocabulary: ",
+        "bbox": [
+            174,
+            723,
+            826,
+            765
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/df2cd3ee91c0c4411af2dc583df41091cf9279ba3f873cde253620e107e9b9ef.jpg",
+        "text": "$$\n\\mathbf { e } _ { w } ^ { o u t } = [ \\mathbf { W } ^ { o u t } ] _ { w }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            441,
+            762,
+            555,
+            781
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Then, the output probabilities are expressed as: ",
+        "bbox": [
+            174,
+            789,
+            483,
+            804
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/076aa1293aa4817d93aee1292be09653cefe35eb3a59605796e5df93d483d2f3.jpg",
+        "text": "$$\nP ( w | H _ { i } ) = \\frac { \\exp { \\mathbf { e } _ { w } ^ { o u t } } \\mathbf { h } ^ { H _ { i } } } { \\displaystyle \\sum _ { 1 < j < | \\mathcal { V } | } \\exp { \\mathbf { e } _ { j } ^ { o u t } } \\mathbf { h } ^ { H _ { i } } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            385,
+            805,
+            612,
+            853
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Later, we will use three different input layer to obtain word representations: ",
+        "bbox": [
+            173,
+            861,
+            669,
+            877
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/c97618b1879e6c1d79ee353c5f318d490b149538f1805f8146067395a909d2b9.jpg",
+        "image_caption": [
+            "Figure 1: CWE Model architecture "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            102,
+            823,
+            349
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "• A classic NLM using word-level embeddings only, that we will note WE, which uses $| \\nu | *$ $d _ { e }$ parameters.   \n• A NLM using embeddings constructed from character n-grams by convolution $^ +$ pooling, that we will note CE, which uses $| \\mathcal { V } _ { c } | \\ast d _ { c } + d _ { c } \\ast n _ { c } \\ast d _ { e }$ parameters.   \n• A NLM using a concatenation of these two types of embeddings as word representation, that we will note CWE. ",
+        "bbox": [
+            209,
+            397,
+            825,
+            491
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.3 OBJECTIVE FUNCTION FOR OPEN VOCABULARY MODELS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            507,
+            607,
+            522
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Usually, such a model is trained by maximizing the log-likelihood. For a given word given its context, the model parameters $\\theta$ are estimated in order to maximize the following function for all the n-grams observed in the training data: ",
+        "bbox": [
+            173,
+            532,
+            825,
+            575
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/98acedcf8729c907a28ee7ee5080b32187cc7ecbd841e72c8018eaa7ebffb953.jpg",
+        "text": "$$\nL L ( \\theta ) = \\sum _ { 1 < i < | D | } \\log P _ { \\theta } ( w _ { i } | H _ { i } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            387,
+            578,
+            607,
+            616
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "This objective function raises two important issues. For conventional word models, it implies a very costly summation imposed by the softmax activation of the output layer. More importantly, this objective requires the definition of a finite vocabulary, while the proposed model may use characterbased word embeddings, especially at the output, making the notion of vocabulary obsolete. ",
+        "bbox": [
+            173,
+            625,
+            825,
+            681
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Therefore, the parameters estimation relies on Noise Contrastive Estimation (NCE) introduced in Gutmann & Hyvarinen (2012); Mnih & Teh (2012). This criterion allows us to train both types ¨ of models based on conventional word embeddings, along with character-based embeddings. The NCE objective function aims to discriminate between examples sampled from the real data and from a noise distribution. When presented with examples coming from a mixture of one sample from the data distribution $P _ { d }$ and $k$ from the noise distribution $P _ { n }$ , $\\bar { P } ^ { H } ( w \\in \\mathcal { D } )$ denotes the posterior probability of a word $w$ given its context $H$ to be sampled from the training data $\\mathcal { D }$ . This probability can be expressed as follows: ",
+        "bbox": [
+            173,
+            688,
+            825,
+            799
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/23ee454365f1fffd9746f6e737de1b419207506c44d14f8455545cdf6650a5bb.jpg",
+        "text": "$$\nP ^ { H } ( w \\in \\mathcal { D } ) = \\frac { P _ { d } ^ { H } ( w ) } { P _ { d } ^ { H } ( w ) + k P _ { n } ( w ) }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            380,
+            796,
+            617,
+            833
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "As suggested in Mnih & Teh (2012), $P _ { n }$ only depends on $w$ here, since we chose the unigram distribution estimated on the training data. If ",
+        "bbox": [
+            174,
+            834,
+            818,
+            862
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0a5a3e26b0f03ba816b2dd4d77a937166c8be2b10a51bcc82c3d3e8a2e0a2f39.jpg",
+        "text": "$$\ns _ { \\theta } ^ { H } ( w ) = \\exp \\left( \\mathbf { e } ^ { o u t } \\mathbf { h } ^ { H } + \\mathbf { b } ^ { o u t } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            392,
+            866,
+            606,
+            885
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "denotes the non-normalized score given by the model to a specific word $w$ , as a function of the parameters $\\theta$ and the context $H$ , the final NCE objective function has the following form Gutmann ",
+        "bbox": [
+            173,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "& Hyvarinen (2012): ¨ ",
+        "bbox": [
+            174,
+            103,
+            313,
+            118
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3909cb8e9f7a2f49cda3ec5cfa18bf688c0b43535de8d314b3be0155be1601fb.jpg",
+        "text": "$$\nJ _ { \\theta } ^ { H } = E _ { s _ { \\theta } ^ { H } } \\left[ l o g \\frac { s _ { \\theta } ^ { H } ( w ) } { s ^ { H } ( w ) + k P _ { n } ( w ) } \\right] + k E _ { P _ { n } } \\left[ l o g \\frac { k P _ { n } ( w ) } { s _ { \\theta } ^ { H } ( w ) + k P _ { n } ( w ) } \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            264,
+            126,
+            732,
+            162
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $s _ { \\theta } ^ { H }$ will tend to $P _ { d } ^ { H }$ without the need for an explicit normalization. ",
+        "bbox": [
+            176,
+            171,
+            651,
+            186
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.4 CHARACTER-BASED OUTPUT WEIGHTS WITH NOISE-CONTRASTIVE ESTIMATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            204,
+            769,
+            219
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The output weights representing each word in the vocabulary $\\mathbf { e } ^ { o u t }$ can also be replaced by embeddings computed by a convolution layer on character $n$ -grams. In this case the model can efficiently represent and infer a score to any word, observed during the training process or not, while with conventional word embeddings, out of vocabulary words only share the same representation and distribution. Instead of using a parameter matrix ${ \\bf W } ^ { o u t }$ to estimate the score like in equation 2, the output representation of a word $w$ , $\\mathbf { e } _ { w } ^ { o u t }$ can be replaced by a vector $\\mathbf { e } _ { w } ^ { c h a r - o u t }$ estimated on the fly based on its character sequence as described in equation 1, using $| \\mathcal { V } _ { c } | \\ast d _ { c } + d _ { c } \\ast n _ { c } \\ast d _ { h }$ parameters. With this extension the model does not rely on a vocabulary anymore, hence motivating our choice of the NCE. This unnormalized objective allows us to handle an open vocabulary, since we only need to compute $k + 1$ word representations for each training examples. Models that use character-based embeddings both for input and output words are denoted by CWE-CWE. ",
+        "bbox": [
+            173,
+            231,
+            825,
+            383
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Moreover, with this extension, the representations of words sharing character $n$ -grams are tied. This is an important property to let the model generalize to unseen words. However, it can be also an issue: the limited number of updates for output representations $\\boldsymbol { k } + \\boldsymbol { 1 }$ words) has a “rich get richer” effect: the most frequent words are usually short and will get most of the update. They may therefore ”contaminate” the representation of longer words with which they share character $n$ -grams, even if these words are not related. This issue is further addressed in section 4.1. ",
+        "bbox": [
+            174,
+            391,
+            825,
+            474
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 EXPERIMENTAL SET-UP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            496,
+            401,
+            512
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The impact of the models described in section 2 is evaluated within the machine translation (MT) shared task of IWSLT- $2 0 1 6 ^ { 2 }$ from Englih to Czech. This language pair is highly challenging since Czech is a morphologically-rich language. Neural language models are integrated in a two steps approach: the first step uses a conventional MT system to produce an $n$ -best list (the $n$ most likely translations); in the second step, these hypothesis are re-ranked by adding the score of the neural language model. To better benefit from the open vocabulary models introduced in section 2.1, a more complex system is also used: first an MT system is used to translate from English to a simplified form of Czech which is reinflected. With this pipeline we expect $n$ -best lists with more diversity and also words unseen during the training process. The neural language models are then used to re-rank the reinflected $n$ -best lists. ",
+        "bbox": [
+            174,
+            529,
+            825,
+            667
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 DATA ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            685,
+            253,
+            700
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The IWSLT16 MT task is focused on the translation of TED talks. The translation systems are trained on parallel data from the TED, QED and europarl. Our Neural language models are trained on the same data, but training examples are sampled from these corpora given weights that are computed to balance between in-domain parallel data (TED), out-of domain parallel data, and additional monolingual data. Finally, we use the concatenation of TED.dev2010, TED.dev2011 and TED.tst2010 as development set, while TED.tst2012 and TED.tst2013 provide the test set. ",
+        "bbox": [
+            174,
+            713,
+            825,
+            796
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 CZECH RE-INFLECTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            815,
+            379,
+            828
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In Czech, a morphologically rich language, each lemma can take a lot of possible word forms. Most of them won’t appear - or with a very low frequency - in training data. For an important part of the words found in test data and unseen during training, their lemmas however can be observed but with a different morphological derivation. ",
+        "bbox": [
+            176,
+            842,
+            825,
+            897
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "A non-observed word form can’t be generated by the translation system, and one seen too rarely won’t be used in a relevant way. To circumvent this limitation, in a similar fashion as the method described in Marie et al. (2015), each noun, pronoun and adjective is replaced in the training corpora by its lemma along with some morphological features. These word forms are considered in factored way, where some of the POS tags are discarded to reduce the vocabulary. After the translation process, a cascade of Conditional Random Fields (CRF) are used to reintroduce the discarded features, such as gender, number and case, and to generate a new word form. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            200
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Formally, the MT system translates English into a simplified version of Czech, that is reinflected. Within this process, the MT system can produce a $n$ -best list, that can be extended to a $n k$ -best list, considering for each translation hypothesis the $k$ -best reinflected sentences given by the factorized CRF. Intuitively, this process can introduce word forms potentially not yet seen in training data, but based on known paradigms, which can give an advantage to language models able to build a word representation from character $n$ -grams. ",
+        "bbox": [
+            174,
+            208,
+            825,
+            291
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 BASELINE TRANSLATION SYSTEM ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            310,
+            447,
+            324
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Our baseline is built with a Statistical Machine Translation system based on bilingual n-grams, NCODE3, described in Crego et al. (2011). We follow the same setup as in Marie et al. (2015). ",
+        "bbox": [
+            176,
+            337,
+            825,
+            364
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.4 NLM TRAINING AND OPTIMIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            383,
+            467,
+            397
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "First, some comparative experiments on a smaller dataset are carried out to better understand how open vocabulary NLM behave and to set the hyper-parameters. First trained using stochastic gradient descent, we observed a quite unstable training process, restricting a proper hyper-parameters choices. We found that especially the embedding dimensions, and the activation functions used could make the NCE-objective hard to optimize. This was aggravated in Czech, which we found more difficult to work with than other morphologically complex languages, like German and Russian. The use of Adagrad Duchi et al. (2010) clearly helps to solve most of these issues, but adds consequent computation time. Following preliminary results on our work with a similar model on a different task Labeau et al. (2015), we made the choice of not implementing LSTMs to obtain character-level word representations. It gave similar results, at the cost of unstable training and extended computation time. We then train using batches of 128, for various context sizes, WE, CWE, and CWE-CWE models. The ReLu activation function is used, along with an embedding size of $d _ { e } = 1 2 8$ . When relevant, we used a character embedding size of $d _ { c } = 3 2$ and a convolution on $n _ { c } = 5$ -grams of characters for all experiments4. Concerning the NCE training, we sampled $k = 2 5$ examples from the unigram distribution obtained from the training data, for each example sampled from the data. The models were implemented using $C { + + } ^ { 5 }$ . ",
+        "bbox": [
+            174,
+            410,
+            825,
+            631
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.5 RERANKING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            650,
+            302,
+            664
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The re-ranking step uses additional features to find a better translation among the $n$ -best generated by the decoder (in our case, $n = 3 0 0$ ): we use the score (probability) of WE, CWE and CWECWE models given to each sentence by our models as such a feature. Tuning for re-ranking was performed with KB-MIRA Cherry & Foster (2012), and evaluation using BLEU score. ",
+        "bbox": [
+            174,
+            678,
+            825,
+            733
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            756,
+            415,
+            770
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The first set of experiments investigates the impact of the padding design on the character-level representation followed by a study of the learning behavior of our proposed models and training criterion. Then, the proposed models are evaluated within the MT task. The final set of experiments analyzes the issues of the model based on character-level representation for output words, in order to propose remedies. ",
+        "bbox": [
+            174,
+            787,
+            825,
+            857
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Preliminary results on smaller dataset are quite poor for models using character-level representation, and far worse when used for the output layer. We suspect that groups of characters are updated far more together, yielding a ”contamination” of several character n-grams by very frequent short words. ",
+        "bbox": [
+            176,
+            128,
+            823,
+            171
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Indeed, our simple padding scheme, as shown in the left part of table 1, makes words sharing first or last letter(s) systematically share at least one character n-gram: we suppose it gives the models more chance to detect similarities in word forms sharing prefixes and suffixes. ",
+        "bbox": [
+            174,
+            178,
+            823,
+            220
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The representations of any of the character n-grams that are included in the frequent words will thus be re-used in a large part of the other words in the corpus. A huge number of word forms are affected: a little more than one third of the training data shares its first character n-gram with one of the ten most frequent words, and a little more than one quarter shares its last. ",
+        "bbox": [
+            174,
+            228,
+            825,
+            284
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "While considering varying size of character n-grams when building our word representation, as in Kim et al. (2015), would certainly help, it would increase our computation time. We thus choose to alleviate our padding scheme, as shown on the right part of table 1. We add only one character token at the beginning of the word, and one at the end6. While it may inhibit the capacity of the model to build links between words sharing prefixes or suffixes, it improves results drastically, especially when using character-level outputs, as shown in figure 3. This limited padding scheme is used for the following experiments. ",
+        "bbox": [
+            173,
+            290,
+            825,
+            388
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/a73b6aecec763b96d3061b27d785bcd8015f9535c921373f3148b6b5190f754d.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>。。。。a·…</td><td colspan=\"2\">ooa..</td></tr><tr><td>ooooa oooon e</td><td>oale. a.</td><td>oona.</td></tr><tr><td>ooooa OOOON by oooobyl</td><td>oaby·</td><td>ooza.</td></tr><tr><td>ooooa 之</td><td>a ooax.</td><td>obyla.</td></tr><tr><td>ooooa1 ni.... oooodva..</td><td>oani.</td><td>odua.</td></tr><tr><td>ooooa si....</td><td>ooootreba. oasi. 1</td><td>otreba.</td></tr></table>",
+        "bbox": [
+            256,
+            400,
+            741,
+            500
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Padding for word decomposition in character 5-grams: $\\circ$ is a character token indicating the beginning of the word, while $\\bullet$ indicates the end of the word. The left part of the table shows our original padding scheme, which makes very different words share character 5-grams, especially with short, frequent words. The right part of the table shows our alleviated padding scheme. ",
+        "bbox": [
+            176,
+            510,
+            823,
+            566
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 NLM TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            598,
+            326,
+            613
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "While the perplexity of our language models is not our main focus, it is still related to the quantity that our training seeks to optimize - since the NCE gradient approaches the maximum likelihood gradient Mnih & Teh (2012). On figure 2 are shown perplexity values of each model during training. These values are based on a vocabulary containing the 250K most frequent words on the training data - it is also the vocabulary used in the model when relevant. They are computed on the development set after each epoch. An epoch includes 2,5M N-grams sampled from the training data. On table 2 are shown the best perplexity obtained on the development set by each model, during training. ",
+        "bbox": [
+            173,
+            623,
+            825,
+            722
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/96bbc9fe365b09891b1c5f3ae1271173efba623e2fe1465e46edec7aa3675795.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Context size (Number of words)</td><td>3</td><td>6</td></tr><tr><td>WE</td><td>227</td><td>193</td></tr><tr><td>CWE</td><td>207</td><td>185</td></tr><tr><td>CWE-CWE</td><td>308</td><td>243</td></tr></table>",
+        "bbox": [
+            334,
+            733,
+            658,
+            806
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 2: Best perplexity reached on the development set, on a 250K output vocabulary, after 15 epochs of 2,5M n-grams ",
+        "bbox": [
+            171,
+            815,
+            823,
+            844
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 2 shows that a character-level word representation helps to decrease the perplexity, even if a larger context closes the gap. To compute the perplexity of CWE-CWE models, we use the ",
+        "bbox": [
+            173,
+            859,
+            823,
+            888
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/3a5686341336b59a9a5a825ca16f0f0be913bb92ab7d17c7401a2c58f012c387.jpg",
+        "image_caption": [
+            "Figure 2 "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            207,
+            103,
+            495,
+            279
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/0f74ca992fbde46fe5b89e9daa8be833f234890e05ebd3910bb474a6ebabce35.jpg",
+        "image_caption": [
+            "Figure 3 "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            504,
+            104,
+            789,
+            279
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Figure 4: Model perplexity measured on the development set during training. The context size is 3 words. Figure 3 shows models based on character-level word representations, with and without complete padding. Models are trained on the same data than Figure 2 but on smaller epochs (250K n-grams). ",
+        "bbox": [
+            173,
+            319,
+            825,
+            375
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "same vocabulary as for other models, and use the ’unknown’ tokens for words and characters-based representations. Hence, the perplexity computed is difficult to interpret. The main downside of Adagrad is that the learning rate determined by accumulating the history of past gradients is usually too aggressive and stops learning rather early. We simply reset this history every five epochs to give the model a chance to improve, which explains the flattening followed by small improvements we see for WE and CWE models. We choose to do that reset 2 times, based on previous experiments. Despite adaptive gradient, training of CWE-CWE models stays unstable. ",
+        "bbox": [
+            174,
+            409,
+            825,
+            507
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 RERANKING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            531,
+            302,
+            545
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/9ab9b838867e4b3a330487b04103b4485574e2e9bf807714a83245550a378db5.jpg",
+        "table_caption": [
+            "Table 3: Best BLEU score obtained after n-best reranking of the hypothesis given by the translation and translation $+ \\mathrm { k }$ -best reinflection systems. $n$ is the context size (in number of words) "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td rowspan=\"2\">System to be re-ranked</td><td rowspan=\"2\">BLEU Reference</td><td colspan=\"2\">CWE</td><td colspan=\"2\">CWE-CWE</td><td colspan=\"2\">WE</td></tr><tr><td>n=3</td><td>n=6</td><td>n=3</td><td>n=6</td><td>n=3</td><td>n=6</td></tr><tr><td>En→Cz</td><td>Baseline system</td><td>19.6</td><td>20.1</td><td>20.3</td><td>19.8</td><td>20.0</td><td>20.0</td><td>20.2</td></tr><tr><td rowspan=\"3\">En → Simplified Cz</td><td>Reinflected baseline system</td><td rowspan=\"3\">19.5</td><td>20.0</td><td>20.2</td><td>19.6</td><td>20.1</td><td>20.1</td><td>20.0</td></tr><tr><td>3-best Reinflected baseline system</td><td>19.9</td><td>20.3</td><td>19.6</td><td>20.0</td><td>20.1</td><td>20.1</td></tr><tr><td>5-best Reinflected baseline system</td><td>19.9</td><td>20.3</td><td>19.5</td><td>19.9</td><td>20.0</td><td>20.1</td></tr></table>",
+        "bbox": [
+            173,
+            570,
+            823,
+            659
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The reranking results are shown in table 3. The first line corresponds to experiments with a direct translation from English to Czech, where $n$ -best lists generated by the MT system are simply rescored by our models. The best result is given by the longest-context CWE model, which produces a $\\mathbf { + 0 . 7 }$ BLEU score improvement. CWE models gives on average $+ 0 . 1$ BLEU point compared to WE models, while CWE-CWE are $- 0 . 2$ BLEU point under. Doubling the context size consistently improves results of $+ 0 . 2$ BLEU point. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            805
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Experimental results on reinflected Czech seems to follow a similar trend: CWE models behave a little better than WE models, while CWE-CWE models are under. While simply reranking $n$ -best lists is not as efficient as doing it directly in Czech, reranking $n k$ -best lists extended by the factorized CRF gives a small improvement, reaching an improvement of $\\mathbf { + 0 . 7 }$ BLEU point. As a general rule, small context models seem to have difficulties with reinflected Czech. The main advantage given by the CWE model is an ability to better rerank $n k$ -best lists. These results suggest that, while the normalization $^ +$ reinflection procedure may introduce diversity in the output to be reranked, our models are not able to draw any significant advantage from it. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.4 ANALYSIS OF CHARACTER-LEVEL OUTPUT REPRESENTATIONS PERFORMANCE ",
+        "text_level": 1,
+        "bbox": [
+            183,
+            104,
+            746,
+            117
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Models using character-level output representations gave sub-par results on re-ranking. It is surprising, especially for re-inflected Czech: such a model is supposed to behave better on unknown words, and thus should benefit from diversity given by generating new words. However, as we can see in table 4, re-inflection doesn’t add that much diversity (About $0 . 1 ~ \\%$ of OOV words, and about $0 . 0 0 1 \\%$ of words never seen by the model before). Diversity is also inhibited by our training algorithm: while we train open-vocabulary models, the negative examples used with Noise-contrastive estimation come from a closed vocabulary. ",
+        "bbox": [
+            173,
+            132,
+            825,
+            231
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/92632d7e59a3a677ffee754d9fb20413ca0310ff579eb3c403d29f2654ae26af.jpg",
+        "table_caption": [
+            "Table 4: Ratio of unknown words in system outputs measured on the test set. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Full training vocabulary</td><td>250K words vocabulary</td></tr><tr><td>Reference</td><td>0.131 %</td><td>0.995 %</td></tr><tr><td>En → Cz (300-best)</td><td>0.566 %</td><td>1.173 %</td></tr><tr><td>En→ Simplified Cz + Reinflection</td><td>0.567 %</td><td>1.263 %</td></tr><tr><td>En→Simplified Cz + 3-Best reinflection</td><td>0.567 %</td><td>1.277 %</td></tr><tr><td>En→ Simplified Cz + 5-Best reinflection</td><td>0.568 %</td><td>1.285 %</td></tr></table>",
+        "bbox": [
+            174,
+            248,
+            823,
+            367
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "This can related to the nature of the unigram distribution used to sample negative examples. As explained in section 4.1, it makes frequent short words completely outweigh the others in number of updates, and we are forced to reduce the ability of the model to find common morphological attributes between words to avoid ’contamination’ of character n-gram representations. ",
+        "bbox": [
+            174,
+            414,
+            825,
+            469
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 RELATED WORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            497,
+            354,
+            513
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "There is a number of different strategies to efficiently train NNLMs with large vocabularies, such as different types of hierarchical softmax Mnih & Hinton (2009); Le et al. (2011), importance sampling Bengio & Sen´ ecal (2003), and Noise contrastive estimation Gutmann & Hyv ´ arinen (2012); Mnih & ¨ Teh (2012). Vaswani et al. (2013) has showed the interest of training a NLM with NCE to re-rank $k$ -best lists, while Devlin et al. (2014) uses a self-normalization. Recently, a comparative study Chen et al. (2016) has been made on how to deal with a large vocabulary. However, the purpose of this paper is to explore models with open vocabulary rather large vocabulary. ",
+        "bbox": [
+            174,
+            532,
+            825,
+            631
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "There is a surge of interest into using character-level information for a wide range of NLP tasks, with improved results in POS Tagging Santos & Zadrozny (2014), Text classification Zhang & LeCun (2015), Parsing Ballesteros et al. (2015), Named entity recognition Lample et al. (2016). ",
+        "bbox": [
+            174,
+            637,
+            825,
+            680
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In language modeling, first applications to language modeling were strictly using characters, and performed less than word-level models Mikolov et al. (2012), while showing impressive results for text generation Sutskever et al. (2011); Graves (2013), using bi-directional LSTM Graves et al. (2013). Recently, Ling et al. (2015) has used bi-directional LSTM to build word representations from characters, with improvements in language modeling and POS-tagging. ",
+        "bbox": [
+            174,
+            686,
+            825,
+            756
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The recent work of Kim et al. (2015), that uses convolutional networks and pooling to construct a word representation from character n-grams, coupled with highway networks Srivastava et al. (2015), showed on various languages that using characters improves results on the language modeling task (for a small corpus), even more so for languages with complex morphology. A similar architecture was used Jozefowicz et al. (2016) on a larger dataset, conjointly with bi-directional ´ LSTMs, and trained with importance sampling, showing great results. ",
+        "bbox": [
+            174,
+            762,
+            825,
+            847
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "On the study of NNLMs in the context of Machine Translation, we can mention the work of Luong et al. (2015) on the effect of the number of layers on reranking $n$ -best lists. Finally, while not directly related to our work, Luong & Manning (2016) very recently showed great improvements on a translation task by handling rare words with character-level recurrent networks, with a neural translation model. ",
+        "bbox": [
+            174,
+            853,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            318,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this work, we addressed the challenge of designing an open vocabulary Neural Language Model. For that purpose, word representations are estimated on-the-fly from n-grams of characters. Two kinds of models are introduced: first, NLMs using word and character-level embeddings to represent the input context (CWE); then its extension to an open-vocabulary even for the predicted words (CWE-CWE). These models were used to re-rank outputs of translation systems from English to Czech. We also carried out experiments on translation systems from English to a simplified Czech, which is then re-inflected into Czech before re-ranking. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            231
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We obtained a slight improvement in BLEU score using a CWE model, which, given the little variety of the words generated by translation systems, makes us suppose there is room for more. We plan to investigate with more complex translation systems, as well as with other applications, such as morphological re-inflection. ",
+        "bbox": [
+            176,
+            238,
+            825,
+            294
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "While the performance of our open-vocabulary models are to some extent disappointing, they open questions about the learned representations we will explore. We also plan to investigate on a more fitted noise distribution to use with NCE when training open-vocabulary models. ",
+        "bbox": [
+            176,
+            301,
+            825,
+            343
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            359,
+            326,
+            373
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            386,
+            285,
+            401
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "A. Allauzen and J.L Gauvain. Open vocabulary asr for audiovisual document indexation. In IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), April 2005. ",
+        "bbox": [
+            174,
+            410,
+            823,
+            438
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. CoRR, abs/1409.0473, 2014. ",
+        "bbox": [
+            174,
+            448,
+            821,
+            477
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Miguel Ballesteros, Chris Dyer, and Noah A. Smith. Improved transition-based parsing by modeling characters instead of words with lstms. In Llus Mrquez, Chris Callison-Burch, Jian Su, Daniele Pighin, and Yuval Marton (eds.), EMNLP, pp. 349–359. The Association for Computational Linguistics, 2015. ISBN 978-1-941643-32-7. URL http://dblp.uni-trier.de/ db/conf/emnlp/emnlp2015.html#BallesterosDS15. ",
+        "bbox": [
+            173,
+            487,
+            825,
+            558
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yoshua Bengio and Jean-Sebastien S ´ en´ ecal. Quick training of probabilistic neural nets by impor- ´ tance sampling. In Proceedings of the conference on Artificial Intelligence and Statistics (AISTATS), 2003. ",
+        "bbox": [
+            176,
+            566,
+            821,
+            609
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yoshua Bengio, Rejean Ducharme, Pascal Vincent, and Christian Jauvin. A neural probabilistic ´ language model. Journal of Machine Learning Research, 3:1137 1155, 2003. ",
+        "bbox": [
+            173,
+            618,
+            821,
+            648
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jan A. Botha and Phil Blunsom. Compositional Morphology for Word Representations and Language Modelling. In Proceedings of the International Conference of Machine Learning (ICML), Beijing, China, jun 2014. ",
+        "bbox": [
+            173,
+            657,
+            825,
+            700
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Wenlin Chen, David Grangier, and Michael Auli. Strategies for training large vocabulary neural language models. In Proceedings of the 54th Annual Meeting of the Association for Computational Linguistics, ACL 2016, August 7-12, 2016, Berlin, Germany, Volume 1: Long Papers, 2016. URL http://aclweb.org/anthology/P/P16/P16-1186.pdf. ",
+        "bbox": [
+            174,
+            709,
+            825,
+            767
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Colin Cherry and George Foster. Batch tuning strategies for statistical machine translation. In Proceedings of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies (NAACL-HLT), pp. 427–436, Montreal, Canada, June 2012. ´ ",
+        "bbox": [
+            176,
+            776,
+            823,
+            820
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ronan Collobert, Jason Weston, Leon Bottou, Michael Karlen, Koray Kavukcuoglu, and Pavel ´ Kuksa. Natural language processing (almost) from scratch. J. Mach. Learn. Res., 12:2493– 2537, November 2011. ISSN 1532-4435. URL http://dl.acm.org/citation.cfm? id=1953048.2078186. ",
+        "bbox": [
+            173,
+            829,
+            825,
+            886
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Josep Maria Crego, Franois Yvon, and Jos B. Marino. N-code: an open-source Bilingual N-gram ˜ SMT Toolkit. Prague Bulletin of Mathematical Linguistics, 96:49–58, 2011. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jacob Devlin, Rabih Zbib, Zhongqiang Huang, Thomas Lamar, Richard M. Schwartz, and John Makhoul. Fast and robust neural network joint models for statistical machine translation. In Proceedings of the 52nd Annual Meeting of the Association for Computational Linguistics, ACL 2014, June 22-27, 2014, Baltimore, MD, USA, Volume 1: Long Papers, pp. 1370–1380, 2014. URL http://aclweb.org/anthology/P/P14/P14-1129.pdf. ",
+        "bbox": [
+            174,
+            103,
+            826,
+            174
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "John Duchi, Elad Hazan, and Yoram Singer. Adaptive subgradient methods for online learning and stochastic optimization. Technical Report UCB/EECS-2010-24, EECS Department, University of California, Berkeley, Mar 2010. URL http://www2.eecs.berkeley.edu/Pubs/ TechRpts/2010/EECS-2010-24.html. ",
+        "bbox": [
+            173,
+            181,
+            825,
+            238
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alex Graves. Generating sequences with recurrent neural networks. CoRR, abs/1308.0850, 2013. URL http://arxiv.org/abs/1308.0850. ",
+        "bbox": [
+            174,
+            246,
+            820,
+            275
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alex Graves, Navdeep Jaitly, and Abdel-rahman Mohamed. Hybrid speech recognition with deep bidirectional LSTM. In 2013 IEEE Workshop on Automatic Speech Recognition and Understanding, Olomouc, Czech Republic, December 8-12, 2013, pp. 273–278, 2013. doi: 10.1109/ASRU. 2013.6707742. URL http://dx.doi.org/10.1109/ASRU.2013.6707742. ",
+        "bbox": [
+            174,
+            281,
+            825,
+            338
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Michael U. Gutmann and Aapo Hyvarinen. Noise-contrastive estimation of unnormalized statistical ¨ models, with applications to natural image statistics. J. Mach. Learn. Res., 13(1):307–361, February 2012. ISSN 1532-4435. URL http://dl.acm.org/citation.cfm?id $\\underline { { \\underline { { \\mathbf { \\Pi } } } } } =$ 2503308. 2188396. ",
+        "bbox": [
+            173,
+            345,
+            825,
+            402
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Rafal Jozefowicz, Oriol Vinyals, Mike Schuster, Noam Shazeer, and Yonghui Wu. Exploring the ´ limits of language modeling. CoRR, abs/1602.02410, 2016. URL http://arxiv.org/abs/ 1602.02410. ",
+        "bbox": [
+            173,
+            410,
+            825,
+            453
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yoon Kim, Yacine Jernite, David Sontag, and Alexander M Rush. Character-aware neural language models. arXiv preprint arXiv:1508.06615, 2015. ",
+        "bbox": [
+            174,
+            460,
+            825,
+            489
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Matthieu Labeau, Kevin Loser, and Alexandre Allauzen. Non-lexical neural architecture for fine- ¨ grained pos tagging. In Proceedings of the Conference on Empirical Methods in Natural Language Processing (EMNLP), pp. 232–237, Lisbon, Portugal, September 2015. ",
+        "bbox": [
+            173,
+            496,
+            825,
+            540
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Guillaume Lample, Miguel Ballesteros, Kazuya Kawakami, Sandeep Subramanian, and Chris Dyer. Neural architectures for named entity recognition. In In proceedings of NAACL-HLT (NAACL 2016)., San Diego, US, 2016. ",
+        "bbox": [
+            174,
+            546,
+            823,
+            589
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hai Son Le, Ilya Oparin, Alexandre Allauzen, Jean-Luc Gauvain, and Franc¸ois Yvon. Structured output layer neural network language model. In Proceedings of the IEEE International Conference on Acoustics, Speech, and Signal Processing, ICASSP 2011, May 22-27, 2011, Prague Congress Center, Prague, Czech Republic, pp. 5524–5527, 2011. doi: 10.1109/ICASSP.2011. 5947610. URL http://dx.doi.org/10.1109/ICASSP.2011.5947610. ",
+        "bbox": [
+            173,
+            597,
+            825,
+            667
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hai-Son Le, Alexandre Allauzen, and Franc¸ois Yvon. Continuous space translation models with neural networks. In Proceedings of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies (NAACL-HLT), pp. 39–48, Montreal, Canada, ´ June 2012. Association for Computational Linguistics. ",
+        "bbox": [
+            173,
+            675,
+            825,
+            731
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Wang Ling, Chris Dyer, Alan W. Black, Isabel Trancoso, Ramon Fermandez, Silvio Amir, Lus Marujo, and Tiago Lus. Finding function in form: Compositional character models for open vocabulary word representation. In EMNLP, pp. 1520–1530. The Association for Computational Linguistics, 2015. ISBN 978-1-941643-32-7. URL http://dblp.uni-trier.de/db/ conf/emnlp/emnlp2015.html#LingDBTFAML15. ",
+        "bbox": [
+            173,
+            739,
+            825,
+            810
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Minh-Thang Luong and Christopher D. Manning. Achieving open vocabulary neural machine translation with hybrid word-character models. CoRR, abs/1604.00788, 2016. URL http: //arxiv.org/abs/1604.00788. ",
+        "bbox": [
+            173,
+            818,
+            821,
+            859
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Thang Luong, Michael Kayser, and Christopher D. Manning. Deep neural language models for machine translation. In Proceedings of the 19th Conference on Computational Natural Language Learning, CoNLL 2015, Beijing, China, July 30-31, 2015, pp. 305–309, 2015. URL http: //aclweb.org/anthology/K/K15/K15-1031.pdf. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Benjamin Marie, Alexandre Allauzen, Franck Burlot, Quoc-Khanh Do, Julia Ive, elena knyazeva, Matthieu Labeau, Thomas Lavergne, Kevin Loser, Nicolas P ¨ echeux, and Franc¸ois Yvon. ´ Limsi@wmt’15 : Translation task. In Proceedings of the Tenth Workshop on Statistical Machine Translation, pp. 145–151, Lisbon, Portugal, September 2015. Association for Computational Linguistics. URL http://aclweb.org/anthology/W15-3016. ",
+        "bbox": [
+            176,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tomas Mikolov, Ilya Sutskever, Anoop Deoras, Hai-Son Le, Stefan Kombrink, and Jan Cernocky. Subword language modeling with neural networks. 2012. Unpublished. ",
+        "bbox": [
+            174,
+            183,
+            821,
+            212
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Andriy Mnih and Geoffrey Hinton. A scalable hierarchical distributed language model. In Advances in Neural Information Processing Systems, volume 21, pp. 1081–1088, 2009. ",
+        "bbox": [
+            173,
+            219,
+            821,
+            250
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Andriy Mnih and Yee Whye Teh. A fast and simple algorithm for training neural probabilistic language models. In ICML. icml.cc / Omnipress, 2012. URL http://dblp.uni-trier. de/db/conf/icml/icml2012.html#MnihT12. ",
+        "bbox": [
+            174,
+            257,
+            821,
+            301
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Cicero D. Santos and Bianca Zadrozny. Learning character-level representations for part-of-speech tagging. In Tony Jebara and Eric P. Xing (eds.), Proceedings of the 31st International Conference on Machine Learning (ICML-14), pp. 1818–1826. JMLR Workshop and Conference Proceedings, 2014. URL http://jmlr.org/proceedings/papers/v32/santos14.pdf. ",
+        "bbox": [
+            173,
+            309,
+            826,
+            366
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Holger Schwenk. Continuous space language models. Computer Speech and Language, 21(3): 492–518, July 2007. ",
+        "bbox": [
+            173,
+            375,
+            820,
+            404
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Rico Sennrich, Barry Haddow, and Alexandra Birch. Neural machine translation of rare words with subword units. In Proceedings of the Annual Meeting on Association for Computational Linguistics (ACL), pp. 1715–1725, Berlin, Germany, August 2016. ",
+        "bbox": [
+            173,
+            412,
+            821,
+            455
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Rupesh Kumar Srivastava, Klaus Greff, and Jurgen Schmidhuber. Training very deep networks. ¨ CoRR, abs/1507.06228, 2015. URL http://arxiv.org/abs/1507.06228. ",
+        "bbox": [
+            171,
+            463,
+            823,
+            494
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ilya Sutskever, James Martens, and Geoffrey Hinton. Generating text with recurrent neural networks. In Lise Getoor and Tobias Scheffer (eds.), Proceedings of the 28th International Conference on Machine Learning (ICML-11), ICML ’11, pp. 1017–1024, New York, NY, USA, June 2011. ACM. ",
+        "bbox": [
+            173,
+            502,
+            825,
+            558
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ashish Vaswani, Yinggong Zhao, Victoria Fossum, and David Chiang. Decoding with large-scale neural language models improves translation. In EMNLP, pp. 1387–1392. ACL, 2013. ISBN 978- 1-937284-97-8. URL http://dblp.uni-trier.de/db/conf/emnlp/emnlp2013. html#VaswaniZFC13. ",
+        "bbox": [
+            174,
+            568,
+            825,
+            623
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alexander Waibel, Toshiyuki Hanazawa, Geofrey Hinton, Kiyohiro Shikano, and Kevin J. Lang. Readings in Speech Recognition, chapter Phoneme Recognition Using Time-delay Neural Networks, pp. 393–404. Morgan Kaufmann Publishers Inc., San Francisco, CA, USA, 1990. ",
+        "bbox": [
+            174,
+            632,
+            825,
+            676
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xiang Zhang and Yann LeCun. Text understanding from scratch. CoRR, abs/1502.01710, 2015. URL http://arxiv.org/abs/1502.01710. ",
+        "bbox": [
+            176,
+            685,
+            821,
+            713
+        ],
+        "page_idx": 10
+    }
+]