Add files using upload-large-folder tool

parse/train/8VXvj1QNRl1/8VXvj1QNRl1.md

@@ -0,0 +1,320 @@
+# ON THE TRANSFER OF DISENTANGLED REPRESENTA-TIONS IN REALISTIC SETTINGS
+
+Andrea Dittadi,∗†1 Frederik Trauble, ¨ ∗2 Francesco Locatello,2,3 Manuel Wuthrich, ¨ 2   
+Vaibhav Agrawal,2 Ole Winther,1,4,5 Stefan Bauer,2,6 Bernhard Scholkopf ¨ 2   
+1Technical University of Denmark, $^ { 2 } \mathrm { M a x }$ Planck Institute for Intelligent Systems,   
+3ETH Zurich, Department for Computer Science, 4Copenhagen University Hospital,   
+5University of Copenhagen , 6CIFAR Azrieli Global Scholar
+
+# ABSTRACT
+
+Learning meaningful representations that disentangle the underlying structure of the data generating process is considered to be of key importance in machine learning. While disentangled representations were found to be useful for diverse tasks such as abstract reasoning and fair classification, their scalability and real-world impact remain questionable. We introduce a new high-resolution dataset with 1M simulated images and over 1,800 annotated real-world images of the same setup. In contrast to previous work, this new dataset exhibits correlations, a complex underlying structure, and allows to evaluate transfer to unseen simulated and realworld settings where the encoder i) remains in distribution or ii) is out of distribution. We propose new architectures in order to scale disentangled representation learning to realistic high-resolution settings and conduct a large-scale empirical study of disentangled representations on this dataset. We observe that disentanglement is a good predictor for out-of-distribution (OOD) task performance.
+
+# 1 INTRODUCTION
+
+Disentangled representations hold the promise of generalization to unseen scenarios (Higgins et al., 2017b), increased interpretability (Adel et al., 2018; Higgins et al., 2018) and faster learning on downstream tasks (van Steenkiste et al., 2019; Locatello et al., 2019a). However, most of the focus in learning disentangled representations has been on small synthetic datasets whose ground truth factors exhibit perfect independence by design. More realistic settings remain largely unexplored. We hypothesize that this is because real-world scenarios present several challenges that have not been extensively studied to date. Important challenges are scaling (much higher resolution in observations and factors), occlusions, and
+
+![](images/c6fb806d6fc458286d4260c0ce63df72991b62a25f144d6895ab501cd4cced79.jpg)  
+Figure 1: Images from the simulated dataset (left) and from the real-world setup (right).
+
+correlation between factors. Consider, for instance, a robotic arm moving a cube: Here, the robot arm can occlude parts of the cube, and its end-effector position exhibits correlations with the cube’s position and orientation, which might be problematic for common disentanglement learners (Trauble ¨ et al., 2020). Another difficulty is that we typically have only limited access to ground truth labels in the real world, which requires robust frameworks for model selection when no or only weak labels are available.
+
+The goal of this work is to provide a path towards disentangled representation learning in realistic settings. First, we argue that this requires a new dataset that captures the challenges mentioned above. We propose a dataset consisting of simulated observations from a scene where a robotic arm interacts with a cube in a stage (see Fig. 1). This setting exhibits correlations and occlusions that are typical in real-world robotics. Second, we show how to scale the architecture of disentanglement methods to perform well on this dataset. Third, we extensively analyze the usefulness of disentangled representations in terms of out-of-distribution downstream generalization, both in terms of held-out factors of variation and sim2real transfer. In fact, our dataset is based on the TriFinger robot from Wuthrich et al. (2020), which can be built to test the deployment of models in the real ¨ world. While the analysis in this paper focuses on the transfer and generalization of predictive models, we hope that our dataset may serve as a benchmark to explore the usefulness of disentangled representations in real-world control tasks.
+
+The contributions of this paper can be summarized as follows:
+
+• We propose a new dataset for disentangled representation learning, containing 1M simulated high-resolution images from a robotic setup, with seven partly correlated factors of variation. Additionally, we provide a dataset of over 1,800 annotated images from the corresponding real-world setup that can be used for challenging sim2real transfer tasks. These datasets are made publicly available.1   
+We propose a new neural architecture to successfully scale VAE-based disentanglement learning approaches to complex datasets.   
+• We conduct a large-scale empirical study on generalization to various transfer scenarios on this challenging dataset. We train 1,080 models using state-of-the-art disentanglement methods and discover that disentanglement is a good predictor for out-of-distribution (OOD) performance of downstream tasks.
+
+# 2 RELATED WORK
+
+Disentanglement methods. Most state-of-the-art disentangled representation learning approaches are based on the framework of variational autoencoders (VAEs) (Kingma & Welling, 2014; Rezende et al., 2014). A (high-dimensional) observation $_ { \textbf { \em x } }$ is assumed to be generated according to the latent variable model $p _ { \theta } ( \pmb { x } | \pmb { z } ) p ( \pmb { z } )$ where the latent variables $_ { z }$ have a fixed prior $p ( z )$ . The generative model $p _ { \theta } ( { \pmb x } | { \pmb z } )$ and the approximate posterior distribution $q _ { \phi } ( \pmb { z } | \pmb { x } )$ are typically parameterized by neural networks, which are optimized by maximizing the evidence lower bound (ELBO):
+
+$$
+\mathcal { L } _ { V A E } = \mathbb { E } _ { q _ { \phi } ( z | x ) } [ \log p _ { \theta } ( \pmb { x } | z ) ] - D _ { \mathrm { K L } } ( q _ { \phi } ( z | \pmb { x } ) | | p ( z ) ) \le \log p ( \pmb { x } )
+$$
+
+As the above objective does not enforce any structure on the latent space except for some similarity to $p ( z )$ , different regularization strategies have been proposed, along with evaluation metrics to gauge the disentanglement of the learned representations (Higgins et al., $2 0 1 7 \mathrm { a }$ ; Kim & Mnih, 2018; Burgess et al., 2018; Kumar et al., 2018; Chen et al., 2018; Eastwood & Williams, 2018). Recently, Locatello et al. (2019b, Theorem 1) showed that the purely unsupervised learning of disentangled representations is impossible. This limitation can be overcome without the need for explicitly labeled data by introducing weak labels (Locatello et al., 2020; Shu et al., 2019). Ideas related to disentangling the factors of variation date back to the non-linear ICA literature (Comon, 1994; Hyvarinen & Pajunen, 1999; Bach & Jordan, 2002; Jutten & Karhunen, 2003; Hyvarinen & ¨ Morioka, 2016; Hyvarinen et al., 2019; Gresele et al., 2019). Recent work combines non-linear ICA with disentanglement (Khemakhem et al., 2020; Sorrenson et al., 2020; Klindt et al., 2020).
+
+Evaluating disentangled representations. The BetaVAE (Higgins et al., 2017a) and FactorVAE (Kim & Mnih, 2018) scores measure disentanglement by performing an intervention on the factors of variation and predicting which factor was intervened on. The Mutual Information Gap (MIG) (Chen et al., 2018), Modularity (Ridgeway & Mozer, 2018), DCI Disentanglement (Eastwood & Williams, 2018) and SAP scores (Kumar et al., 2018) are based on matrices relating factors of variation and codes (e.g. pairwise mutual information, feature importance and predictability).
+
+Datasets for disentanglement learning. dSprites (Higgins et al., 2017a), which consists of binary low-resolution 2D images of basic shapes, is one of the most commonly used synthetic datasets for disentanglement learning. Color-dSprites, Noisy-dSprites, and Scream-dSprites are slightly more challenging variants of dSprites. The SmallNORB dataset contains toy images rendered under different lighting conditions, elevations and azimuths (LeCun et al., 2004). Cars3D (Reed et al., 2015) exhibits different car models from Fidler et al. (2012) under different camera viewpoints. 3dshapes is a popular dataset of simple shapes in a 3D scene (Kim & Mnih, 2018). Finally, Gondal et al. (2019) proposed MPI3D, containing images of physical 3D objects with seven factors of variation, such as object color, shape, size and position available in a simulated, simulated and highly realistic rendered simulated variant. Except MPI3D which has over 1M images, the size of the other datasets is limited with only 17, 568 to 737, 280 images. All of the above datasets exhibit perfect independence of all factors, the number of possible states is on the order of 1M or less, and due to their static setting they do not allow for dynamic downstream tasks such as reinforcement learning. In addition, except for SmallNORB, the image resolution is limited to 64x64 and there are no occlusions.
+
+Other related work. Locatello et al. (2020) probed the out-of-distribution generalization of downstream tasks trained on disentangled representations. However, these representations are trained on the entire dataset. Generalization and transfer performance especially for representation learning has likewise been studied in Dayan (1993); Muandet et al. (2013); Heinze-Deml & Meinshausen (2017); Rojas-Carulla et al. (2018); Suter et al. (2019); Li et al. (2018); Arjovsky et al. (2019); Krueger et al. (2020); Gowal et al. (2020). For the role of disentanglement in causal representation learning we refer to the recent overview by Scholkopf et al. (2021). Tr ¨ auble et al. (2020) systematically investi- ¨ gated the effects of correlations between factors of variation on disentangled representation learners. Transfer of learned disentangled representations from simulation to the real world has been recently investigated by Gondal et al. (2019) on the MPI3D dataset, and previously by Higgins et al. (2017b) in the context of reinforcement learning. Sim2real transfer is of major interest in the robotic learning community, because of limited data and supervision in the real world (Tobin et al., 2017; Rusu et al., 2017; Peng et al., 2018; James et al., 2019; Yan et al., 2020; Andrychowicz et al., 2020).
+
+A new challenging dataset. Simulated images in our dataset are derived from the trifinger robot platform introduced by Wuthrich et al. ¨ (2020). The motivation for choosing this setting is that (1) it is challenging due to occlusions, correlations, and other difficulties encountered in robotic settings, (2) it requires modeling of fine details such as tip links at high resolutions, and (3) it corresponds to a robotic setup, so that learned representations can be used for control and reinforcement learning in simulation and in the real world. The scene comprises a robot finger with three joints that can be controlled to manipulate a cube in a bowl-shaped stage. Fig. 1 shows examples of scenes from our dataset. The data is generated from 7 different factors of variation (FoV)
+
+3 SCALING DISENTANGLED REPRESENTATIONS TO COMPLEX SCENARIOS  
+Table 1: Factors of variation in the proposed dataset. Values are linearly spaced in the specified intervals. Joint angles are in radians, cube positions in meters.   
+
+<table><tr><td rowspan=1 colspan=2>FoV              Values</td></tr><tr><td rowspan=1 colspan=1>Upper joint</td><td rowspan=1 colspan=1>30 values in[-0.65,+0.65]</td></tr><tr><td rowspan=1 colspan=1>Middle joint     30 values in</td><td rowspan=1 colspan=1>[-0.5,+0.5]</td></tr><tr><td rowspan=1 colspan=1>Lower joint      30 values in</td><td rowspan=1 colspan=1>[-0.8,+0.8]</td></tr><tr><td rowspan=2 colspan=1>Cube position X  30 values in[-0.11, +0.11]Cube position y  30 values in[-0.11, +0.11]</td><td rowspan=1 colspan=1>+0.11]</td></tr><tr><td rowspan=1 colspan=1>[-0.11, +0.11]</td></tr><tr><td rowspan=1 colspan=1>Cube rotation    10 values in [0°,81°]</td><td rowspan=2 colspan=1>12 values in [0°,330°]</td></tr><tr><td rowspan=1 colspan=1>Cube color hue  12 values in [0°,330°]</td></tr></table>
+
+listed in Table 1. Unlike in previous datasets, not all FoVs are independent: The end-effector (the tip of the finger) can collide with the floor or the cube, resulting in infeasible combinations of the factors (see Appendix B.1). We argue that such correlations are a key feature in real-world data that is not present in existing datasets. The high FoV resolution results in approximately 1.52 billion feasible states, but the dataset itself only contains one million of them (approximately $0 . 0 6 5 \%$ of all possible FoV combinations), realistically rendered into $1 2 8 \times 1 2 8$ images. Additionally, we recorded an annotated dataset under the same conditions in the real-world setup: we acquired 1,809 camera images from the same viewpoint and recorded the labels of the 7 underlying factors of variation. This dataset can be used for out-of-distribution evaluations, few-shot learning, and testing other sim2real aspects.
+
+![](images/f32fff0f3873c7b5bb46601dc40ae372b6d5350f2fe784b3fcf23de2e0923423.jpg)  
+Figure 2: Latent traversals of a trained model that perfectly disentangles the dataset’s FoVs. In each column, all latent variables but one are fixed.
+
+Model architecture. When scaling disentangled representation learning to more complex datasets, such as the one proposed here, one of the main bottlenecks in current VAE-based approaches is the flexibility of the encoder and decoder networks. In particular, using the architecture from Locatello et al. (2019b), none of the models we trained correctly captured all factors of variation or yielded high-quality reconstructions. While the increased image resolution already presents a challenge, the main practical issue in our new dataset is the level of detail that needs to be modeled. In particular, we identified the cube rotation and the lower joint position to be the factors of variation that were the hardest to capture. This is likely because these factors only produce relatively small changes in the image and hence the reconstruction error.
+
+To overcome these issues, we propose a deeper and wider neural architecture than those commonly used in the disentangled representation learning literature, where the encoder and decoder typically have 4 convolutional and 2 fully-connected layers. Our encoder consists of a convolutional layer, 10 residual blocks, and 2 fully-connected layers. Some residual blocks are followed by 1x1 convolutions that change the number of channels, or by average pooling that downsamples the tensors by a factor of 2 along the spatial dimensions. Each residual block consists of two 3x3 convolutions with a leaky ReLU nonlinearity, and a learnable scalar gating mechanism (Bachlechner et al., 2020). Overall, the encoder has 23 convolutional layers and 2 fully connected layers. The decoder mirrors this architecture, with average pooling replaced by bilinear interpolation for upsampling. The total number of parameters is approximately 16.3M. See Appendix A for further implementation details.
+
+Experimental setup. We perform a large-scale empirical study on the simulated dataset introduced above by training 1,080 $\beta$ -VAE models.2 For further experimental details we refer the reader to Appendix A. The hyperparameter sweep is defined as follows:
+
+• We train the models using either unsupervised learning or weakly supervised learning (Locatello et al., 2020). In the weakly supervised case, a model is trained with pairs of images that differ in $k$ factors of variation. Here we fix $k = 1$ as it was shown to lead to higher disentanglement by Locatello et al. (2020). The dataset therefore consists of $5 0 0 \mathrm { k }$ pairs of images that differ in only one FoV.   
+• We vary the parameter $\beta$ in $\{ 1 , 2 , 4 \}$ , and use linear deterministic warm-up (Bowman et al., 2015; Sønderby et al., 2016) over the first $\{ 0 , 1 0 0 0 0 , 5 0 0 0 0 \}$ training steps.   
+• The latent space dimensionality is in $\{ 1 0 , 2 5 , 5 0 \}$ .   
+• Half of the models are trained with additive noise in the input image. This choice is motivated by the fact that adding noise to the input of neural networks has been shown to be beneficial for out-of-distribution generalization (Sietsma & Dow, 1991; Bishop, 1995).   
+• Each of the 108 resulting configurations is trained with 10 random seeds.
+
+Can we scale up disentanglement learning? Most of the trained VAEs in our empirical study fully capture all the elements of a scene, correctly model heavy occlusions, and generate detailed, high-quality samples and reconstructions (see Appendix B.2). From visual inspections such as the latent traversals in Fig. 2, we observe that many trained models fully disentangle the ground-truth factors of variation. This, however, appears to only be possible in the weakly supervised scenario. The fact that models trained without supervision learn entangled representations is in line with the impossibility result for the unsupervised learning of disentangled representations from Locatello et al. (2019b). Latent traversals from a selection of models with different degrees of disentanglement are presented in Appendix B.3. Interestingly, the high-disentanglement models seem to correct for correlations and interpolate infeasible states, i.e. the fingertip traverses through the cube or the floor.
+
+![](images/88ab1de0ae19149e0481ebac85d3f259b45588c758c6f7f48f60d62f133c98e3.jpg)  
+Figure 3: Left: Disentanglement metrics aggregating all hyperparameters except for supervision type. Right: Rank correlations (Spearman) of ELBO, reconstruction loss, and the test error of a GBT classifier trained on 10,000 labelled data points with disentanglement metrics. The upper rank correlations correspond to the unsupervised models and the lower to the weakly supervised models.
+
+Summary: The proposed architecture can scale disentanglement learning to more realistic settings, but a form of weak supervision is necessary to achieve high disentanglement.
+
+How useful are common disentanglement metrics in realistic scenarios? The violin plot in Fig. 3 (left) shows that DCI and MIG measure high disentanglement under weak supervision and lower disentanglement in the unsupervised setting. This is consistent with our qualitative conclusion from visual inspection of the models (Appendix B.3) and with the aforementioned impossibility result. Many of the models trained with weak supervision exhibit a very high DCI score $2 9 \%$ of them have ${ > } 9 9 \%$ DCI, some of them up to $9 9 . 8 9 \%$ ). SAP and Modularity appear to be ineffective at capturing disentanglement in this setting, as also observed by Locatello et al. (2019b). Finally, note that the BetaVAE and FactorVAE metrics are not straightforward to be evaluated on datasets that do not contain all possible combinations of factor values. According to Fig. 3 (right), DCI and MIG strongly correlate with test accuracy of GBT classifiers predicting the FoVs. In the weakly supervised setting, these metrics are strongly correlated with the ELBO (positively) and with the reconstruction loss (negatively). We illustrate these relationships in more detail in Appendix B.4. Such correlations were also observed by Locatello et al. (2020) on significantly less complex datasets, and can be exploited for unsupervised model selection: these unsupervised metrics can be used as proxies for disentanglement metrics, which would require fully labeled data.
+
+Summary: DCI and MIG appear to be useful disentanglement metrics in realistic scenarios, whereas other metrics seem to fall short of capturing disentanglement or can be difficult to compute. When using weak supervision, we can select disentangled models with unsupervised metrics.
+
+# 4 FRAMEWORK FOR THE EVALUATION OF OOD GENERALIZATION
+
+Previous work has focused on evaluating the usefulness of disentangled representations for various downstream tasks, such as predicting ground truth factors of variation, fair classification, and abstract reasoning. Here we propose a new framework for evaluating the out-of-distribution (OOD) generalization properties of representations. More specifically, we consider a downstream task – in our case, regression of ground truth factors – trained on a learned representation of the data, and evaluate the performance on a held-out test set. While the test set typically follows the same distribution as the training set (in-distribution generalization), we also consider test sets that follow a different distribution (out-of-distribution generalization). Our goal is to investigate to what extent, if at all, downstream tasks trained on disentangled representations exhibit a higher degree of OOD generalization than those trained on entangled representations.
+
+Let $D$ denote the training set for disentangled representation learning. To investigate OOD generalization, we train downstream regression models on a subset $D _ { 1 } \subset D$ to predict ground truth factor values from the learned representation computed by the encoder. We independently train one predictor per factor. We then test the regression models on a set $D _ { 2 }$ that differs distributionally from the training set $D _ { 1 }$ , as it either contains images corresponding to held-out values of a chosen FoV (e.g. unseen object colors), or it consists of real-world images. We now differentiate between two scenarios: (1) $D _ { 2 } \subset D$ , i.e. the OOD test set is a subset of the dataset for representation learning; (2) $D$ and $D _ { 2 }$ are disjoint and distributionally different. These two scenarios will be denoted by $O O D I$ and $O O D 2$ , respectively. For example, consider the case in which distributional shifts are based on one FoV: the color of the object. Then, we could define these datasets such that images in $D$ always contain a red or blue object, and those in $D _ { 1 } \subset D$ always contain a red object. In the OOD1 scenario, images in $D _ { 2 }$ would always contain a blue object, whereas in the OOD2 case they would always contain an object that is neither red nor blue.
+
+The regression models considered here are Gradient Boosted Trees (GBT), random forests, and MLPs with $\{ 1 , 2 , 3 \}$ hidden layers. Since random forests exhibit a similar behavior to GBTs, and all MLPs yield similar results to each other, we choose GBTs and the 2-layer MLP as representative models and only report results for those. To quantify prediction quality, we normalize the ground truth factor values to the range $[ 0 , 1 ]$ , and compute the mean absolute error (MAE). Since the values are normalized, we can define our transfer metric as the average of the MAE over all factors (except for the FoV that is OOD).
+
+# 5 BENEFITS AND TRANSFER OF STRUCTURED REPRESENTATIONS
+
+Experimental setup. We evaluate the transfer metric introduced in Section 4 across all 1,080 trained models. To compute this metric, we train regression models to predict the ground truth factors of variation, and test them under distributional shift. We consider distributional shifts in terms of cube color or sim2real, and we do not evaluate downstream prediction of cube color. We report scores for two different regression models: a Gradient Boosted Tree (GBT) and an MLP with 2 hidden layers of size 256. In Appendix A we provide details on the datasets used in this section.
+
+In the OOD1 setting, we have $D _ { 2 } ~ \subset ~ D$ , hence the encoder is in-distribution: we are testing the predictor on representations of images that were in the training set of the representation learning algorithm. Therefore, we expect the representations to be meaningful. We consider three scenarios:
+
+OOD1-A: The regression models are trained on 1 cube color (red) and evaluated on the remaining 7 colors. OOD1-B: The regression models are trained on 4 cube colors with high hue in the HSV space, and evaluated on 4 cube colors with low hue (extrapolation). OOD1-C: The regression models are again trained and evaluated on 4 cube colors, but the training and evaluation colors are alternating along the hue dimension (interpolation).
+
+In the more challenging setting where even the encoder goes out-of-distribution (OOD2, with $D _ { 2 } \cap$ $D = \varnothing$ ), we train the regression models on a subset of the training set $D$ that includes all 8 cube colors, and we consider the two following scenarios:
+
+• OOD2-A: The regression models are evaluated on simulated data, on 4 cube colors that are out of the encoder’s training distribution.   
+• OOD2-B: The regression models are evaluated on real-world images of the robotic setup, without any adaptation or fine-tuning.
+
+![](images/a8917eeb133d6b5669d032b13e81cac11e7185bed02ca42aee8c10d3256aab63.jpg)  
+Figure 4: Higher disentanglement corresponds to better generalization across all OOD1 scenarios, as seen from the transfer scores (left). The transfer score is computed as the mean absolute prediction error of ground truth factor values (lower is better). This correlation is particularly evident in the GBT case, whereas MLPs appear to exhibit better OOD1 transfer with very high disentanglement only. These results are mirrored in the Spearman rank correlations between transfer scores and disentanglement metrics (right).
+
+Is disentanglement correlated with OOD1 generalization? In Fig. 4 we consistently observe a negative correlation between disentanglement and transfer error across all OOD1 settings. The correlation is mild when using MLPs, strong when using GBTs. This difference is expected, as GBTs have an axis-alignment bias whereas MLPs can – given enough data and capacity – disentangle an entangled representation more easily. Our results therefore suggest that highly disentangled representations are useful for generalizing out-of-distribution as long as the encoder remains in-distribution. This is in line with the correlation found by Locatello et al. (2019b) between disentanglement and the GBT10000 metric. There, however, GBTs are tested on the same distribution as the training distribution, while here we test them under distributional shift. Given that the computation of disentanglement scores requires labels, this is of little benefit in the unsupervised setting. However, it can be exploited in the weakly supervised setting, where disentanglement was shown to correlate with ELBO and reconstruction loss (Section 3). Therefore, model selection for representations that transfer well in these scenarios is feasible based on the ELBO or reconstruction loss, when weak supervision is available. Note that, in absolute terms, the OOD generalization error with encoder in-distribution (OOD1) is very low in the high-disentanglement case (the only exception being the MLP in the OOD1-C case, with the 1-7 color split, which seems to overfit). This suggests that disentangled representations can be useful in downstream tasks even when transferring out of the training distribution.
+
+Summary: Disentanglement seems to be positively correlated with OOD generalization of downstream tasks, provided that the encoder remains in-distribution (OOD1). Since in the weakly supervised case disentanglement correlates with the ELBO and the reconstruction loss, model selection can be performed using these metrics as proxies for disentanglement. These metrics have the advantage that they can be computed without labels, unlike disentanglement metrics.
+
+Is disentanglement correlated with OOD2 generalization? As seen in Fig. 5, the negative correlation between disentanglement and GBT transfer error is weaker when the encoder is out of distribution (OOD2). Nonetheless, we observe a non-negligible correlation for GBTs in the OOD2- A case, where we investigate out-of-distribution generalization along one FoV, with observations in $D _ { 2 }$ still generated from the same simulator. In the OOD2-B setting, where the observations are taken from cameras in the corresponding real-world setting, the correlation between disentanglement and transfer performance appears to be minor at best. This scenario can be considered a variant of zero-shot sim2real generalization.
+
+Summary: Disentanglement has a minor effect on out-of-distribution generalization outside of the training distribution of the encoder (OOD2).
+
+![](images/3caa155b0e0c7e7a7836a9f63f3aa28e051c3f1d453968d716ec81ac3a38a25e.jpg)  
+Figure 5: Disentanglement affects generalization across the OOD2 scenarios only minimally as seen from transfer scores (left) and corresponding rank correlations with disentanglement metrics (right).
+
+![](images/8a3bf47d3eed60551e8542f6371b5044c44bfa24971224373ae2079c5152b46a.jpg)  
+Figure 6: Noise improves generalization across the OOD2 scenarios and less so for the OOD1 scenarios as seen from the transfer scores. Top row: Spearman rank correlation coefficients between transfer metrics and presence of noise in the input.
+
+What else matters for OOD2 generalization? Results in Fig. 6 suggest that adding Gaussian noise to the input during training as described in Section 3 leads to significantly better OOD2 generalization, and has no effect on OOD1 generalization. Adding noise to the input of neural networks is known to lead to better generalization (Sietsma & Dow, 1991; Bishop, 1995). This is in agreement with our results, since OOD1 generalization does not require generalization of the encoder, while OOD2 does. Interestingly, closer inspection reveals that the contribution of different factors of variation to the generalization error can vary widely. See Appendix B.5 for further details. In particular, with noisy input, the position of the cube is predicted accurately even in real-world images ${ < } 5 \%$ mean absolute error on each axis). This is promising for robotics applications, where the true state of the joints is observable but inference of the cube position relies on object tracking methods. Fig. 7 shows an example of real-world inputs and reconstructions of their simulated equivalents.
+
+Summary: Adding input noise during training appears to be significantly beneficial for OOD2 generalization, while having no effect when the encoder is kept in its training distribution (OOD1).
+
+# 6 CONCLUSION
+
+Despite the growing importance of the field and the potential societal impact in the medical domain (Chartsias et al., 2018) and fair decision making (Locatello et al., 2019a), state-of-the-art approaches for learning disentangled representations have so far only been systematically evaluated on synthetic toy datasets. Here we introduced a new high-resolution dataset with 1M simulated images and over 1,800 annotated real-world images of the same setup. This dataset exhibits a number of challenges and features which are not present in previous datasets: it contains correlations between factors, occlusions, a complex underlying structure, and it allows for evaluation of transfer to unseen simulated and real-world settings. We proposed a new VAE architecture to scale disentangled representation learning to this realistic setting and conducted a large-scale empirical study of disentangled representations on this dataset. We discovered that disentanglement is a good predictor of OOD generalization of downstream tasks and showed that, in the context of weak supervision, model selection for good OOD performance can be based on the ELBO or the reconstruction loss, which are accessible without explicit labels. Our setting allows for studying a wide variety of interesting downstream tasks in the future, such as reinforcement learning or learning a dynamics model of the environment. Finally, we believe that in the future it will be important to take further steps in the direction of this paper by considering settings with even more complex structures and stronger correlations between factors.
+
+![](images/80cc02fdfea336501807be97fe20f51feac8677170955d3731e106b2859b088b.jpg)  
+Figure 7: Zero-shot transfer to real-world observations of our models trained in simulation. Left: input; right: reconstruction.
+
+# ACKNOWLEDGEMENTS
+
+The authors thank Shruti Joshi and Felix Widmaier for their useful comments on the simulated setup, Anirudh Goyal for helpful discussions and comments, and CIFAR for the support. We thank the International Max Planck Research School for Intelligent Systems (IMPRS-IS) for supporting Frederik Trauble.¨
+
+# REFERENCES
+
+Tameem Adel, Zoubin Ghahramani, and Adrian Weller. Discovering interpretable representations for both deep generative and discriminative models. In International Conference on Machine Learning, pp. 50–59, 2018.
+
+OpenAI: Marcin Andrychowicz, Bowen Baker, Maciek Chociej, Rafal Jozefowicz, Bob McGrew, Jakub Pachocki, Arthur Petron, Matthias Plappert, Glenn Powell, Alex Ray, et al. Learning dexterous in-hand manipulation. The International Journal of Robotics Research, 39(1):3–20, 2020.
+
+Martin Arjovsky, Leon Bottou, Ishaan Gulrajani, and David Lopez-Paz. Invariant risk minimization. ´ arXiv preprint arXiv:1907.02893, 2019.
+
+Francis Bach and Michael Jordan. Kernel independent component analysis. Journal of Machine Learning Research, 3(7):1–48, 2002.
+
+Thomas Bachlechner, Bodhisattwa Prasad Majumder, Huanru Henry Mao, Garrison W Cottrell, and Julian McAuley. Rezero is all you need: Fast convergence at large depth. arXiv preprint arXiv:2003.04887, 2020.
+
+Chris M Bishop. Training with noise is equivalent to tikhonov regularization. Neural computation, 7(1):108–116, 1995.
+
+Samuel R Bowman, Luke Vilnis, Oriol Vinyals, Andrew M Dai, Rafal Jozefowicz, and Samy Bengio. Generating sentences from a continuous space. arXiv preprint arXiv:1511.06349, 2015.
+
+Christopher P Burgess, Irina Higgins, Arka Pal, Loic Matthey, Nick Watters, Guillaume Desjardins, and Alexander Lerchner. Understanding disentangling in beta-VAE. arXiv preprint arXiv:1804.03599, 2018.
+
+Agisilaos Chartsias, Thomas Joyce, Giorgos Papanastasiou, Scott Semple, Michelle Williams, David Newby, Rohan Dharmakumar, and Sotirios A Tsaftaris. Factorised spatial representation learning: Application in semi-supervised myocardial segmentation. In International Conference on Medical Image Computing and Computer-Assisted Intervention, pp. 490–498. Springer, 2018.
+
+Tian Qi Chen, Xuechen Li, Roger Grosse, and David Duvenaud. Isolating sources of disentanglement in variational autoencoders. In Advances in Neural Information Processing Systems, 2018.
+
+Pierre Comon. Independent component analysis, a new concept? Signal Processing, 36(3):287–314, 1994.
+
+Peter Dayan. Improving generalization for temporal difference learning: The successor representation. Neural Computation, 5(4):613–624, 1993.
+
+Cian Eastwood and Christopher KI Williams. A framework for the quantitative evaluation of disentangled representations. In International Conference on Learning Representations, 2018.
+
+Sanja Fidler, Sven Dickinson, and Raquel Urtasun. 3d object detection and viewpoint estimation with a deformable 3d cuboid model. In Advances in neural information processing systems, pp. 611–619, 2012.
+
+Muhammad Waleed Gondal, Manuel Wuthrich, Djordje Miladinovi ¨ c, Francesco Locatello, Martin ´ Breidt, Valentin Volchkov, Joel Akpo, Olivier Bachem, Bernhard Scholkopf, and Stefan Bauer. ¨ On the transfer of inductive bias from simulation to the real world: a new disentanglement dataset. In Advances in Neural Information Processing Systems, 2019.
+
+Sven Gowal, Chongli Qin, Po-Sen Huang, Taylan Cemgil, Krishnamurthy Dvijotham, Timothy Mann, and Pushmeet Kohli. Achieving robustness in the wild via adversarial mixing with disentangled representations. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 1211–1220, 2020.
+
+Luigi Gresele, Paul K. Rubenstein, Arash Mehrjou, Francesco Locatello, and Bernhard Scholkopf.¨ The incomplete rosetta stone problem: Identifiability results for multi-view nonlinear ica. In Conference on Uncertainty in Artificial Intelligence (UAI), 2019.
+
+Christina Heinze-Deml and Nicolai Meinshausen. Conditional variance penalties and domain shift robustness. arXiv preprint arXiv:1710.11469, 2017.
+
+Irina Higgins, Loic Matthey, Arka Pal, Christopher Burgess, Xavier Glorot, Matthew Botvinick, Shakir Mohamed, and Alexander Lerchner. beta-VAE: Learning basic visual concepts with a constrained variational framework. In International Conference on Learning Representations, 2017a.
+
+Irina Higgins, Arka Pal, Andrei Rusu, Loic Matthey, Christopher Burgess, Alexander Pritzel, Matthew Botvinick, Charles Blundell, and Alexander Lerchner. Darla: Improving zero-shot transfer in reinforcement learning. In International Conference on Machine Learning, 2017b.
+
+Irina Higgins, Nicolas Sonnerat, Loic Matthey, Arka Pal, Christopher P Burgess, Matko Bosnjak, ˇ Murray Shanahan, Matthew Botvinick, Demis Hassabis, and Alexander Lerchner. Scan: Learning hierarchical compositional visual concepts. In International Conference on Learning Representations, 2018.
+
+Aapo Hyvarinen and Hiroshi Morioka. Unsupervised feature extraction by time-contrastive learning and nonlinear ica. In Advances in Neural Information Processing Systems, 2016.
+
+Aapo Hyvarinen and Petteri Pajunen. Nonlinear independent component analysis: Existence and ¨ uniqueness results. Neural Networks, 1999.
+
+Aapo Hyvarinen, Hiroaki Sasaki, and Richard E Turner. Nonlinear ica using auxiliary variables and generalized contrastive learning. In International Conference on Artificial Intelligence and Statistics, 2019.
+
+Stephen James, Paul Wohlhart, Mrinal Kalakrishnan, Dmitry Kalashnikov, Alex Irpan, Julian Ibarz, Sergey Levine, Raia Hadsell, and Konstantinos Bousmalis. Sim-to-real via sim-to-sim: Dataefficient robotic grasping via randomized-to-canonical adaptation networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 12627–12637, 2019.
+
+Christian Jutten and Juha Karhunen. Advances in nonlinear blind source separation. In International Symposium on Independent Component Analysis and Blind Signal Separation, pp. 245–256, 2003.
+
+Ilyes Khemakhem, Diederik Kingma, Ricardo Monti, and Aapo Hyvarinen. Variational autoencoders and nonlinear ica: A unifying framework. In International Conference on Artificial Intelligence and Statistics, pp. 2207–2217, 2020.
+
+Hyunjik Kim and Andriy Mnih. Disentangling by factorising. In International Conference on Machine Learning, 2018.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Diederik P Kingma and Max Welling. Auto-encoding variational Bayes. In International Conference on Learning Representations, 2014.
+
+David Klindt, Lukas Schott, Yash Sharma, Ivan Ustyuzhaninov, Wieland Brendel, Matthias Bethge, and Dylan Paiton. Towards nonlinear disentanglement in natural data with temporal sparse coding. arXiv preprint arXiv:2007.10930, 2020.
+
+David Krueger, Ethan Caballero, Joern-Henrik Jacobsen, Amy Zhang, Jonathan Binas, Remi Le Priol, and Aaron Courville. Out-of-distribution generalization via risk extrapolation (rex). arXiv preprint arXiv:2003.00688, 2020.
+
+Abhishek Kumar, Prasanna Sattigeri, and Avinash Balakrishnan. Variational inference of disentangled latent concepts from unlabeled observations. In International Conference on Learning Representations, 2018.
+
+Yann LeCun, Fu Jie Huang, and Leon Bottou. Learning methods for generic object recognition with invariance to pose and lighting. In IEEE Conference on Computer Vision and Pattern Recognition, 2004.
+
+Ya Li, Xinmei Tian, Mingming Gong, Yajing Liu, Tongliang Liu, Kun Zhang, and Dacheng Tao. Deep domain generalization via conditional invariant adversarial networks. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 624–639, 2018.
+
+Francesco Locatello, Gabriele Abbati, Thomas Rainforth, Stefan Bauer, Bernhard Scholkopf, and ¨ Olivier Bachem. On the fairness of disentangled representations. In Advances in Neural Information Processing Systems, pp. 14611–14624, 2019a.
+
+Francesco Locatello, Stefan Bauer, Mario Lucic, Sylvain Gelly, Bernhard Scholkopf, and Olivier ¨ Bachem. Challenging common assumptions in the unsupervised learning of disentangled representations. In International Conference on Machine Learning, 2019b.
+
+Francesco Locatello, Ben Poole, Gunnar Ratsch, Bernhard Sch¨ olkopf, Olivier Bachem, and¨ Michael Tschannen. Weakly-supervised disentanglement without compromises. arXiv preprint arXiv:2002.02886, 2020.
+
+Krikamol Muandet, David Balduzzi, and Bernhard Scholkopf. Domain generalization via invariant ¨ feature representation. In International Conference on Machine Learning, pp. 10–18, 2013.
+
+Xue Bin Peng, Marcin Andrychowicz, Wojciech Zaremba, and Pieter Abbeel. Sim-to-real transfer of robotic control with dynamics randomization. In 2018 IEEE international conference on robotics and automation (ICRA), pp. 1–8. IEEE, 2018.
+
+Scott Reed, Yi Zhang, Yuting Zhang, and Honglak Lee. Deep visual analogy-making. In Advances in Neural Information Processing Systems, 2015.
+
+Danilo Jimenez Rezende, Shakir Mohamed, and Daan Wierstra. Stochastic backpropagation and approximate inference in deep generative models. arXiv preprint arXiv:1401.4082, 2014.
+
+Karl Ridgeway and Michael C Mozer. Learning deep disentangled embeddings with the f-statistic loss. In Advances in Neural Information Processing Systems, 2018.
+
+Mateo Rojas-Carulla, Bernhard Scholkopf, Richard Turner, and Jonas Peters. Invariant models for ¨ causal transfer learning. The Journal of Machine Learning Research, 19(1):1309–1342, 2018.
+
+Andrei A Rusu, Matej Vecer ˇ ´ık, Thomas Rothorl, Nicolas Heess, Razvan Pascanu, and Raia Hadsell. ¨ Sim-to-real robot learning from pixels with progressive nets. In Conference on Robot Learning, pp. 262–270, 2017.
+
+Bernhard Scholkopf, Francesco Locatello, Stefan Bauer, Nan Rosemary Ke, Nal Kalchbrenner, ¨ Anirudh Goyal, and Yoshua Bengio. Towards causal representation learning. arXiv preprint arXiv:2102.11107, 2021.
+
+Rui Shu, Yining Chen, Abhishek Kumar, Stefano Ermon, and Ben Poole. Weakly supervised disentanglement with guarantees. arXiv preprint arXiv:1910.09772, 2019.
+
+Jocelyn Sietsma and Robert JF Dow. Creating artificial neural networks that generalize. Neural networks, 4(1):67–79, 1991.
+
+Casper Kaae Sønderby, Tapani Raiko, Lars Maaløe, Søren Kaae Sønderby, and Ole Winther. Ladder variational autoencoders. In Advances in neural information processing systems, pp. 3738–3746, 2016.
+
+Peter Sorrenson, Carsten Rother, and Ullrich Kothe. Disentanglement by nonlinear ica with general ¨ incompressible-flow networks (gin). arXiv preprint arXiv:2001.04872, 2020.
+
+Raphael Suter, Djordje Miladinovic, Bernhard Scholkopf, and Stefan Bauer. Robustly disentangled ¨ causal mechanisms: Validating deep representations for interventional robustness. In International Conference on Machine Learning, pp. 6056–6065. PMLR, 2019.
+
+Josh Tobin, Rachel Fong, Alex Ray, Jonas Schneider, Wojciech Zaremba, and Pieter Abbeel. Domain randomization for transferring deep neural networks from simulation to the real world. In 2017 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), pp. 23–30. IEEE, 2017.
+
+Frederik Trauble, Elliot Creager, Niki Kilbertus, Francesco Locatello, Andrea Dittadi, Anirudh ¨ Goyal, Bernhard Scholkopf, and Stefan Bauer. On disentangled representations learned from ¨ correlated data. arXiv preprint arXiv:2006.07886, 2020.
+
+Sjoerd van Steenkiste, Francesco Locatello, Jurgen Schmidhuber, and Olivier Bachem. Are disen- ¨ tangled representations helpful for abstract visual reasoning? arXiv preprint arXiv:1905.12506, 2019.
+
+Manuel Wuthrich, Felix Widmaier, Felix Grimminger, Joel Akpo, Shruti Joshi, Vaibhav Agrawal, ¨ Bilal Hammoud, Majid Khadiv, Miroslav Bogdanovic, Vincent Berenz, et al. Trifinger: An opensource robot for learning dexterity. arXiv preprint arXiv:2008.03596, 2020.
+
+Mengyuan Yan, Qingyun Sun, Iuri Frosio, Stephen Tyree, and Jan Kautz. How to close sim-real gap? transfer with segmentation! arXiv preprint arXiv:2005.07695, 2020.
+
+# A IMPLEMENTATION DETAILS
+
+Training. We train the $\beta$ -VAEs by maximizing the following objective function:
+
+$$
+\mathcal { L } _ { V A E } ^ { \beta } = \mathbb { E } _ { q _ { \phi } ( z | \mathbf { x } ) } [ \log p _ { \theta } ( \mathbf { x } | z ) ] - \beta D _ { \mathrm { K L } } ( q _ { \phi } ( z | \mathbf { x } ) \| p ( z ) ) \leq \log p ( \mathbf { x } )
+$$
+
+with $\beta > 0$ using the Adam optimizer (Kingma & Ba, 2014) with default parameters. We use a batch size of 64 and train for 400k steps. The learning rate is initialized to 1e-4 and halved at 150k and $3 0 0 \mathrm { k }$ training steps. We clip the global gradient norm to 1.0 before each weight update. Following Locatello et al. (2019b), we use a Gaussian encoder with an isotropic Gaussian prior for the latent variable, and a Bernoulli decoder. Our implementation of weakly supervised learning is based on Ada-GVAE (Locatello et al., 2020), but uses a symmetrized KL divergence:
+
+$$
+\tilde { D } _ { \mathrm { K L } } ( p , q ) = \frac { 1 } { 2 } D _ { \mathrm { K L } } ( p \Vert q ) + \frac { 1 } { 2 } D _ { \mathrm { K L } } ( q \Vert p )
+$$
+
+to infer which latent dimensions should be aggregated.
+
+The noise added to the encoder’s input consists of two independent components, both iid Gaussian with zero mean: one is independent for each subpixel (RGB) and has standard deviation 0.03, the other is a $8 \times 8$ pixel-wise (greyscale) noise with standard deviation 0.15, bilinearly upsampled by a factor of 16. The latter has been designed (by visual inspection) to roughly mimic observation noise in the real images due to complex lighting conditions.
+
+Neural architecture. Architectural details are provided in Tables 2 and 3, and Fig. 8 provides a high-level overview. In preliminary experiments, we observed that batch normalization, layer normalization, and dropout did not significantly affect performance in terms of ELBO, model samples, and disentanglement scores, both in the unsupervised and weakly supervised settings. On the other hand, layer normalization before the posterior parameterization (last layer of the encoder) appeared to be beneficial for stability in early training. While using an architecture based on residual blocks leads to fast convergence, in practice we observed that it may be challenging to keep the gradients in check at the beginning of training.3 In order to solve this issue, we resorted to a simple scalar gating mechanism in the residual blocks (Bachlechner et al., 2020) such that each residual block is initialized to the identity.
+
+Datasets and OOD evaluation. Because we evaluate OOD generalization in terms of cube color hue (except in the sim2real case), we first sampled 8 color hues at random from the 12 specified in Table 1. The chosen hues are: $[ 0 ^ { \circ } , 1 2 0 ^ { \circ }$ , $1 5 0 ^ { \circ }$ , $1 8 0 ^ { \circ }$ , $2 1 0 ^ { \circ }$ , $2 7 0 ^ { \circ }$ , $3 0 0 ^ { \circ } , 3 3 0 ^ { \circ } ]$ ]. Then, the dataset $D$ used for training VAEs is generated by randomly sampling values for the factors of variation from Table 1, with the color hue restricted to the above-mentioned values. This makes OOD2 evaluation possible, specifically OOD2-A where the learned predictors are tested on representations extracted from images with held-out values of the cube hue.
+
+For evaluation of out-of-distribution generalization, we train the downstream predictors on a subset $D _ { 1 } \subset D$ of the representation training set. The downstream training set $D _ { 1 }$ is sampled at random from $D$ but only contains a (not necessarily proper) subset of the 8 cube colors. This subset contains 1 color in the OOD1-A case, 4 colors in OOD1-B and OOD1-C, all 8 colors in OOD2 (in this case $D _ { 1 }$ is simply a random subset of $D$ ). Then we test the downstream predictors on a set $D _ { 2 }$ distributionally different from $D _ { 1 }$ in terms of cube color (all OOD1 scenarios as well as OOD2-A) or sim2real (OOD2-B). In the OOD1 case, $D _ { 2 }$ is also a subset of $D$ and is generated the same way. In each OOD1 case, the test set $D _ { 2 }$ is paired with its corresponding $D _ { 1 }$ that was used to train the downstream predictors. $D _ { 2 }$ contains all colors in $D$ minus those in $D _ { 1 }$ . In the OOD2-A case, $D _ { 2 }$ is a separate dataset containing $5 \mathrm { k }$ simulated images like those in $D$ , except that these only contain the 4 colors that were left out from the VAE training set $D$ (hue in $[ 3 0 ^ { \circ } , 6 0 ^ { \circ } , 9 0 ^ { \circ } , 2 4 0 ^ { \circ } ] )$ . In the OOD2-B case, the set $D _ { 2 }$ is the dataset of real images. Following previous work (e.g. the GBT10000 metric in Locatello et al. (2019b)), the training set $D _ { 1 }$ and test set $D _ { 2 }$ for downstream tasks contain 10k and $5 \mathrm { k }$ images, respectively, except in the OOD2-B case, where the size is limited by the size of the real dataset.
+
+<table><tr><td colspan="2">Encoder</td></tr><tr><td>Operation</td><td>Output Shape</td></tr><tr><td>Input Conv 5x5, stride 2, 64 ch. LeakyReLU(0.02) 2x ResidualBlock(64)</td><td>128×128×K 64×64×64</td></tr><tr><td>Conv 1x1,128 channels AveragePool(2) 2x ResidualBlock(128)</td><td>64×64×128 32×32×128</td></tr><tr><td>AveragePool(2) 2x ResidualBlock(128) Conv 1x1,256 channels</td><td>16×16×128</td></tr><tr><td>AveragePool(2) 2x ResidualBlock(256) AveragePool(2)</td><td>16×16×256 8×8×256</td></tr><tr><td>2x ResidualBlock(256) Flatten LeakyReLU(0.02)</td><td>4×4×256 一</td></tr><tr><td></td><td>4096 512</td></tr><tr><td>FC(512) LeakyReLU(0.02) LayerNorm 2x FC(d)</td><td>一 2d</td></tr></table>
+
+<table><tr><td colspan="2">Decoder</td></tr><tr><td>Operation</td><td>Output Shape</td></tr><tr><td>Input FC(512)</td><td>d 512</td></tr><tr><td>LeakyReLU(0.02) FC(4096)</td><td></td></tr><tr><td rowspan="2">Reshape 2x ResidualBlock(256) BilinearInterpolation(2)</td><td>4096 4×4×256</td></tr><tr><td></td></tr><tr><td>2x ResidualBlock(256) Conv 1x1,128 channels</td><td>8×8×256 8×8×128</td></tr><tr><td>BilinearInterpolation(2) 2x ResidualBlock(128) BilinearInterpolation(2)</td><td>16×16×128</td></tr><tr><td>2x ResidualBlock(128) Conv 1x1, 64 channels BilinearInterpolation(2)</td><td>32×32×128</td></tr><tr><td></td><td>32×32×64 64×64×64</td></tr><tr><td>2x ResidualBlock(64) BilinearInterpolation(2)</td><td></td></tr><tr><td>LeakyReLU(0.02) Conv 5x5,K channels</td><td>128×128×64 128×128×K</td></tr></table>
+
+Table 2: Encoder (left) and decoder (right) architectures. The latent space dimensionality is denoted by $d$ , and $K = 3$ indicates the number of image channels. Last line in the encoder architecture: the fully connected layer parameterizing the log variance of the approximate posterior distributions of the latent variables has custom initialization. The weights are initialized with $1 / 1 0$ standard deviation than the default value, and the biases are initialized to $- 1$ instead of 0. Empirically, this together with (learnable) LayerNorm was beneficial for training stability at the beginning of training.
+
+Table 3: Architecture of one residual block. The scalar gate is implemented by multiplying the tensor by a learnable scalar parameter before adding it to the block input. Initializing the residual block to the identity by setting this parameter to zero has been originally proposed by Bachlechner et al. (2020). The tensor shape is constant throughout the residual block.   
+
+<table><tr><td>Residual Block</td></tr><tr><td>Input: shape H × W ×C LeakyReLU(0.02) Conv 3x3, C channels</td></tr></table>
+
+![](images/9917a1686b283cacc0999471103f84041ea0591fae9eedfb47dd33f8520b29f8.jpg)  
+Figure 8: Schemes of the encoder (top) and decoder (bottom) architectures. In both schemes, information flows left to right. Blue blocks represent convolutional layers: those labeled “conv” have 5x5 kernels and stride 2, while those labeled “1x1” have 1x1 kernels. Each orange block represents a pair of residual blocks (implementation details of a residual block are provided in Table 3). Green blocks in the encoder represent average pooling with stride 2, and those in the decoder denote bilinear upsampling by a factor of 2. Red blocks represent fully-connected layers. The block labeled “norm” indicates layer normalization. Dashed lines denote tensor reshaping.
+
+# B ADDITIONAL RESULTS
+
+# B.1 DATASET CORRELATIONS
+
+![](images/a4d55e75790005f576632c767cb3647291f2b598564805a06e28a1defb1e3775.jpg)  
+Figure 9: Feasible states of the 2nd and 3rd DoF when the angle of the 1st DoF is 0. Angles are in radians.
+
+![](images/d9cb88bc4c7d6037fa6a0122b8ef412b507e8238e54f00bfd2907b6616b9ba07.jpg)  
+Figure 10: Density of feasible states of 2nd and 3rd DoF over the whole training dataset. Darker shades of blue indicate regions of higher density. Angles are in radians.
+
+# B.2 SAMPLES AND RECONSTRUCTIONS
+
+![](images/f42e6fd5a8d1605b10df96d9537dbefb0433dd74fe0de7ebeedcc06a584cf414.jpg)  
+Figure 11: Samples generated by a trained model. This model was selected based on the ELBO.
+
+![](images/8d2079514c2ede8646f1b27227273070da8929c53c342dad2407f8e7c67b358c.jpg)  
+Figure 12: Input reconstructions by a trained model. This model was selected based on the ELBO. Image inputs are on odd columns, reconstructions on even columns.
+
+#
+
+![](images/ebc83f404362b5359f97ad0da34b96428f54166a8e05e75371fb287f5c60c284.jpg)  
+Figure 13: Latent traversals for a model with low DCI score (0.15) in (a), medium DCI score (0.5) in (b), and high DCI score (1.0) in (c).
+
+![](images/f547612880ffae15a6b1c2197dee451a33ac3262505aca08a5ad80dc5750e3cc.jpg)  
+Figure 14: Scatter plots of unsupervised metrics (left: ELBO; right: reconstruction loss) vs disentanglement (top: MIG; bottom: DCI) for 1,080 trained models, color-coded according to supervision. Each point represents a trained model.
+
+# B.5 OUT-OF-DISTRIBUTION TRANSFER
+
+![](images/fd91b88d8f66083508e0489d539bf4f86ef58a5fa9b40c428d246dd324881699.jpg)  
+Figure 15: Transfer metric in OOD2-A (top) and OOD2-B (bottom) settings, decomposed according to the factor of variation and presence of input noise. When noise is added to the input during training, the inferred cube position error is relatively low (the scores are the mean absolute error, and they are normalized to [0, 1]). This is particularly useful in the OOD2-B setting (real world) where the joint state is anyway considered known, while object position has to be inferred with tracking methods.
+
+![](images/baebf49c43dfc087165de52f6cc029407e610ae45792d4a34f95c68fb5f0c95b.jpg)  
+Figure 16: Reconstructions of real-world images (OOD2-B) for a model with low DCI score (0.15) in (a), medium DCI score (0.5) in (b), and high DCI score (1.0) in (c).
+
+![](images/b41979d54e732d8d4a896fb03d91db1257283803cbbaecf406efd61fd88936ae.jpg)  
+Figure 17: Reconstructions of simulated images with encoder out-of-distribution colors (OOD2-A) for a model with low DCI score (0.15) in (a), medium DCI score (0.5) in (b), and high DCI score (1.0) in (c).

parse/train/8VXvj1QNRl1/8VXvj1QNRl1_content_list.json

@@ -0,0 +1,1703 @@
+[
+    {
+        "type": "text",
+        "text": "ON THE TRANSFER OF DISENTANGLED REPRESENTA-TIONS IN REALISTIC SETTINGS",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            821,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Andrea Dittadi,∗†1 Frederik Trauble, ¨ ∗2 Francesco Locatello,2,3 Manuel Wuthrich, ¨ 2   \nVaibhav Agrawal,2 Ole Winther,1,4,5 Stefan Bauer,2,6 Bernhard Scholkopf ¨ 2   \n1Technical University of Denmark, $^ { 2 } \\mathrm { M a x }$ Planck Institute for Intelligent Systems,   \n3ETH Zurich, Department for Computer Science, 4Copenhagen University Hospital,   \n5University of Copenhagen , 6CIFAR Azrieli Global Scholar ",
+        "bbox": [
+            183,
+            169,
+            759,
+            199
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            186,
+            205,
+            735,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            287,
+            544,
+            303
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Learning meaningful representations that disentangle the underlying structure of the data generating process is considered to be of key importance in machine learning. While disentangled representations were found to be useful for diverse tasks such as abstract reasoning and fair classification, their scalability and real-world impact remain questionable. We introduce a new high-resolution dataset with 1M simulated images and over 1,800 annotated real-world images of the same setup. In contrast to previous work, this new dataset exhibits correlations, a complex underlying structure, and allows to evaluate transfer to unseen simulated and realworld settings where the encoder i) remains in distribution or ii) is out of distribution. We propose new architectures in order to scale disentangled representation learning to realistic high-resolution settings and conduct a large-scale empirical study of disentangled representations on this dataset. We observe that disentanglement is a good predictor for out-of-distribution (OOD) task performance. ",
+        "bbox": [
+            233,
+            323,
+            764,
+            502
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            540,
+            336,
+            555
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Disentangled representations hold the promise of generalization to unseen scenarios (Higgins et al., 2017b), increased interpretability (Adel et al., 2018; Higgins et al., 2018) and faster learning on downstream tasks (van Steenkiste et al., 2019; Locatello et al., 2019a). However, most of the focus in learning disentangled representations has been on small synthetic datasets whose ground truth factors exhibit perfect independence by design. More realistic settings remain largely unexplored. We hypothesize that this is because real-world scenarios present several challenges that have not been extensively studied to date. Important challenges are scaling (much higher resolution in observations and factors), occlusions, and ",
+        "bbox": [
+            174,
+            575,
+            483,
+            796
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/c6fb806d6fc458286d4260c0ce63df72991b62a25f144d6895ab501cd4cced79.jpg",
+        "image_caption": [
+            "Figure 1: Images from the simulated dataset (left) and from the real-world setup (right). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            498,
+            592,
+            823,
+            733
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "correlation between factors. Consider, for instance, a robotic arm moving a cube: Here, the robot arm can occlude parts of the cube, and its end-effector position exhibits correlations with the cube’s position and orientation, which might be problematic for common disentanglement learners (Trauble ¨ et al., 2020). Another difficulty is that we typically have only limited access to ground truth labels in the real world, which requires robust frameworks for model selection when no or only weak labels are available. ",
+        "bbox": [
+            173,
+            796,
+            825,
+            878
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The goal of this work is to provide a path towards disentangled representation learning in realistic settings. First, we argue that this requires a new dataset that captures the challenges mentioned above. We propose a dataset consisting of simulated observations from a scene where a robotic arm interacts with a cube in a stage (see Fig. 1). This setting exhibits correlations and occlusions that are typical in real-world robotics. Second, we show how to scale the architecture of disentanglement methods to perform well on this dataset. Third, we extensively analyze the usefulness of disentangled representations in terms of out-of-distribution downstream generalization, both in terms of held-out factors of variation and sim2real transfer. In fact, our dataset is based on the TriFinger robot from Wuthrich et al. (2020), which can be built to test the deployment of models in the real ¨ world. While the analysis in this paper focuses on the transfer and generalization of predictive models, we hope that our dataset may serve as a benchmark to explore the usefulness of disentangled representations in real-world control tasks. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            270
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The contributions of this paper can be summarized as follows: ",
+        "bbox": [
+            173,
+            276,
+            581,
+            291
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We propose a new dataset for disentangled representation learning, containing 1M simulated high-resolution images from a robotic setup, with seven partly correlated factors of variation. Additionally, we provide a dataset of over 1,800 annotated images from the corresponding real-world setup that can be used for challenging sim2real transfer tasks. These datasets are made publicly available.1   \nWe propose a new neural architecture to successfully scale VAE-based disentanglement learning approaches to complex datasets.   \n• We conduct a large-scale empirical study on generalization to various transfer scenarios on this challenging dataset. We train 1,080 models using state-of-the-art disentanglement methods and discover that disentanglement is a good predictor for out-of-distribution (OOD) performance of downstream tasks. ",
+        "bbox": [
+            215,
+            304,
+            825,
+            467
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            487,
+            344,
+            503
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Disentanglement methods. Most state-of-the-art disentangled representation learning approaches are based on the framework of variational autoencoders (VAEs) (Kingma & Welling, 2014; Rezende et al., 2014). A (high-dimensional) observation $_ { \\textbf { \\em x } }$ is assumed to be generated according to the latent variable model $p _ { \\theta } ( \\pmb { x } | \\pmb { z } ) p ( \\pmb { z } )$ where the latent variables $_ { z }$ have a fixed prior $p ( z )$ . The generative model $p _ { \\theta } ( { \\pmb x } | { \\pmb z } )$ and the approximate posterior distribution $q _ { \\phi } ( \\pmb { z } | \\pmb { x } )$ are typically parameterized by neural networks, which are optimized by maximizing the evidence lower bound (ELBO): ",
+        "bbox": [
+            173,
+            520,
+            825,
+            603
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c6ce0e20b5dec62c017c0335c1ea308fb369d723d7c3676cf7e0a507f03ef065.jpg",
+        "text": "$$\n\\mathcal { L } _ { V A E } = \\mathbb { E } _ { q _ { \\phi } ( z | x ) } [ \\log p _ { \\theta } ( \\pmb { x } | z ) ] - D _ { \\mathrm { K L } } ( q _ { \\phi } ( z | \\pmb { x } ) | | p ( z ) ) \\le \\log p ( \\pmb { x } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            276,
+            609,
+            722,
+            628
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "As the above objective does not enforce any structure on the latent space except for some similarity to $p ( z )$ , different regularization strategies have been proposed, along with evaluation metrics to gauge the disentanglement of the learned representations (Higgins et al., $2 0 1 7 \\mathrm { a }$ ; Kim & Mnih, 2018; Burgess et al., 2018; Kumar et al., 2018; Chen et al., 2018; Eastwood & Williams, 2018). Recently, Locatello et al. (2019b, Theorem 1) showed that the purely unsupervised learning of disentangled representations is impossible. This limitation can be overcome without the need for explicitly labeled data by introducing weak labels (Locatello et al., 2020; Shu et al., 2019). Ideas related to disentangling the factors of variation date back to the non-linear ICA literature (Comon, 1994; Hyvarinen & Pajunen, 1999; Bach & Jordan, 2002; Jutten & Karhunen, 2003; Hyvarinen & ¨ Morioka, 2016; Hyvarinen et al., 2019; Gresele et al., 2019). Recent work combines non-linear ICA with disentanglement (Khemakhem et al., 2020; Sorrenson et al., 2020; Klindt et al., 2020). ",
+        "bbox": [
+            173,
+            635,
+            825,
+            787
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Evaluating disentangled representations. The BetaVAE (Higgins et al., 2017a) and FactorVAE (Kim & Mnih, 2018) scores measure disentanglement by performing an intervention on the factors of variation and predicting which factor was intervened on. The Mutual Information Gap (MIG) (Chen et al., 2018), Modularity (Ridgeway & Mozer, 2018), DCI Disentanglement (Eastwood & Williams, 2018) and SAP scores (Kumar et al., 2018) are based on matrices relating factors of variation and codes (e.g. pairwise mutual information, feature importance and predictability). ",
+        "bbox": [
+            174,
+            803,
+            823,
+            887
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Datasets for disentanglement learning. dSprites (Higgins et al., 2017a), which consists of binary low-resolution 2D images of basic shapes, is one of the most commonly used synthetic datasets for disentanglement learning. Color-dSprites, Noisy-dSprites, and Scream-dSprites are slightly more challenging variants of dSprites. The SmallNORB dataset contains toy images rendered under different lighting conditions, elevations and azimuths (LeCun et al., 2004). Cars3D (Reed et al., 2015) exhibits different car models from Fidler et al. (2012) under different camera viewpoints. 3dshapes is a popular dataset of simple shapes in a 3D scene (Kim & Mnih, 2018). Finally, Gondal et al. (2019) proposed MPI3D, containing images of physical 3D objects with seven factors of variation, such as object color, shape, size and position available in a simulated, simulated and highly realistic rendered simulated variant. Except MPI3D which has over 1M images, the size of the other datasets is limited with only 17, 568 to 737, 280 images. All of the above datasets exhibit perfect independence of all factors, the number of possible states is on the order of 1M or less, and due to their static setting they do not allow for dynamic downstream tasks such as reinforcement learning. In addition, except for SmallNORB, the image resolution is limited to 64x64 and there are no occlusions. ",
+        "bbox": [
+            174,
+            104,
+            825,
+            297
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Other related work. Locatello et al. (2020) probed the out-of-distribution generalization of downstream tasks trained on disentangled representations. However, these representations are trained on the entire dataset. Generalization and transfer performance especially for representation learning has likewise been studied in Dayan (1993); Muandet et al. (2013); Heinze-Deml & Meinshausen (2017); Rojas-Carulla et al. (2018); Suter et al. (2019); Li et al. (2018); Arjovsky et al. (2019); Krueger et al. (2020); Gowal et al. (2020). For the role of disentanglement in causal representation learning we refer to the recent overview by Scholkopf et al. (2021). Tr ¨ auble et al. (2020) systematically investi- ¨ gated the effects of correlations between factors of variation on disentangled representation learners. Transfer of learned disentangled representations from simulation to the real world has been recently investigated by Gondal et al. (2019) on the MPI3D dataset, and previously by Higgins et al. (2017b) in the context of reinforcement learning. Sim2real transfer is of major interest in the robotic learning community, because of limited data and supervision in the real world (Tobin et al., 2017; Rusu et al., 2017; Peng et al., 2018; James et al., 2019; Yan et al., 2020; Andrychowicz et al., 2020). ",
+        "bbox": [
+            173,
+            315,
+            825,
+            496
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A new challenging dataset. Simulated images in our dataset are derived from the trifinger robot platform introduced by Wuthrich et al. ¨ (2020). The motivation for choosing this setting is that (1) it is challenging due to occlusions, correlations, and other difficulties encountered in robotic settings, (2) it requires modeling of fine details such as tip links at high resolutions, and (3) it corresponds to a robotic setup, so that learned representations can be used for control and reinforcement learning in simulation and in the real world. The scene comprises a robot finger with three joints that can be controlled to manipulate a cube in a bowl-shaped stage. Fig. 1 shows examples of scenes from our dataset. The data is generated from 7 different factors of variation (FoV) ",
+        "bbox": [
+            174,
+            550,
+            482,
+            785
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/9377971bb9cd80dd613624dc8e1083a8dd5582c86b07cd4d889581024cacc9bf.jpg",
+        "table_caption": [
+            "3 SCALING DISENTANGLED REPRESENTATIONS TO COMPLEX SCENARIOS",
+            "Table 1: Factors of variation in the proposed dataset. Values are linearly spaced in the specified intervals. Joint angles are in radians, cube positions in meters. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=2>FoV              Values</td></tr><tr><td rowspan=1 colspan=1>Upper joint</td><td rowspan=1 colspan=1>30 values in[-0.65,+0.65]</td></tr><tr><td rowspan=1 colspan=1>Middle joint     30 values in</td><td rowspan=1 colspan=1>[-0.5,+0.5]</td></tr><tr><td rowspan=1 colspan=1>Lower joint      30 values in</td><td rowspan=1 colspan=1>[-0.8,+0.8]</td></tr><tr><td rowspan=2 colspan=1>Cube position X  30 values in[-0.11, +0.11]Cube position y  30 values in[-0.11, +0.11]</td><td rowspan=1 colspan=1>+0.11]</td></tr><tr><td rowspan=1 colspan=1>[-0.11, +0.11]</td></tr><tr><td rowspan=1 colspan=1>Cube rotation    10 values in [0°,81°]</td><td rowspan=2 colspan=1>12 values in [0°,330°]</td></tr><tr><td rowspan=1 colspan=1>Cube color hue  12 values in [0°,330°]</td></tr></table>",
+        "bbox": [
+            496,
+            566,
+            823,
+            693
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "listed in Table 1. Unlike in previous datasets, not all FoVs are independent: The end-effector (the tip of the finger) can collide with the floor or the cube, resulting in infeasible combinations of the factors (see Appendix B.1). We argue that such correlations are a key feature in real-world data that is not present in existing datasets. The high FoV resolution results in approximately 1.52 billion feasible states, but the dataset itself only contains one million of them (approximately $0 . 0 6 5 \\%$ of all possible FoV combinations), realistically rendered into $1 2 8 \\times 1 2 8$ images. Additionally, we recorded an annotated dataset under the same conditions in the real-world setup: we acquired 1,809 camera images from the same viewpoint and recorded the labels of the 7 underlying factors of variation. This dataset can be used for out-of-distribution evaluations, few-shot learning, and testing other sim2real aspects. ",
+        "bbox": [
+            174,
+            785,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/f32fff0f3873c7b5bb46601dc40ae372b6d5350f2fe784b3fcf23de2e0923423.jpg",
+        "image_caption": [
+            "Figure 2: Latent traversals of a trained model that perfectly disentangles the dataset’s FoVs. In each column, all latent variables but one are fixed. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            101,
+            823,
+            252
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Model architecture. When scaling disentangled representation learning to more complex datasets, such as the one proposed here, one of the main bottlenecks in current VAE-based approaches is the flexibility of the encoder and decoder networks. In particular, using the architecture from Locatello et al. (2019b), none of the models we trained correctly captured all factors of variation or yielded high-quality reconstructions. While the increased image resolution already presents a challenge, the main practical issue in our new dataset is the level of detail that needs to be modeled. In particular, we identified the cube rotation and the lower joint position to be the factors of variation that were the hardest to capture. This is likely because these factors only produce relatively small changes in the image and hence the reconstruction error. ",
+        "bbox": [
+            174,
+            319,
+            825,
+            445
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To overcome these issues, we propose a deeper and wider neural architecture than those commonly used in the disentangled representation learning literature, where the encoder and decoder typically have 4 convolutional and 2 fully-connected layers. Our encoder consists of a convolutional layer, 10 residual blocks, and 2 fully-connected layers. Some residual blocks are followed by 1x1 convolutions that change the number of channels, or by average pooling that downsamples the tensors by a factor of 2 along the spatial dimensions. Each residual block consists of two 3x3 convolutions with a leaky ReLU nonlinearity, and a learnable scalar gating mechanism (Bachlechner et al., 2020). Overall, the encoder has 23 convolutional layers and 2 fully connected layers. The decoder mirrors this architecture, with average pooling replaced by bilinear interpolation for upsampling. The total number of parameters is approximately 16.3M. See Appendix A for further implementation details. ",
+        "bbox": [
+            174,
+            452,
+            825,
+            592
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Experimental setup. We perform a large-scale empirical study on the simulated dataset introduced above by training 1,080 $\\beta$ -VAE models.2 For further experimental details we refer the reader to Appendix A. The hyperparameter sweep is defined as follows: ",
+        "bbox": [
+            176,
+            607,
+            825,
+            650
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "• We train the models using either unsupervised learning or weakly supervised learning (Locatello et al., 2020). In the weakly supervised case, a model is trained with pairs of images that differ in $k$ factors of variation. Here we fix $k = 1$ as it was shown to lead to higher disentanglement by Locatello et al. (2020). The dataset therefore consists of $5 0 0 \\mathrm { k }$ pairs of images that differ in only one FoV.   \n• We vary the parameter $\\beta$ in $\\{ 1 , 2 , 4 \\}$ , and use linear deterministic warm-up (Bowman et al., 2015; Sønderby et al., 2016) over the first $\\{ 0 , 1 0 0 0 0 , 5 0 0 0 0 \\}$ training steps.   \n• The latent space dimensionality is in $\\{ 1 0 , 2 5 , 5 0 \\}$ .   \n• Half of the models are trained with additive noise in the input image. This choice is motivated by the fact that adding noise to the input of neural networks has been shown to be beneficial for out-of-distribution generalization (Sietsma & Dow, 1991; Bishop, 1995).   \n• Each of the 108 resulting configurations is trained with 10 random seeds. ",
+        "bbox": [
+            215,
+            661,
+            825,
+            849
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Can we scale up disentanglement learning? Most of the trained VAEs in our empirical study fully capture all the elements of a scene, correctly model heavy occlusions, and generate detailed, high-quality samples and reconstructions (see Appendix B.2). From visual inspections such as the latent traversals in Fig. 2, we observe that many trained models fully disentangle the ground-truth factors of variation. This, however, appears to only be possible in the weakly supervised scenario. The fact that models trained without supervision learn entangled representations is in line with the impossibility result for the unsupervised learning of disentangled representations from Locatello et al. (2019b). Latent traversals from a selection of models with different degrees of disentanglement are presented in Appendix B.3. Interestingly, the high-disentanglement models seem to correct for correlations and interpolate infeasible states, i.e. the fingertip traverses through the cube or the floor. ",
+        "bbox": [
+            176,
+            871,
+            825,
+            900
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/88ab1de0ae19149e0481ebac85d3f259b45588c758c6f7f48f60d62f133c98e3.jpg",
+        "image_caption": [
+            "Figure 3: Left: Disentanglement metrics aggregating all hyperparameters except for supervision type. Right: Rank correlations (Spearman) of ELBO, reconstruction loss, and the test error of a GBT classifier trained on 10,000 labelled data points with disentanglement metrics. The upper rank correlations correspond to the unsupervised models and the lower to the weakly supervised models. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            223,
+            111,
+            797,
+            290
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            392,
+            825,
+            503
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Summary: The proposed architecture can scale disentanglement learning to more realistic settings, but a form of weak supervision is necessary to achieve high disentanglement. ",
+        "bbox": [
+            174,
+            511,
+            821,
+            539
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "How useful are common disentanglement metrics in realistic scenarios? The violin plot in Fig. 3 (left) shows that DCI and MIG measure high disentanglement under weak supervision and lower disentanglement in the unsupervised setting. This is consistent with our qualitative conclusion from visual inspection of the models (Appendix B.3) and with the aforementioned impossibility result. Many of the models trained with weak supervision exhibit a very high DCI score $2 9 \\%$ of them have ${ > } 9 9 \\%$ DCI, some of them up to $9 9 . 8 9 \\%$ ). SAP and Modularity appear to be ineffective at capturing disentanglement in this setting, as also observed by Locatello et al. (2019b). Finally, note that the BetaVAE and FactorVAE metrics are not straightforward to be evaluated on datasets that do not contain all possible combinations of factor values. According to Fig. 3 (right), DCI and MIG strongly correlate with test accuracy of GBT classifiers predicting the FoVs. In the weakly supervised setting, these metrics are strongly correlated with the ELBO (positively) and with the reconstruction loss (negatively). We illustrate these relationships in more detail in Appendix B.4. Such correlations were also observed by Locatello et al. (2020) on significantly less complex datasets, and can be exploited for unsupervised model selection: these unsupervised metrics can be used as proxies for disentanglement metrics, which would require fully labeled data. ",
+        "bbox": [
+            174,
+            556,
+            825,
+            763
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Summary: DCI and MIG appear to be useful disentanglement metrics in realistic scenarios, whereas other metrics seem to fall short of capturing disentanglement or can be difficult to compute. When using weak supervision, we can select disentangled models with unsupervised metrics. ",
+        "bbox": [
+            174,
+            771,
+            825,
+            813
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 FRAMEWORK FOR THE EVALUATION OF OOD GENERALIZATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            835,
+            740,
+            852
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Previous work has focused on evaluating the usefulness of disentangled representations for various downstream tasks, such as predicting ground truth factors of variation, fair classification, and abstract reasoning. Here we propose a new framework for evaluating the out-of-distribution (OOD) generalization properties of representations. More specifically, we consider a downstream task – in our case, regression of ground truth factors – trained on a learned representation of the data, and evaluate the performance on a held-out test set. While the test set typically follows the same distribution as the training set (in-distribution generalization), we also consider test sets that follow a different distribution (out-of-distribution generalization). Our goal is to investigate to what extent, if at all, downstream tasks trained on disentangled representations exhibit a higher degree of OOD generalization than those trained on entangled representations. ",
+        "bbox": [
+            176,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Let $D$ denote the training set for disentangled representation learning. To investigate OOD generalization, we train downstream regression models on a subset $D _ { 1 } \\subset D$ to predict ground truth factor values from the learned representation computed by the encoder. We independently train one predictor per factor. We then test the regression models on a set $D _ { 2 }$ that differs distributionally from the training set $D _ { 1 }$ , as it either contains images corresponding to held-out values of a chosen FoV (e.g. unseen object colors), or it consists of real-world images. We now differentiate between two scenarios: (1) $D _ { 2 } \\subset D$ , i.e. the OOD test set is a subset of the dataset for representation learning; (2) $D$ and $D _ { 2 }$ are disjoint and distributionally different. These two scenarios will be denoted by $O O D I$ and $O O D 2$ , respectively. For example, consider the case in which distributional shifts are based on one FoV: the color of the object. Then, we could define these datasets such that images in $D$ always contain a red or blue object, and those in $D _ { 1 } \\subset D$ always contain a red object. In the OOD1 scenario, images in $D _ { 2 }$ would always contain a blue object, whereas in the OOD2 case they would always contain an object that is neither red nor blue. ",
+        "bbox": [
+            174,
+            194,
+            825,
+            375
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The regression models considered here are Gradient Boosted Trees (GBT), random forests, and MLPs with $\\{ 1 , 2 , 3 \\}$ hidden layers. Since random forests exhibit a similar behavior to GBTs, and all MLPs yield similar results to each other, we choose GBTs and the 2-layer MLP as representative models and only report results for those. To quantify prediction quality, we normalize the ground truth factor values to the range $[ 0 , 1 ]$ , and compute the mean absolute error (MAE). Since the values are normalized, we can define our transfer metric as the average of the MAE over all factors (except for the FoV that is OOD). ",
+        "bbox": [
+            174,
+            382,
+            825,
+            479
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 BENEFITS AND TRANSFER OF STRUCTURED REPRESENTATIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            502,
+            733,
+            518
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Experimental setup. We evaluate the transfer metric introduced in Section 4 across all 1,080 trained models. To compute this metric, we train regression models to predict the ground truth factors of variation, and test them under distributional shift. We consider distributional shifts in terms of cube color or sim2real, and we do not evaluate downstream prediction of cube color. We report scores for two different regression models: a Gradient Boosted Tree (GBT) and an MLP with 2 hidden layers of size 256. In Appendix A we provide details on the datasets used in this section. ",
+        "bbox": [
+            174,
+            536,
+            825,
+            619
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In the OOD1 setting, we have $D _ { 2 } ~ \\subset ~ D$ , hence the encoder is in-distribution: we are testing the predictor on representations of images that were in the training set of the representation learning algorithm. Therefore, we expect the representations to be meaningful. We consider three scenarios: ",
+        "bbox": [
+            174,
+            626,
+            821,
+            669
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "OOD1-A: The regression models are trained on 1 cube color (red) and evaluated on the remaining 7 colors. OOD1-B: The regression models are trained on 4 cube colors with high hue in the HSV space, and evaluated on 4 cube colors with low hue (extrapolation). OOD1-C: The regression models are again trained and evaluated on 4 cube colors, but the training and evaluation colors are alternating along the hue dimension (interpolation). ",
+        "bbox": [
+            215,
+            681,
+            825,
+            782
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In the more challenging setting where even the encoder goes out-of-distribution (OOD2, with $D _ { 2 } \\cap$ $D = \\varnothing$ ), we train the regression models on a subset of the training set $D$ that includes all 8 cube colors, and we consider the two following scenarios: ",
+        "bbox": [
+            178,
+            795,
+            825,
+            837
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "• OOD2-A: The regression models are evaluated on simulated data, on 4 cube colors that are out of the encoder’s training distribution.   \n• OOD2-B: The regression models are evaluated on real-world images of the robotic setup, without any adaptation or fine-tuning. ",
+        "bbox": [
+            217,
+            849,
+            825,
+            915
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/a8917eeb133d6b5669d032b13e81cac11e7185bed02ca42aee8c10d3256aab63.jpg",
+        "image_caption": [
+            "Figure 4: Higher disentanglement corresponds to better generalization across all OOD1 scenarios, as seen from the transfer scores (left). The transfer score is computed as the mean absolute prediction error of ground truth factor values (lower is better). This correlation is particularly evident in the GBT case, whereas MLPs appear to exhibit better OOD1 transfer with very high disentanglement only. These results are mirrored in the Spearman rank correlations between transfer scores and disentanglement metrics (right). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            108,
+            812,
+            286
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Is disentanglement correlated with OOD1 generalization? In Fig. 4 we consistently observe a negative correlation between disentanglement and transfer error across all OOD1 settings. The correlation is mild when using MLPs, strong when using GBTs. This difference is expected, as GBTs have an axis-alignment bias whereas MLPs can – given enough data and capacity – disentangle an entangled representation more easily. Our results therefore suggest that highly disentangled representations are useful for generalizing out-of-distribution as long as the encoder remains in-distribution. This is in line with the correlation found by Locatello et al. (2019b) between disentanglement and the GBT10000 metric. There, however, GBTs are tested on the same distribution as the training distribution, while here we test them under distributional shift. Given that the computation of disentanglement scores requires labels, this is of little benefit in the unsupervised setting. However, it can be exploited in the weakly supervised setting, where disentanglement was shown to correlate with ELBO and reconstruction loss (Section 3). Therefore, model selection for representations that transfer well in these scenarios is feasible based on the ELBO or reconstruction loss, when weak supervision is available. Note that, in absolute terms, the OOD generalization error with encoder in-distribution (OOD1) is very low in the high-disentanglement case (the only exception being the MLP in the OOD1-C case, with the 1-7 color split, which seems to overfit). This suggests that disentangled representations can be useful in downstream tasks even when transferring out of the training distribution. ",
+        "bbox": [
+            173,
+            422,
+            825,
+            672
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Summary: Disentanglement seems to be positively correlated with OOD generalization of downstream tasks, provided that the encoder remains in-distribution (OOD1). Since in the weakly supervised case disentanglement correlates with the ELBO and the reconstruction loss, model selection can be performed using these metrics as proxies for disentanglement. These metrics have the advantage that they can be computed without labels, unlike disentanglement metrics. ",
+        "bbox": [
+            174,
+            680,
+            823,
+            750
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Is disentanglement correlated with OOD2 generalization? As seen in Fig. 5, the negative correlation between disentanglement and GBT transfer error is weaker when the encoder is out of distribution (OOD2). Nonetheless, we observe a non-negligible correlation for GBTs in the OOD2- A case, where we investigate out-of-distribution generalization along one FoV, with observations in $D _ { 2 }$ still generated from the same simulator. In the OOD2-B setting, where the observations are taken from cameras in the corresponding real-world setting, the correlation between disentanglement and transfer performance appears to be minor at best. This scenario can be considered a variant of zero-shot sim2real generalization. ",
+        "bbox": [
+            174,
+            776,
+            825,
+            888
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Summary: Disentanglement has a minor effect on out-of-distribution generalization outside of the training distribution of the encoder (OOD2). ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/3caa155b0e0c7e7a7836a9f63f3aa28e051c3f1d453968d716ec81ac3a38a25e.jpg",
+        "image_caption": [
+            "Figure 5: Disentanglement affects generalization across the OOD2 scenarios only minimally as seen from transfer scores (left) and corresponding rank correlations with disentanglement metrics (right). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            259,
+            109,
+            733,
+            301
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/8a3bf47d3eed60551e8542f6371b5044c44bfa24971224373ae2079c5152b46a.jpg",
+        "image_caption": [
+            "Figure 6: Noise improves generalization across the OOD2 scenarios and less so for the OOD1 scenarios as seen from the transfer scores. Top row: Spearman rank correlation coefficients between transfer metrics and presence of noise in the input. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            414,
+            805,
+            617
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "What else matters for OOD2 generalization? Results in Fig. 6 suggest that adding Gaussian noise to the input during training as described in Section 3 leads to significantly better OOD2 generalization, and has no effect on OOD1 generalization. Adding noise to the input of neural networks is known to lead to better generalization (Sietsma & Dow, 1991; Bishop, 1995). This is in agreement with our results, since OOD1 generalization does not require generalization of the encoder, while OOD2 does. Interestingly, closer inspection reveals that the contribution of different factors of variation to the generalization error can vary widely. See Appendix B.5 for further details. In particular, with noisy input, the position of the cube is predicted accurately even in real-world images ${ < } 5 \\%$ mean absolute error on each axis). This is promising for robotics applications, where the true state of the joints is observable but inference of the cube position relies on object tracking methods. Fig. 7 shows an example of real-world inputs and reconstructions of their simulated equivalents. ",
+        "bbox": [
+            173,
+            734,
+            825,
+            888
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Summary: Adding input noise during training appears to be significantly beneficial for OOD2 generalization, while having no effect when the encoder is kept in its training distribution (OOD1). ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            318,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Despite the growing importance of the field and the potential societal impact in the medical domain (Chartsias et al., 2018) and fair decision making (Locatello et al., 2019a), state-of-the-art approaches for learning disentangled representations have so far only been systematically evaluated on synthetic toy datasets. Here we introduced a new high-resolution dataset with 1M simulated images and over 1,800 annotated real-world images of the same setup. This dataset exhibits a number of challenges and features which are not present in previous datasets: it contains correlations between factors, occlusions, a complex underlying structure, and it allows for evaluation of transfer to unseen simulated and real-world settings. We proposed a new VAE architecture to scale disentangled representation learning to this realistic setting and conducted a large-scale empirical study of disentangled representations on this dataset. We discovered that disentanglement is a good predictor of OOD generalization of downstream tasks and showed that, in the context of weak supervision, model selection for good OOD performance can be based on the ELBO or the reconstruction loss, which are accessible without explicit labels. Our setting allows for studying a wide variety of interesting downstream tasks in the future, such as reinforcement learning or learning a dynamics model of the environment. Finally, we believe that in the future it will be important to take further steps in the direction of this paper by considering settings with even more complex structures and stronger correlations between factors. ",
+        "bbox": [
+            174,
+            132,
+            825,
+            188
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            188,
+            633,
+            436
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/80cc02fdfea336501807be97fe20f51feac8677170955d3731e106b2859b088b.jpg",
+        "image_caption": [
+            "Figure 7: Zero-shot transfer to real-world observations of our models trained in simulation. Left: input; right: reconstruction. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            647,
+            205,
+            823,
+            344
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGEMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            454,
+            334,
+            467
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The authors thank Shruti Joshi and Felix Widmaier for their useful comments on the simulated setup, Anirudh Goyal for helpful discussions and comments, and CIFAR for the support. We thank the International Max Planck Research School for Intelligent Systems (IMPRS-IS) for supporting Frederik Trauble.¨ ",
+        "bbox": [
+            174,
+            477,
+            825,
+            532
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            553,
+            285,
+            568
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Tameem Adel, Zoubin Ghahramani, and Adrian Weller. Discovering interpretable representations for both deep generative and discriminative models. In International Conference on Machine Learning, pp. 50–59, 2018. ",
+        "bbox": [
+            174,
+            575,
+            825,
+            617
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "OpenAI: Marcin Andrychowicz, Bowen Baker, Maciek Chociej, Rafal Jozefowicz, Bob McGrew, Jakub Pachocki, Arthur Petron, Matthias Plappert, Glenn Powell, Alex Ray, et al. Learning dexterous in-hand manipulation. The International Journal of Robotics Research, 39(1):3–20, 2020. ",
+        "bbox": [
+            174,
+            625,
+            823,
+            680
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Martin Arjovsky, Leon Bottou, Ishaan Gulrajani, and David Lopez-Paz. Invariant risk minimization. ´ arXiv preprint arXiv:1907.02893, 2019. ",
+        "bbox": [
+            173,
+            688,
+            821,
+            717
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Francis Bach and Michael Jordan. Kernel independent component analysis. Journal of Machine Learning Research, 3(7):1–48, 2002. ",
+        "bbox": [
+            173,
+            723,
+            823,
+            752
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Thomas Bachlechner, Bodhisattwa Prasad Majumder, Huanru Henry Mao, Garrison W Cottrell, and Julian McAuley. Rezero is all you need: Fast convergence at large depth. arXiv preprint arXiv:2003.04887, 2020. ",
+        "bbox": [
+            174,
+            760,
+            823,
+            803
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Chris M Bishop. Training with noise is equivalent to tikhonov regularization. Neural computation, 7(1):108–116, 1995. ",
+        "bbox": [
+            173,
+            809,
+            823,
+            838
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Samuel R Bowman, Luke Vilnis, Oriol Vinyals, Andrew M Dai, Rafal Jozefowicz, and Samy Bengio. Generating sentences from a continuous space. arXiv preprint arXiv:1511.06349, 2015. ",
+        "bbox": [
+            171,
+            844,
+            821,
+            875
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Christopher P Burgess, Irina Higgins, Arka Pal, Loic Matthey, Nick Watters, Guillaume Desjardins, and Alexander Lerchner. Understanding disentangling in beta-VAE. arXiv preprint arXiv:1804.03599, 2018. ",
+        "bbox": [
+            173,
+            881,
+            821,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Agisilaos Chartsias, Thomas Joyce, Giorgos Papanastasiou, Scott Semple, Michelle Williams, David Newby, Rohan Dharmakumar, and Sotirios A Tsaftaris. Factorised spatial representation learning: Application in semi-supervised myocardial segmentation. In International Conference on Medical Image Computing and Computer-Assisted Intervention, pp. 490–498. Springer, 2018. ",
+        "bbox": [
+            176,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tian Qi Chen, Xuechen Li, Roger Grosse, and David Duvenaud. Isolating sources of disentanglement in variational autoencoders. In Advances in Neural Information Processing Systems, 2018. ",
+        "bbox": [
+            176,
+            170,
+            821,
+            199
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Pierre Comon. Independent component analysis, a new concept? Signal Processing, 36(3):287–314, 1994. ",
+        "bbox": [
+            174,
+            210,
+            823,
+            239
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Peter Dayan. Improving generalization for temporal difference learning: The successor representation. Neural Computation, 5(4):613–624, 1993. ",
+        "bbox": [
+            173,
+            251,
+            823,
+            280
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Cian Eastwood and Christopher KI Williams. A framework for the quantitative evaluation of disentangled representations. In International Conference on Learning Representations, 2018. ",
+        "bbox": [
+            173,
+            290,
+            821,
+            319
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sanja Fidler, Sven Dickinson, and Raquel Urtasun. 3d object detection and viewpoint estimation with a deformable 3d cuboid model. In Advances in neural information processing systems, pp. 611–619, 2012. ",
+        "bbox": [
+            174,
+            330,
+            823,
+            372
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Muhammad Waleed Gondal, Manuel Wuthrich, Djordje Miladinovi ¨ c, Francesco Locatello, Martin ´ Breidt, Valentin Volchkov, Joel Akpo, Olivier Bachem, Bernhard Scholkopf, and Stefan Bauer. ¨ On the transfer of inductive bias from simulation to the real world: a new disentanglement dataset. In Advances in Neural Information Processing Systems, 2019. ",
+        "bbox": [
+            173,
+            383,
+            825,
+            440
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sven Gowal, Chongli Qin, Po-Sen Huang, Taylan Cemgil, Krishnamurthy Dvijotham, Timothy Mann, and Pushmeet Kohli. Achieving robustness in the wild via adversarial mixing with disentangled representations. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 1211–1220, 2020. ",
+        "bbox": [
+            174,
+            450,
+            825,
+            508
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Luigi Gresele, Paul K. Rubenstein, Arash Mehrjou, Francesco Locatello, and Bernhard Scholkopf.¨ The incomplete rosetta stone problem: Identifiability results for multi-view nonlinear ica. In Conference on Uncertainty in Artificial Intelligence (UAI), 2019. ",
+        "bbox": [
+            173,
+            518,
+            825,
+            563
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Christina Heinze-Deml and Nicolai Meinshausen. Conditional variance penalties and domain shift robustness. arXiv preprint arXiv:1710.11469, 2017. ",
+        "bbox": [
+            173,
+            571,
+            823,
+            602
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Irina Higgins, Loic Matthey, Arka Pal, Christopher Burgess, Xavier Glorot, Matthew Botvinick, Shakir Mohamed, and Alexander Lerchner. beta-VAE: Learning basic visual concepts with a constrained variational framework. In International Conference on Learning Representations, 2017a. ",
+        "bbox": [
+            174,
+            612,
+            825,
+            669
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Irina Higgins, Arka Pal, Andrei Rusu, Loic Matthey, Christopher Burgess, Alexander Pritzel, Matthew Botvinick, Charles Blundell, and Alexander Lerchner. Darla: Improving zero-shot transfer in reinforcement learning. In International Conference on Machine Learning, 2017b. ",
+        "bbox": [
+            176,
+            679,
+            823,
+            723
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Irina Higgins, Nicolas Sonnerat, Loic Matthey, Arka Pal, Christopher P Burgess, Matko Bosnjak, ˇ Murray Shanahan, Matthew Botvinick, Demis Hassabis, and Alexander Lerchner. Scan: Learning hierarchical compositional visual concepts. In International Conference on Learning Representations, 2018. ",
+        "bbox": [
+            173,
+            733,
+            825,
+            790
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Aapo Hyvarinen and Hiroshi Morioka. Unsupervised feature extraction by time-contrastive learning and nonlinear ica. In Advances in Neural Information Processing Systems, 2016. ",
+        "bbox": [
+            169,
+            801,
+            823,
+            830
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Aapo Hyvarinen and Petteri Pajunen. Nonlinear independent component analysis: Existence and ¨ uniqueness results. Neural Networks, 1999. ",
+        "bbox": [
+            171,
+            842,
+            823,
+            869
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Aapo Hyvarinen, Hiroaki Sasaki, and Richard E Turner. Nonlinear ica using auxiliary variables and generalized contrastive learning. In International Conference on Artificial Intelligence and Statistics, 2019. ",
+        "bbox": [
+            176,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Stephen James, Paul Wohlhart, Mrinal Kalakrishnan, Dmitry Kalashnikov, Alex Irpan, Julian Ibarz, Sergey Levine, Raia Hadsell, and Konstantinos Bousmalis. Sim-to-real via sim-to-sim: Dataefficient robotic grasping via randomized-to-canonical adaptation networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 12627–12637, 2019. ",
+        "bbox": [
+            174,
+            103,
+            826,
+            160
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Christian Jutten and Juha Karhunen. Advances in nonlinear blind source separation. In International Symposium on Independent Component Analysis and Blind Signal Separation, pp. 245–256, 2003. ",
+        "bbox": [
+            176,
+            170,
+            823,
+            199
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ilyes Khemakhem, Diederik Kingma, Ricardo Monti, and Aapo Hyvarinen. Variational autoencoders and nonlinear ica: A unifying framework. In International Conference on Artificial Intelligence and Statistics, pp. 2207–2217, 2020. ",
+        "bbox": [
+            173,
+            208,
+            825,
+            252
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Hyunjik Kim and Andriy Mnih. Disentangling by factorising. In International Conference on Machine Learning, 2018. ",
+        "bbox": [
+            173,
+            262,
+            823,
+            291
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            171,
+            301,
+            825,
+            330
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Max Welling. Auto-encoding variational Bayes. In International Conference on Learning Representations, 2014. ",
+        "bbox": [
+            169,
+            340,
+            825,
+            369
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "David Klindt, Lukas Schott, Yash Sharma, Ivan Ustyuzhaninov, Wieland Brendel, Matthias Bethge, and Dylan Paiton. Towards nonlinear disentanglement in natural data with temporal sparse coding. arXiv preprint arXiv:2007.10930, 2020. ",
+        "bbox": [
+            174,
+            378,
+            823,
+            421
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "David Krueger, Ethan Caballero, Joern-Henrik Jacobsen, Amy Zhang, Jonathan Binas, Remi Le Priol, and Aaron Courville. Out-of-distribution generalization via risk extrapolation (rex). arXiv preprint arXiv:2003.00688, 2020. ",
+        "bbox": [
+            173,
+            431,
+            825,
+            474
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Abhishek Kumar, Prasanna Sattigeri, and Avinash Balakrishnan. Variational inference of disentangled latent concepts from unlabeled observations. In International Conference on Learning Representations, 2018. ",
+        "bbox": [
+            173,
+            484,
+            825,
+            529
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Fu Jie Huang, and Leon Bottou. Learning methods for generic object recognition with invariance to pose and lighting. In IEEE Conference on Computer Vision and Pattern Recognition, 2004. ",
+        "bbox": [
+            174,
+            537,
+            823,
+            580
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ya Li, Xinmei Tian, Mingming Gong, Yajing Liu, Tongliang Liu, Kun Zhang, and Dacheng Tao. Deep domain generalization via conditional invariant adversarial networks. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 624–639, 2018. ",
+        "bbox": [
+            178,
+            590,
+            825,
+            633
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Francesco Locatello, Gabriele Abbati, Thomas Rainforth, Stefan Bauer, Bernhard Scholkopf, and ¨ Olivier Bachem. On the fairness of disentangled representations. In Advances in Neural Information Processing Systems, pp. 14611–14624, 2019a. ",
+        "bbox": [
+            174,
+            643,
+            825,
+            688
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Francesco Locatello, Stefan Bauer, Mario Lucic, Sylvain Gelly, Bernhard Scholkopf, and Olivier ¨ Bachem. Challenging common assumptions in the unsupervised learning of disentangled representations. In International Conference on Machine Learning, 2019b. ",
+        "bbox": [
+            173,
+            696,
+            825,
+            739
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Francesco Locatello, Ben Poole, Gunnar Ratsch, Bernhard Sch¨ olkopf, Olivier Bachem, and¨ Michael Tschannen. Weakly-supervised disentanglement without compromises. arXiv preprint arXiv:2002.02886, 2020. ",
+        "bbox": [
+            173,
+            750,
+            825,
+            792
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Krikamol Muandet, David Balduzzi, and Bernhard Scholkopf. Domain generalization via invariant ¨ feature representation. In International Conference on Machine Learning, pp. 10–18, 2013. ",
+        "bbox": [
+            168,
+            803,
+            825,
+            833
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xue Bin Peng, Marcin Andrychowicz, Wojciech Zaremba, and Pieter Abbeel. Sim-to-real transfer of robotic control with dynamics randomization. In 2018 IEEE international conference on robotics and automation (ICRA), pp. 1–8. IEEE, 2018. ",
+        "bbox": [
+            173,
+            842,
+            823,
+            885
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Scott Reed, Yi Zhang, Yuting Zhang, and Honglak Lee. Deep visual analogy-making. In Advances in Neural Information Processing Systems, 2015. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Danilo Jimenez Rezende, Shakir Mohamed, and Daan Wierstra. Stochastic backpropagation and approximate inference in deep generative models. arXiv preprint arXiv:1401.4082, 2014. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            133
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Karl Ridgeway and Michael C Mozer. Learning deep disentangled embeddings with the f-statistic loss. In Advances in Neural Information Processing Systems, 2018. ",
+        "bbox": [
+            173,
+            140,
+            823,
+            171
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Mateo Rojas-Carulla, Bernhard Scholkopf, Richard Turner, and Jonas Peters. Invariant models for ¨ causal transfer learning. The Journal of Machine Learning Research, 19(1):1309–1342, 2018. ",
+        "bbox": [
+            173,
+            178,
+            823,
+            208
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Andrei A Rusu, Matej Vecer ˇ ´ık, Thomas Rothorl, Nicolas Heess, Razvan Pascanu, and Raia Hadsell. ¨ Sim-to-real robot learning from pixels with progressive nets. In Conference on Robot Learning, pp. 262–270, 2017. ",
+        "bbox": [
+            173,
+            215,
+            825,
+            258
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Bernhard Scholkopf, Francesco Locatello, Stefan Bauer, Nan Rosemary Ke, Nal Kalchbrenner, ¨ Anirudh Goyal, and Yoshua Bengio. Towards causal representation learning. arXiv preprint arXiv:2102.11107, 2021. ",
+        "bbox": [
+            173,
+            267,
+            825,
+            310
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Rui Shu, Yining Chen, Abhishek Kumar, Stefano Ermon, and Ben Poole. Weakly supervised disentanglement with guarantees. arXiv preprint arXiv:1910.09772, 2019. ",
+        "bbox": [
+            171,
+            319,
+            823,
+            349
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jocelyn Sietsma and Robert JF Dow. Creating artificial neural networks that generalize. Neural networks, 4(1):67–79, 1991. ",
+        "bbox": [
+            173,
+            357,
+            823,
+            387
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Casper Kaae Sønderby, Tapani Raiko, Lars Maaløe, Søren Kaae Sønderby, and Ole Winther. Ladder variational autoencoders. In Advances in neural information processing systems, pp. 3738–3746, 2016. ",
+        "bbox": [
+            173,
+            395,
+            826,
+            438
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Peter Sorrenson, Carsten Rother, and Ullrich Kothe. Disentanglement by nonlinear ica with general ¨ incompressible-flow networks (gin). arXiv preprint arXiv:2001.04872, 2020. ",
+        "bbox": [
+            171,
+            446,
+            821,
+            476
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Raphael Suter, Djordje Miladinovic, Bernhard Scholkopf, and Stefan Bauer. Robustly disentangled ¨ causal mechanisms: Validating deep representations for interventional robustness. In International Conference on Machine Learning, pp. 6056–6065. PMLR, 2019. ",
+        "bbox": [
+            174,
+            484,
+            825,
+            527
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Josh Tobin, Rachel Fong, Alex Ray, Jonas Schneider, Wojciech Zaremba, and Pieter Abbeel. Domain randomization for transferring deep neural networks from simulation to the real world. In 2017 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), pp. 23–30. IEEE, 2017. ",
+        "bbox": [
+            173,
+            535,
+            825,
+            592
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Frederik Trauble, Elliot Creager, Niki Kilbertus, Francesco Locatello, Andrea Dittadi, Anirudh ¨ Goyal, Bernhard Scholkopf, and Stefan Bauer. On disentangled representations learned from ¨ correlated data. arXiv preprint arXiv:2006.07886, 2020. ",
+        "bbox": [
+            174,
+            601,
+            823,
+            645
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sjoerd van Steenkiste, Francesco Locatello, Jurgen Schmidhuber, and Olivier Bachem. Are disen- ¨ tangled representations helpful for abstract visual reasoning? arXiv preprint arXiv:1905.12506, 2019. ",
+        "bbox": [
+            174,
+            652,
+            823,
+            695
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Manuel Wuthrich, Felix Widmaier, Felix Grimminger, Joel Akpo, Shruti Joshi, Vaibhav Agrawal, ¨ Bilal Hammoud, Majid Khadiv, Miroslav Bogdanovic, Vincent Berenz, et al. Trifinger: An opensource robot for learning dexterity. arXiv preprint arXiv:2008.03596, 2020. ",
+        "bbox": [
+            176,
+            704,
+            821,
+            748
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Mengyuan Yan, Qingyun Sun, Iuri Frosio, Stephen Tyree, and Jan Kautz. How to close sim-real gap? transfer with segmentation! arXiv preprint arXiv:2005.07695, 2020. ",
+        "bbox": [
+            174,
+            756,
+            821,
+            786
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A IMPLEMENTATION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            441,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Training. We train the $\\beta$ -VAEs by maximizing the following objective function: ",
+        "bbox": [
+            174,
+            132,
+            712,
+            148
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0307c6ea7f97f101ff05f2ef067136a3017b2b09a827dcf3cbe4662854ffa4c8.jpg",
+        "text": "$$\n\\mathcal { L } _ { V A E } ^ { \\beta } = \\mathbb { E } _ { q _ { \\phi } ( z | \\mathbf { x } ) } [ \\log p _ { \\theta } ( \\mathbf { x } | z ) ] - \\beta D _ { \\mathrm { K L } } ( q _ { \\phi } ( z | \\mathbf { x } ) \\| p ( z ) ) \\leq \\log p ( \\mathbf { x } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            272,
+            154,
+            725,
+            175
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "with $\\beta > 0$ using the Adam optimizer (Kingma & Ba, 2014) with default parameters. We use a batch size of 64 and train for 400k steps. The learning rate is initialized to 1e-4 and halved at 150k and $3 0 0 \\mathrm { k }$ training steps. We clip the global gradient norm to 1.0 before each weight update. Following Locatello et al. (2019b), we use a Gaussian encoder with an isotropic Gaussian prior for the latent variable, and a Bernoulli decoder. Our implementation of weakly supervised learning is based on Ada-GVAE (Locatello et al., 2020), but uses a symmetrized KL divergence: ",
+        "bbox": [
+            173,
+            179,
+            825,
+            263
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3abfb9868a07569e8fa29284dda40528e9ba74cacc760330065457021dad3114.jpg",
+        "text": "$$\n\\tilde { D } _ { \\mathrm { K L } } ( p , q ) = \\frac { 1 } { 2 } D _ { \\mathrm { K L } } ( p \\Vert q ) + \\frac { 1 } { 2 } D _ { \\mathrm { K L } } ( q \\Vert p )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            361,
+            268,
+            637,
+            299
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "to infer which latent dimensions should be aggregated. ",
+        "bbox": [
+            176,
+            304,
+            531,
+            319
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The noise added to the encoder’s input consists of two independent components, both iid Gaussian with zero mean: one is independent for each subpixel (RGB) and has standard deviation 0.03, the other is a $8 \\times 8$ pixel-wise (greyscale) noise with standard deviation 0.15, bilinearly upsampled by a factor of 16. The latter has been designed (by visual inspection) to roughly mimic observation noise in the real images due to complex lighting conditions. ",
+        "bbox": [
+            173,
+            325,
+            825,
+            396
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Neural architecture. Architectural details are provided in Tables 2 and 3, and Fig. 8 provides a high-level overview. In preliminary experiments, we observed that batch normalization, layer normalization, and dropout did not significantly affect performance in terms of ELBO, model samples, and disentanglement scores, both in the unsupervised and weakly supervised settings. On the other hand, layer normalization before the posterior parameterization (last layer of the encoder) appeared to be beneficial for stability in early training. While using an architecture based on residual blocks leads to fast convergence, in practice we observed that it may be challenging to keep the gradients in check at the beginning of training.3 In order to solve this issue, we resorted to a simple scalar gating mechanism in the residual blocks (Bachlechner et al., 2020) such that each residual block is initialized to the identity. ",
+        "bbox": [
+            173,
+            410,
+            825,
+            549
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Datasets and OOD evaluation. Because we evaluate OOD generalization in terms of cube color hue (except in the sim2real case), we first sampled 8 color hues at random from the 12 specified in Table 1. The chosen hues are: $[ 0 ^ { \\circ } , 1 2 0 ^ { \\circ }$ , $1 5 0 ^ { \\circ }$ , $1 8 0 ^ { \\circ }$ , $2 1 0 ^ { \\circ }$ , $2 7 0 ^ { \\circ }$ , $3 0 0 ^ { \\circ } , 3 3 0 ^ { \\circ } ]$ ]. Then, the dataset $D$ used for training VAEs is generated by randomly sampling values for the factors of variation from Table 1, with the color hue restricted to the above-mentioned values. This makes OOD2 evaluation possible, specifically OOD2-A where the learned predictors are tested on representations extracted from images with held-out values of the cube hue. ",
+        "bbox": [
+            174,
+            564,
+            825,
+            662
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "For evaluation of out-of-distribution generalization, we train the downstream predictors on a subset $D _ { 1 } \\subset D$ of the representation training set. The downstream training set $D _ { 1 }$ is sampled at random from $D$ but only contains a (not necessarily proper) subset of the 8 cube colors. This subset contains 1 color in the OOD1-A case, 4 colors in OOD1-B and OOD1-C, all 8 colors in OOD2 (in this case $D _ { 1 }$ is simply a random subset of $D$ ). Then we test the downstream predictors on a set $D _ { 2 }$ distributionally different from $D _ { 1 }$ in terms of cube color (all OOD1 scenarios as well as OOD2-A) or sim2real (OOD2-B). In the OOD1 case, $D _ { 2 }$ is also a subset of $D$ and is generated the same way. In each OOD1 case, the test set $D _ { 2 }$ is paired with its corresponding $D _ { 1 }$ that was used to train the downstream predictors. $D _ { 2 }$ contains all colors in $D$ minus those in $D _ { 1 }$ . In the OOD2-A case, $D _ { 2 }$ is a separate dataset containing $5 \\mathrm { k }$ simulated images like those in $D$ , except that these only contain the 4 colors that were left out from the VAE training set $D$ (hue in $[ 3 0 ^ { \\circ } , 6 0 ^ { \\circ } , 9 0 ^ { \\circ } , 2 4 0 ^ { \\circ } ] )$ . In the OOD2-B case, the set $D _ { 2 }$ is the dataset of real images. Following previous work (e.g. the GBT10000 metric in Locatello et al. (2019b)), the training set $D _ { 1 }$ and test set $D _ { 2 }$ for downstream tasks contain 10k and $5 \\mathrm { k }$ images, respectively, except in the OOD2-B case, where the size is limited by the size of the real dataset. ",
+        "bbox": [
+            174,
+            670,
+            825,
+            876
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/429706c7f7cdade1885ac6d69063bcdf958294ea0f2e17be25a5fcd7e54c7899.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">Encoder</td></tr><tr><td>Operation</td><td>Output Shape</td></tr><tr><td>Input Conv 5x5, stride 2, 64 ch. LeakyReLU(0.02) 2x ResidualBlock(64)</td><td>128×128×K 64×64×64</td></tr><tr><td>Conv 1x1,128 channels AveragePool(2) 2x ResidualBlock(128)</td><td>64×64×128 32×32×128</td></tr><tr><td>AveragePool(2) 2x ResidualBlock(128) Conv 1x1,256 channels</td><td>16×16×128</td></tr><tr><td>AveragePool(2) 2x ResidualBlock(256) AveragePool(2)</td><td>16×16×256 8×8×256</td></tr><tr><td>2x ResidualBlock(256) Flatten LeakyReLU(0.02)</td><td>4×4×256 一</td></tr><tr><td></td><td>4096 512</td></tr><tr><td>FC(512) LeakyReLU(0.02) LayerNorm 2x FC(d)</td><td>一 2d</td></tr></table>",
+        "bbox": [
+            174,
+            151,
+            486,
+            476
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/39becbd30022ae3db4fa4f5a4735613ca1e1972658b03ca4f114c8ef7775526f.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">Decoder</td></tr><tr><td>Operation</td><td>Output Shape</td></tr><tr><td>Input FC(512)</td><td>d 512</td></tr><tr><td>LeakyReLU(0.02) FC(4096)</td><td></td></tr><tr><td rowspan=\"2\">Reshape 2x ResidualBlock(256) BilinearInterpolation(2)</td><td>4096 4×4×256</td></tr><tr><td></td></tr><tr><td>2x ResidualBlock(256) Conv 1x1,128 channels</td><td>8×8×256 8×8×128</td></tr><tr><td>BilinearInterpolation(2) 2x ResidualBlock(128) BilinearInterpolation(2)</td><td>16×16×128</td></tr><tr><td>2x ResidualBlock(128) Conv 1x1, 64 channels BilinearInterpolation(2)</td><td>32×32×128</td></tr><tr><td></td><td>32×32×64 64×64×64</td></tr><tr><td>2x ResidualBlock(64) BilinearInterpolation(2)</td><td></td></tr><tr><td>LeakyReLU(0.02) Conv 5x5,K channels</td><td>128×128×64 128×128×K</td></tr></table>",
+        "bbox": [
+            516,
+            151,
+            816,
+            463
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Table 2: Encoder (left) and decoder (right) architectures. The latent space dimensionality is denoted by $d$ , and $K = 3$ indicates the number of image channels. Last line in the encoder architecture: the fully connected layer parameterizing the log variance of the approximate posterior distributions of the latent variables has custom initialization. The weights are initialized with $1 / 1 0$ standard deviation than the default value, and the biases are initialized to $- 1$ instead of 0. Empirically, this together with (learnable) LayerNorm was beneficial for training stability at the beginning of training. ",
+        "bbox": [
+            173,
+            486,
+            825,
+            570
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/ea865178fb0ecfb5de1ee970723bf90e0da87d8780520ce190b0726889b1ac03.jpg",
+        "table_caption": [
+            "Table 3: Architecture of one residual block. The scalar gate is implemented by multiplying the tensor by a learnable scalar parameter before adding it to the block input. Initializing the residual block to the identity by setting this parameter to zero has been originally proposed by Bachlechner et al. (2020). The tensor shape is constant throughout the residual block. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Residual Block</td></tr><tr><td>Input: shape H × W ×C LeakyReLU(0.02) Conv 3x3, C channels</td></tr></table>",
+        "bbox": [
+            406,
+            678,
+            591,
+            804
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/9917a1686b283cacc0999471103f84041ea0591fae9eedfb47dd33f8520b29f8.jpg",
+        "image_caption": [
+            "Figure 8: Schemes of the encoder (top) and decoder (bottom) architectures. In both schemes, information flows left to right. Blue blocks represent convolutional layers: those labeled “conv” have 5x5 kernels and stride 2, while those labeled “1x1” have 1x1 kernels. Each orange block represents a pair of residual blocks (implementation details of a residual block are provided in Table 3). Green blocks in the encoder represent average pooling with stride 2, and those in the decoder denote bilinear upsampling by a factor of 2. Red blocks represent fully-connected layers. The block labeled “norm” indicates layer normalization. Dashed lines denote tensor reshaping. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            251,
+            821,
+            657
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "B ADDITIONAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            400,
+            118
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "B.1 DATASET CORRELATIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            133,
+            397,
+            148
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/a4d55e75790005f576632c767cb3647291f2b598564805a06e28a1defb1e3775.jpg",
+        "image_caption": [
+            "Figure 9: Feasible states of the 2nd and 3rd DoF when the angle of the 1st DoF is 0. Angles are in radians. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            325,
+            171,
+            669,
+            380
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/d9cb88bc4c7d6037fa6a0122b8ef412b507e8238e54f00bfd2907b6616b9ba07.jpg",
+        "image_caption": [
+            "Figure 10: Density of feasible states of 2nd and 3rd DoF over the whole training dataset. Darker shades of blue indicate regions of higher density. Angles are in radians. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            325,
+            492,
+            666,
+            703
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "B.2 SAMPLES AND RECONSTRUCTIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            460,
+            117
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/f42e6fd5a8d1605b10df96d9537dbefb0433dd74fe0de7ebeedcc06a584cf414.jpg",
+        "image_caption": [
+            "Figure 11: Samples generated by a trained model. This model was selected based on the ELBO. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            287,
+            133,
+            710,
+            459
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/8d2079514c2ede8646f1b27227273070da8929c53c342dad2407f8e7c67b358c.jpg",
+        "image_caption": [
+            "Figure 12: Input reconstructions by a trained model. This model was selected based on the ELBO. Image inputs are on odd columns, reconstructions on even columns. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            508,
+            823,
+            758
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            370,
+            117
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/ebc83f404362b5359f97ad0da34b96428f54166a8e05e75371fb287f5c60c284.jpg",
+        "image_caption": [
+            "Figure 13: Latent traversals for a model with low DCI score (0.15) in (a), medium DCI score (0.5) in (b), and high DCI score (1.0) in (c). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            228,
+            49,
+            767,
+            843
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/f547612880ffae15a6b1c2197dee451a33ac3262505aca08a5ad80dc5750e3cc.jpg",
+        "image_caption": [
+            "Figure 14: Scatter plots of unsupervised metrics (left: ELBO; right: reconstruction loss) vs disentanglement (top: MIG; bottom: DCI) for 1,080 trained models, color-coded according to supervision. Each point represents a trained model. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            137,
+            813,
+            648
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "B.5 OUT-OF-DISTRIBUTION TRANSFER ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            460,
+            117
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "image",
+        "img_path": "images/fd91b88d8f66083508e0489d539bf4f86ef58a5fa9b40c428d246dd324881699.jpg",
+        "image_caption": [
+            "Figure 15: Transfer metric in OOD2-A (top) and OOD2-B (bottom) settings, decomposed according to the factor of variation and presence of input noise. When noise is added to the input during training, the inferred cube position error is relatively low (the scores are the mean absolute error, and they are normalized to [0, 1]). This is particularly useful in the OOD2-B setting (real world) where the joint state is anyway considered known, while object position has to be inferred with tracking methods. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            214,
+            133,
+            781,
+            632
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "image",
+        "img_path": "images/baebf49c43dfc087165de52f6cc029407e610ae45792d4a34f95c68fb5f0c95b.jpg",
+        "image_caption": [
+            "Figure 16: Reconstructions of real-world images (OOD2-B) for a model with low DCI score (0.15) in (a), medium DCI score (0.5) in (b), and high DCI score (1.0) in (c). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            71,
+            766,
+            852
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "image",
+        "img_path": "images/b41979d54e732d8d4a896fb03d91db1257283803cbbaecf406efd61fd88936ae.jpg",
+        "image_caption": [
+            "Figure 17: Reconstructions of simulated images with encoder out-of-distribution colors (OOD2-A) for a model with low DCI score (0.15) in (a), medium DCI score (0.5) in (b), and high DCI score (1.0) in (c). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            230,
+            59,
+            766,
+            847
+        ],
+        "page_idx": 21
+    }
+]

parse/train/BklEF3VFPB/BklEF3VFPB.md

@@ -0,0 +1,256 @@
+# TOWARDS STABLE AND COMPREHENSIVE DOMAIN ALIGNMENT: MAX-MARGIN DOMAIN-ADVERSARIAL TRAINING
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Domain adaptation tackles the problem of transferring knowledge from a labelrich source domain to an unlabeled or label-scarce target domain. Recently domain-adversarial training (DAT) has shown promising capacity to learn a domaininvariant feature space by reversing the gradient propagation of a domain classifier. However, DAT is still vulnerable in several aspects including (1) training instability due to the overwhelming discriminative ability of the domain classifier in adversarial training, (2) restrictive feature-level alignment, and (3) lack of interpretability or systematic explanation of the learned feature space. In this paper, we propose a novel Max-margin Domain-Adversarial Training (MDAT) by designing an Adversarial Reconstruction Network (ARN). The proposed MDAT stabilizes the gradient reversing in ARN by replacing the domain classifier with a reconstruction network, and in this manner ARN conducts both feature-level and pixel-level domain alignment without involving extra network structures. Furthermore, ARN demonstrates strong robustness to a wide range of hyper-parameters settings, greatly alleviating the task of model selection. Extensive empirical results validate that our approach outperforms other state-of-the-art domain alignment methods. Additionally, the reconstructed target samples are visualized to interpret the domain-invariant feature space which conforms with our intuition.
+
+# 1 INTRODUCTION
+
+Deep neural networks have gained great success on a wide range of tasks such as visual recognition and machine translation (LeCun et al., 2015). They usually require a large number of labeled data that can be prohibitively expensive to collect, and even with sufficient supervision their performance can still be poor when being generalized to a new environment. The problem of discrepancy between the training and testing data distribution is commonly referred to as domain shift (Shimodaira, 2000). To alleviate the effect of such shift, domain adaptation sets out to obtain a model trained in a label-rich source domain to generalize well in an unlabeled target domain. Domain adaptation has benefited various applications in many practical scenarios, including but not limited to object detection under challenging conditions (Chen et al., 2018), cost-effective learning using only synthetic data to generalize to real-world imagery (Vazquez et al., 2013), etc.
+
+Prevailing methods for unsupervised domain adaptation (UDA) are mostly based on domain alignment which aims to learn domain-invariant features by reducing the distribution discrepancy between the source and target domain using some pre-defined metrics such as maximum mean discrepancy (Tzeng et al., 2014). Recently, Ganin & Lempitsky (2015) proposed to achieve domain alignment by domainadversarial training (DAT) that reverses the gradients of a domain classifier to maximize domain confusion. Having yielded remarkable performance gain, DAT was employed in many subsequent UDA methods (Long et al., 2018; Shu et al., 2018). Even so, there still exist three critical issues of DAT that hinder its performance: (1) as the domain classifier has high-capacity to discriminate two domains, the unbalanced adversarial training cannot continuously provide effective gradients, which is usually overcome by manually adjusting the weights of adversarial training according to specific tasks; (2) DAT-based methods cannot deal with pixel-level domain shift (Hoffman et al., 2018); (3) the domain-invariant features learned by DAT are only based on intuition but difficult to interpret, which impedes the investigation of the underlying mechanism of adversarial domain adaptation.
+
+To overcome the aforementioned difficulties, we propose an innovative DAT approach, namely Max-margin Domain-Adversarial Training (MDAT), to realize stable and comprehensive domain alignment. To demonstrate its effectiveness, we develop an Adversarial Reconstruction Network (ARN) that only utilizes MDAT for UDA. Specifically, ARN consists of a shared feature extractor, a label predictor, and a reconstruction network (i.e. decoder) that serves as a domain classifier. Supervised learning is conducted on source domain, and MDAT helps learn domain-invariant features. In MDAT, the decoder only focuses on reconstructing samples on source domain and pushing the target domain away from a margin, while the feature extractor aims to fool the decoder by learning to reconstruct samples on target domain. In this way, three critical issues can be solved by MDAT: (1) the max-margin loss reduces the discriminative capacity of domain classifier, leading to balanced and thus stable adversarial training; (2) without involving new network structures, MDAT achieves both pixel-level and feature-level domain alignment; (3) visualizing the reconstructed samples reveals how the source and target domains are aligned. We evaluate ARN with MDAT on five visual and non-visual UDA benchmarks. It achieves significant improvement to DAT on all tasks with pixel-level or higher-level domain shift. We also observe that it is insensitive to the choices of hyperparameters and as such is favorable for replication in practice. In principle, our approach is generic and can be used to enhance any UDA methods that leverage domain alignment as an ingredient.
+
+# 2 RELATED WORK
+
+Domain adaptation aims to transfer knowledge from one domain to another. Ben-David et al. (2010) provide an upper bound of the test error on the target domain in terms of the source error and the $\mathcal { H } \triangle \mathcal { H }$ -distance. As the source error is stationary for a fixed model, the goal of most UDA methods is to minimize the $\mathcal { H } \triangle \mathcal { H }$ -distance by reducing some metrics such as Maximum Mean Discrepancy (MMD) (Tzeng et al., 2014; Long et al., 2015) and CORAL (Sun & Saenko, 2016). Inspired by Generative Adversarial Networks (GAN) (Goodfellow et al., 2014), Ganin & Lempitsky (2015) proposed to learn domain-invariant features by adversarial training, which has inspired many UDA methods thereafter. Adversarial Discriminative Domain Adaptation (ADDA) tried to fool the label classifier by adversarial training but not in an end-to-end manner. CyCADA (Hoffman et al., 2018) and PixelDA (Bousmalis et al., 2017) leveraged GAN to conduct both feature-level and pixel-level domain adaptation, which yields significant improvement yet the network complexity is high.
+
+Another line of approaches that are relevant to our method is the reconstruction network (i.e. the decoder network). The success of image-to-image translation corroborates that it helps learn pixellevel features in an unsupervised manner. In UDA, Ghifary et al. (2016) employed a decoder network for pixel-level adaptation, and Domain Separate Network (DSN) (Bousmalis et al., 2016) further leveraged multiple reconstruction networks to learn domain-specific features. These approaches treat the decoder network as an independent component that is irrelevant to domain alignment (Glorot et al., 2011). In this paper, our approach proposes to utilize the decoder network as domain classifier in MDAT which enables both feature-level and pixel-level domain alignment in a stable and straightforward fashion.
+
+# 3 PROBLEM FORMULATION
+
+# 3.1 PROBLEM DEFINITION AND NOTATIONS
+
+In unsupervised domain adaptation, we assume that the model works with a labeled dataset $\mathbf { X } _ { S }$ and an unlabeled dataset $\mathbf { X } _ { T }$ . Let $\mathbf { X } _ { S } = \{ ( \mathbf { x } _ { i } ^ { s } , y _ { i } ^ { s } ) \} _ { i \in [ N _ { s } ] }$ denote the labeled dataset of $N _ { s }$ samples from the source domain, and the certain label $y _ { i } ^ { s }$ belongs to the label space $Y$ that is a finite set $( Y = 1 , 2 , . . . , K )$ . The other dataset $\mathbf { X } _ { T } = \{ \mathbf { x } _ { i } ^ { t } \} _ { i \in [ N _ { t } ] }$ has $N _ { t }$ samples from the target domain but has no labels. We further assume that two domains have different distributions, i.e. $\mathbf { x } _ { i } ^ { s } \sim \mathcal { D } _ { S }$ and $\mathbf { x } _ { i } ^ { t } \sim \mathcal { D } _ { T }$ . In other words, there exist some domain shift (Ben-David et al., 2010) between $\mathcal { D } _ { S }$ and $\mathcal { D } _ { T }$ . The ultimate goal is to learn a model that can predict the label $y _ { i } ^ { t }$ given the target input $\mathbf { x } _ { i } ^ { t }$ .
+
+# 3.2 IMBALANCED MINIMAX GAME IN DOMAIN-ADVERSARIAL TRAINING
+
+To achieve domain alignment, Domain-Adversarial Training (DAT) is a minimax game between a shared feature extractor $F$ for two domains and a domain classifier $D$ . The domain classifier is
+
+![](images/001311f8f21980fa16dacf066d24b3fe311eef6861e67cfc41a97be754e1ac07.jpg)  
+Figure 1: The proposed architecture is composed of a shared feature extractor $G _ { e }$ for two domains, a label predictor $G _ { y }$ and a reconstruction network $G _ { r }$ . In addition to the basic supervised learning in the source domain, our adversarial reconstruction training enables the extractor $G _ { e }$ to learn domain-invariant features. Specifically, the network $G _ { r }$ aims to reconstruct the source samples $x ^ { s }$ and to impede the reconstruction of the target samples $x ^ { t }$ , while the extractor $G _ { e }$ tries to fool the reconstruction network in order to reconstruct the target samples $x ^ { t }$ .
+
+trained to determine whether the input sample belongs to the source or the target domain while the feature extractor learns to deceive the domain classifier, which is formulated as:
+
+$$
+\operatorname* { m i n } _ { F } \operatorname* { m a x } _ { D } \mathcal { L } _ { D A T } ( D _ { s } , D _ { t } ) = \mathbb { E } _ { x \sim D _ { s } } [ \ln F ( x ) ] + \mathbb { E } _ { x \sim D _ { t } } [ \ln \left( 1 - D ( F ( x ) ) \right) ] .
+$$
+
+In DAT, we usually utilize CNN as the feature extractor and fully connected layers (FC) as the domain classifier. DAT reduces the cross-domain discrepancy, achieving significant performance improvement for UDA. Nevertheless, the training of DAT is rather unstable. Without sophisticated tuning of the hyper-parameters, DAT cannot reach the convergence. Through empirical experiments, we observe that such instability is due to the imbalanced minimax game. The binary domain classifier $D$ can easily achieve convergence with very high accuracy at an early training epoch, while it is much harder for the feature extractor $F$ to fool the domain classifier and to simultaneously perform well on the source domain. In this sense, the domain classifier dominates DAT, and the only solution is to palliate the training of $D$ by tuning the hyper-parameters according to different tasks. In our method, we restrict the capacity of the domain classifier so as to form a minimax game in a harmonious manner. Inspired by the max-margin loss in Support Vector Machine (SVM) (Cristianini et al., 2000) (i.e. hinge loss), if we push the source domain and the target domain away from a margin rather than as far as possible, then the training task of $F$ to fool $D$ becomes easier. For a binary domain classifier, we define the margin loss as
+
+$$
+\mathcal { L } _ { m a r g i n } ( y ) = [ 0 , m - t \cdot y ] ^ { + } ,
+$$
+
+where $y$ is the predicted domain label, $[ \cdot ] ^ { + } : = m a x ( 0 , \cdot )$ , $m$ is a positive margin and $t$ is the ground truth label for two domains $t = - 1$ for the source domain and $t = 1$ for the target domain). Then we introduce our MDAT scheme based on an innovative network architecture.
+
+# 3.3 MAX-MARGIN DOMAIN-ADVERSARIAL TRAINING
+
+Besides the training instability issue, DAT also suffers from restrictive feature-level alignment – lack of pixel-level alignment. To realize stable and comprehensive domain alignment together, we first propose an Adversarial Reconstruction Network (ARN) and then elaborate MDAT.
+
+As depicted in Figure 1, our model consists of three parts including a shared feature extractor $G _ { e }$ for both domains, a label predictor $G _ { y }$ and a reconstruction network $G _ { r }$ . Let the feature extractor $G _ { e } ( \mathbf { x } ; \theta _ { e } )$ be a function parameterized by $\theta _ { e }$ which maps an input sample $\mathbf { X }$ to a deep embedding z. Let the label predictor $G _ { y } ( \pmb { z } ; \theta _ { y } )$ be a task-specific function parameterized by $\theta _ { y }$ which maps an embedding $\mathbf { z }$ to a task-specific prediction $\hat { y }$ . The reconstruction network $G _ { r } ( \pmb { z } ; \bar { \theta } _ { r } )$ is a decoding function parameterized by $\theta _ { r }$ that maps an embedding $\mathbf { z }$ to its corresponding reconstruction $\hat { \bf x }$ .
+
+The first learning objective for the feature extractor $G _ { e }$ and label predictor $G _ { y }$ is to perform well in the source domain. For a supervised $\mathrm { K }$ -way classification problem, it is simply achieved by minimizing the negative log-likelihood of the ground truth class for each sample:
+
+$$
+\mathcal { L } _ { t a s k } = \sum _ { i = 1 } ^ { N _ { s } } \mathcal { L } _ { y } ( \mathbf { x } _ { i } ^ { s } , \mathbf { y } _ { i } ^ { s } ) = - \sum _ { i = 1 } ^ { N _ { s } } \mathbf { y } _ { i } ^ { s } \cdot \log G _ { y } ( G _ { e } ( \mathbf { x } _ { i } ^ { s } ; \boldsymbol { \theta } _ { e } ) ; \boldsymbol { \theta } _ { y } ) ,
+$$
+
+where $\mathbf { y } _ { i } ^ { s }$ is the one-hot encoding of the class label $y _ { i } ^ { s }$ and the logarithm operation is conducted on the softmax predictions of the model.
+
+The second objective is to render the feature learning to be domain-invariant. This is motivated by the covariate shift assumption (Shimodaira, 2000) that indicates if the feature distributions $\dot { S } ( \mathbf { z } ) = \{ G _ { e } ( \mathbf { x } ; \theta _ { e } ) | \mathbf { \bar { x } } \sim \mathcal { D } _ { S } \}$ and $T ( \mathbf { z } ) = \{ G _ { e } ( \mathbf { x } ; \boldsymbol { \theta } _ { e } ) | \mathbf { x } \sim \mathcal { D } _ { T } \}$ are similar, the source label predictor $G _ { y }$ can achieve a similar high accuracy in the target domain. To this end, we design a decoder network $G _ { r }$ that serves as a domain classifier, and then MDAT could be applied for stable training. Different from the normal binary domain classifier, MDAT lets the decoder network $G _ { r }$ only reconstruct the features in the source domain and push the features in the target domain away from a margin $m$ . In this way, the decoder has the functionality of distinguishing the source domain from the target domain. The objective of training $G _ { r }$ is formulated as
+
+$$
+\operatorname* { m i n } _ { \theta _ { r } } \sum _ { i = 1 } ^ { N _ { s } + N _ { t } } \mathcal { L } _ { m a r g i n } ( \mathcal { L } _ { r } ( \mathbf { x } _ { i } ) ) = \operatorname* { m i n } _ { \theta _ { r } } \sum _ { i = 1 } ^ { N _ { s } } \mathcal { L } _ { r } ( \mathbf { x } _ { i } ^ { s } ) + \sum _ { j = 1 } ^ { N _ { t } } [ m - \mathcal { L } _ { r } ( \mathbf { x } _ { j } ^ { t } ) ] ^ { + } ,
+$$
+
+where $m$ is a positive margin and $\textstyle { \mathcal { L } } _ { r } ( \cdot )$ is the mean squared error (MSE) term for the reconstruction loss that is defined as
+
+$$
+\mathcal { L } _ { r } ( \mathbf { x } ) = | | G _ { r } ( G _ { e } ( \mathbf { x } ; \boldsymbol { \theta } _ { e } ) ; \boldsymbol { \theta } _ { r } ) - \mathbf { x } | | _ { 2 } ^ { 2 } ,
+$$
+
+where $| | \cdot | | _ { 2 } ^ { 2 }$ denotes the squared $L _ { 2 }$ -norm.
+
+Oppositely, to form a minimax game, the feature extractor $G _ { e }$ learns to deceive $G _ { r }$ such that the learned target features are indistinguishable to the source ones, which is formulated by:
+
+$$
+\operatorname* { m i n } _ { \theta _ { e } } \sum _ { j = 1 } ^ { N _ { t } } \mathcal { L } _ { r } ( \mathbf { x } _ { j } ^ { t } ) .
+$$
+
+Then the whole learning procedure of ARN with MDAT can be formulated by:
+
+$$
+\begin{array} { l } { { \displaystyle \operatorname* { m i n } _ { \theta _ { e } , \theta _ { c } } \sum _ { i = 1 } ^ { N _ { s } } } \mathcal { L } _ { y } ( \mathbf { x } _ { i } ^ { s } , \mathbf { y } _ { i } ^ { s } ) + \alpha \sum _ { j = 1 } ^ { N _ { t } } \mathcal { L } _ { r } ( \mathbf { x } _ { j } ^ { t } ) , \ ~ } \\ { { \displaystyle \operatorname* { m i n } _ { \theta _ { r } } \sum _ { i = 1 } ^ { N _ { s } } } \mathcal { L } _ { r } ( \mathbf { x } _ { i } ^ { s } ) + \sum _ { j = 1 } ^ { N _ { t } } [ m - \mathcal { L } _ { r } ( \mathbf { x } _ { j } ^ { t } ) ] ^ { + } , \ ~ } \end{array}
+$$
+
+where $\mathcal { L } _ { y }$ denotes the negative log-likelihood of the ground truth class for labeled sample $\left( \mathbf { x } _ { i } ^ { s } , \mathbf { y } _ { i } ^ { s } \right)$ and $\alpha$ controls the interaction of the loss terms. In the following section, we provide theoretical justifications on how MDAT reduces the distribution discrepancy, and discuss why it is superior to the classic DAT.
+
+# 3.4 THEORETICAL JUSTIFICATIONS
+
+In this section, we provide the theoretical justifications on how the proposed method reduces the distribution discrepancy for UDA. The rationale behind domain alignment is motivated from the learning theory of non-conservative domain adaptation problem by Ben-David et al. (Ben-David et al., 2010):
+
+Theorem 3.1 Let $\mathcal { H }$ be the hypothesis space where $h \in \mathcal H$ . Let $( \mathcal { D } _ { S } , \epsilon _ { s } )$ and $( \mathcal { D } _ { T } , \epsilon _ { t } )$ be the two domains and their corresponding generalization error functions. The expected error for the target domain is upper bounded by
+
+$$
+\epsilon _ { t } ( h ) \leq \epsilon _ { s } ( h ) + \frac { 1 } { 2 } d _ { \mathscr { H } \triangle \mathscr { H } } ( \mathscr { D } _ { S } , \mathscr { D } _ { T } ) + \lambda , \forall h \in \mathscr { H } ,
+$$
+
+where $\begin{array} { r } { d _ { \mathcal { H } \triangle \mathcal { H } } ( \mathcal { D } _ { S } , \mathcal { D } _ { T } ) = 2 \operatorname* { s u p } _ { h _ { 1 } , h _ { 2 } \in \mathcal { H } } \big | \operatorname* { P r } _ { x \sim \mathcal { D } _ { S } } [ h _ { 1 } ( x ) \neq h _ { 2 } ( x ) ] - \operatorname* { P r } _ { x \sim \mathcal { D } _ { T } } [ h _ { 1 } ( x ) \neq h _ { 2 } ( x ) ] \big | } \end{array}$ and $\lambda = \mathrm { m i n } _ { h } [ \epsilon _ { s } ( h ) + \epsilon _ { t } ( h ) ]$ .
+
+Theoretically, when we minimize the $\mathcal { H } \triangle \mathcal { H }$ -distance, the upper bound of the expected error for the target domain is reduced accordingly. As derived in DAT (Ganin $\&$ Lempitsky, 2015), assuming a family of domain classifiers $\mathcal { H } _ { d }$ to be rich enough to contain the symmetric difference hypothesis set of $\mathcal { H } _ { p }$ , such that $\mathcal { H } _ { p } \triangle \mathcal { H } _ { p } = \{ h | h = h _ { 1 } \oplus \bar { h } _ { 2 } , h _ { 1 } , h _ { 2 } \in \mathcal { H } _ { p } \}$ where $\oplus$ is XOR-function, the empirical $\mathcal { H } _ { p } \triangle \mathcal { H } _ { p }$ -distance has an upper bound with regard to the optimal domain classifier $h$ :
+
+$$
+d _ { \mathcal H _ { p } \triangle \mathcal H _ { p } } ( \hat { D } _ { S } , \hat { D } _ { T } ) \le 2 \operatorname* { s u p } _ { h \in \mathcal H _ { d } } \vert \operatorname* { P r } _ { \mathbf z \sim \hat { D } _ { S } } [ h ( \mathbf z ) = 0 ] + \operatorname* { P r } _ { \mathbf z \sim \hat { D } _ { T } } [ h ( \mathbf z ) = 1 ] - 1 \vert ,
+$$
+
+where $\hat { \mathcal { D } } _ { S }$ and $\hat { \mathcal { D } } _ { T }$ denote the distributions of the source and target feature space ${ \mathcal { Z } } _ { S }$ and ${ \mathcal { Z } } _ { T }$ , respectively. Note that the MSE of $G _ { r }$ plus a ceiling function is a form of domain classifier $h ( \mathbf { z } )$ , i.e. $\lceil [ m - \bar { \mathcal { L } } _ { r } ( \cdot ) ] ^ { + } - 0 . 5 \rceil$ for $m = 1$ . It maps source samples to 0 and target samples to 1 which is exactly the upper bound in Eq.10. Therefore, our reconstruction network $G _ { r }$ maximizes the domain discrepancy with a margin and the feature extractor learns to minimize it oppositely.
+
+# 3.5 DISCUSSIONS
+
+Compared with the conventional DAT-based methods that are usually based on a binary logistic network (Ganin & Lempitsky, 2015), the proposed ARN with MDAT is more attractive and incorporates new merits conceptually and theoretically:
+
+(1) Stable training and insensitivity to hyper-parameters. Using the decoder as domain classifier with a margin loss to restrain its overwhelming capacity in adversarial training, the minimax game can continuously provide effective gradients for training the feature extractor. Moreover, through the experiments in Section 4, we discover that our method shows strong robustness to the hyperparameters, i.e. $\alpha$ and $m$ , greatly alleviating the parameters tuning for model selection.
+
+(2) Richer information for comprehensive domain alignment. Rather than DAT that uses a bit of domain information, MDAT utilizes the reconstruction network as the domain classifier that could capture more domain-specific and pixel-level features during the unsupervised reconstruction (Bousmalis et al., 2016). Therefore, MDAT further helps address pixel-level domain shift apart from the feature-level shift, leading to comprehensive domain alignment in a straightforward manner.
+
+(3) Feature visualization for method validation. Another key merit of MDAT is that MDAT allows us to visualize the features directly by the reconstruction network. It is crucial to understand to what extent the features are aligned since this helps to reveal the underlying mechanism of adversarial domain adaptation. We will detail the interpretability of these adapted features in Section 4.3.
+
+# 4 EXPERIMENT
+
+In this section, we evaluate the proposed ARN with MDAT on a number of visual and non-visual UDA tasks with varying degrees of domain shift. We conduct ablation study to corroborate the effectiveness of MDAT and unsupervised reconstruction for UDA. Then the sensitivity of the hyperparameters is investigated, and the adapted features are interpreted via the reconstruction network in ARN.
+
+Setup. We evaluate our method on four classic visual UDA datasets and a WiFi-based Gesture Recognition (WGR) dataset (Zou et al., 2019). The classic datasets have middle level of domain shift including MNIST (LeCun et al., 1998), USPS (Hull, 1994), Street View House Numbers (SVHN) (Netzer et al., 2011) and Synthetic Digits (SYN). For a fair comparison, we follow the same CNN architecture as DANN (Ganin & Lempitsky, 2015) while using the inverse of $G _ { e }$ as $G _ { r }$ with pooling operation replaced by upsampling. For the penalty term $\alpha$ , we choose 0.02 by searching over the grid $\lbrace 1 0 ^ { - 2 } , \dot { 1 } \rbrace$ . We also obtain the optimal margin $m = 5$ by a search over $\{ 1 0 ^ { \dot { - } 1 } , 1 0 \}$ . Then we use the same hyperparameter settings for all tasks to show the robustness. For the optimization, we simply use Adam Optimizer $( l r = 2 \times 1 0 ^ { - 4 } , \beta _ { 1 } = 0 . 5 , \beta _ { 2 } = 0 . 9 9 9 )$ and train all experiments for 50 epochs with batch size 128. We implemented our model and conducted all the experiments using the PyTorch framework. More implementation details are illustrated in the appendix.
+
+Baselines. We evaluate the efficacy of our approach by comparing it with existing UDA methods that perform three ways of domain alignment. Specifically, MMD regularization (Long et al., 2015) and Correlation Alignment (Sun & Saenko, 2016) employ the statistical distribution matching. DRCN (Ghifary et al., 2016) and DSN (Bousmalis et al., 2016) use the reconstruction error for UDA,
+
+<table><tr><td>Source Target</td><td>MNIST USPS</td><td>USPS MNIST</td><td>SVHN MNIST</td><td>SYN SVHN</td></tr><tr><td>Source-Only model</td><td>78.2</td><td>63.4</td><td>54.9</td><td>86.7</td></tr><tr><td>Train on target</td><td>96.5</td><td>99.4</td><td>99.4</td><td>91.3</td></tr><tr><td>[S] MMD (Long et al., 2015)</td><td>81.1</td><td>-</td><td>71.1</td><td>88.0</td></tr><tr><td>[S] CORAL (Sun &amp; Saenko, 2016)</td><td>80.7</td><td>-</td><td>63.1</td><td>85.2</td></tr><tr><td>[R] DRCN* (Ghifary et al.,2016)</td><td>91.8</td><td>73.7</td><td>82.0</td><td>87.5</td></tr><tr><td>[R] DSN (Bousmalis et al., 2016)</td><td>91.3</td><td>-</td><td>82.7</td><td>91.2</td></tr><tr><td>[A] DANN (Ganin et al., 2016)</td><td>85.1</td><td>73.0</td><td>74.7</td><td>90.3</td></tr><tr><td>[A] ADDA (Tzeng et al., 2017)</td><td>89.4</td><td>90.1</td><td>76.0</td><td>-</td></tr><tr><td>[A] CyCADA (Hoffman et al., 2018)</td><td>95.6</td><td>96.5</td><td>90.4</td><td>-</td></tr><tr><td>[A] CADA (Zou et al., 2019)</td><td>96.4</td><td>97.0</td><td>90.9</td><td>1</td></tr><tr><td>[A] MECA (Morerio et al.,2018)</td><td>-</td><td>-</td><td>95.2</td><td>90.3</td></tr><tr><td>ARN w.0. MDAT</td><td>93.1±0.3</td><td>76.5±1.2</td><td>67.4±0.9</td><td>86.8±0.5</td></tr><tr><td>ARN with MDAT (proposed)</td><td>98.6±0.3</td><td>98.4±0.1</td><td>97.4±0.3</td><td>92.0±0.2</td></tr></table>
+
+Table 1: We compare with general, statistics-based (S), reconstruction-based $\mathbf { ( R ) }$ and adversarialbased (A) state-of-the-art approaches. We repeated each experiment for 3 times and report the average and standard deviation (std) of the test accuracy in the target domain.
+
+while many prevailing UDA methods adopt domain-adversarial training including DANN (Ganin & Lempitsky, 2015), ADDA (Tzeng et al., 2017), MECA (Morerio et al., 2018), CyCADA (Hoffman et al., 2018) and CADA (Zou et al., 2019). For all transfer tasks, we follow the same protocol as DANN (Ganin & Lempitsky, 2015) that uses official training data split in both domains for training and evaluates the testing data split in the target domain.
+
+# 4.1 OVERALL RESULTS
+
+MNIST USPS. Both datasets are composed of grey-scale handwritten images with diverse stroke weights, leading to low-level domain shift. Since USPS has only 7291 training images, USPS ${ \bf { \Gamma } } \to \mathbf { M N I S T }$ is more difficult. As shown in Table 1, our method achieves state-of-the-art accuracy of $9 8 . 6 \%$ on MNIST USPS and $9 8 . 4 \%$ on USPS MNIST, which demonstrates that ARN can tackle low-level domain shift by only using ART (rather than many adversarial UDA methods that adopt other loss terms to adjust classifier boundaries or conduct style transfer).
+
+Table 2: Comparisons on WGR.   
+
+<table><tr><td rowspan=1 colspan=1>SourceTarget</td><td rowspan=1 colspan=1>Room ARoom B</td></tr><tr><td rowspan=1 colspan=1>Method</td><td rowspan=1 colspan=1>Accuracy (%)</td></tr><tr><td rowspan=1 colspan=1>Source-only[S] MMD</td><td rowspan=2 colspan=1>58.4±0.761.2±0.569.3±0.3</td></tr><tr><td rowspan=1 colspan=1>[R] DRCN</td></tr><tr><td rowspan=1 colspan=1>[A]DANN</td><td rowspan=1 colspan=1>68.2±0.2</td></tr><tr><td rowspan=1 colspan=1>[A] ADDA</td><td rowspan=1 colspan=1>71.5±0.3</td></tr><tr><td rowspan=1 colspan=1>[A] CADA</td><td rowspan=1 colspan=1>88.8±0.1</td></tr><tr><td rowspan=1 colspan=1>ARN+MDAT</td><td rowspan=1 colspan=1>91.3±0.2</td></tr></table>
+
+SVHN MNIST and $\mathbf { S Y N } {  } \mathbf { S V H N }$ . The SVHN dataset contains RGB digit images that introduce significant variations such as scale, background, embossing, rotation, slanting and even multiple digits. The SYN data consists of $5 0 k$ RGB images of varying color, background, blur and orientation. These two tasks have tremendous pixel-level domain shfit. The proposed method achieves a state-ofthe-art performance of $9 7 . 4 \%$ for $\mathbf { S V H N { \to } M N I S T }$ , far ahead of other DAT-based methods, significantly improving the classic DANN by $2 2 . 7 \%$ . Similarly, ARN with MDAT also achieves a noticeable improvement of $5 . 3 \%$ compared with the source-only model, even outperforming the supervised SVHN accuracy $9 1 . 3 \%$ .
+
+WiFi Gesture Recognition with Distant Domains. To evaluate the proposed method on a non-visual UDA task, we applied our method to the WiFi gesture recognition dataset (Zou et al., 2019). The WiFi data of six gestures was collected in two rooms regarded as two domains. The results in Table 2 demonstrate that our approach significantly improves classification accuracy against Source-Only and DANN by $3 2 . 9 \%$ and $2 3 . 1 \%$ , respectively.
+
+Table 3: The accuracy $( \% )$ with different hyperparameters on SVHN MNIST.   
+
+<table><tr><td>a</td><td>0.01</td><td>0.03</td><td>0.07</td><td>0.1</td><td>0.2</td><td>0.3</td><td>0.5</td><td>1.0</td></tr><tr><td>DANN</td><td>71.1</td><td>74.1</td><td>72.7</td><td>74.1</td><td>74.7</td><td>9.6</td><td>9.7</td><td>10.3</td></tr><tr><td>ARN (m = 1)</td><td>95.7</td><td>95.9</td><td>93.3</td><td>93.2</td><td>80.1</td><td>75.3</td><td>73.1</td><td>67.5</td></tr><tr><td>m</td><td>0.1</td><td>0.3</td><td>0.5</td><td>0.7</td><td>1.0</td><td>2.0</td><td>5.0</td><td>10.0</td></tr><tr><td>ARN(α = 2e-2)</td><td>64.5</td><td>75.2</td><td>90.0</td><td>92.6</td><td>96.0</td><td>97.4</td><td>97.7</td><td>96.7</td></tr></table>
+
+# 4.2 ABLATION STUDY AND SENSITIVITY ANALYSIS
+
+The contribution of MDAT and image reconstruction in ARN. We design an ablation study to verify the contribution of MDAT and unsupervised reconstruction in ARN. To this end, we discard the term $\dot { \mathcal { L } } _ { r } ( \mathbf { x } ^ { t } )$ in Eq.4, and evaluate the method, denoted as ARN w.o. MDAT in Table 1. (1) Comparing ARN w.o. MDAT with source-only model, we can infer the effect of unsupervised reconstruction for UDA. It is observed that ARN w.o. MDAT improves tasks with low-level domain shift such as MNIST USPS, which conforms with our discussion that the unsupervised reconstruction is instrumental in learning low-level features. (2) Comparing ARN w.o. MDAT with the original ARN, we can infer the contribution of MDAT. Table 1 shows that the MDAT achieves an impressive marginof-improvement. For USPS MNIST and SV $\mathbf { H N } {  } \mathbf { M N }$ IST, the MDAT improves ARN w.o. MDAT by around $30 \%$ . It demonstrates that MDAT which helps learn domain-invariant representations is the main reason for the tremendous improvement.
+
+Parameter sensitivity. We investigate the effect of $\alpha$ and $m$ on S $\mathbf { \nabla } \sqrt { \mathbf { H N } } \to \mathbf { M }$ NIST. The results in Table 3 show that ARN achieves good performance as $\alpha \in [ 0 . 0 1 , 0 . 1 ]$ and even with larger $\alpha$ ARN is able to achieve convergence. In comparison, denoting $\alpha$ as the weight of adversarial loss, the DANN cannot converge when $\alpha > 0 . 2$ . For the sensitivity of $m$ , the accuracy of ARN exceeds $9 6 . 0 \%$ as $m \geq 1$ . These analyses validate that the training of ARN is not sensitive to the parameters and even in the worst cases ARN can achieve convergence.
+
+Gradients and training procedure. We draw the training procedure with regard to loss and target accuracy in Figure 2(b) and Figure 2(a), respectively. In Figure 2(b), ARN has smoother and more effective gradients $( \mathcal { L } _ { r } )$ for all $\alpha$ , while the loss of DAT domain classifier $( \mathcal { L } _ { d } )$ gets extremely small at the beginning. This observation conforms with our intuition, which demonstrates that by restricting the capacity of domain classifier MDAT provides more effective gradients for training feature extractor, leading to a more stable training procedure. This could be further validated in Figure 2(b) where the ARN accuracy is more stable than that of DAT across training epochs.
+
+![](images/52dba511d647d639645ebf2e30bb3449cb0c5632abfcd2262b3a859d0381b616.jpg)  
+Figure 2: The training procedure with regard to loss and test accuracy. ( $\mathcal { L } _ { e } : = \mathrm { E q }$ . 6; $\mathcal { L } _ { r }$ := Eq. 4; $\mathcal { L } _ { d }$ is the domain loss of DAT (Ganin & Lempitsky, 2015); $\alpha$ is the penalty term of $\mathcal { L } _ { e }$ and $\mathcal { L } _ { d }$ .)
+
+<table><tr><td></td><td>Source Images</td><td>Target Images</td><td>R-Target Images</td></tr><tr><td>MNIST→USPS</td><td>72/04149 97349665 34727121</td><td>06181328 Li;97210 10140198</td><td>618132 108:019 3</td></tr><tr><td>USPS→MNIST</td><td>01870009 z568928i 35418305</td><td>7210414a 97349665 341727121</td><td>72104197 97s41665 34727121</td></tr><tr><td>SVHN→MNIST</td><td>0103457N0 2 19 5 5259.012 1310</td><td>59069015 0740131 2413512</td><td>9101e19101115 :1061:01511 gCk ES52</td></tr><tr><td>SYN-→SVHN</td><td>14366 40570 6.75/ 65 3607 37 1236:83811 094</td><td>6s 31 140885 3 96 品 3913b8m</td><td>64040003 30296651 39)-0s81</td></tr></table>
+
+Table 4: Visualizing the source image, target images and reconstructed target images (R-Target Images) for four digit adaptation tasks.
+
+# 4.3 VISUALIZATION AND ANALYSIS
+
+Interpreting MDAT features via reconstructed images. One of the key advantages of ARN is that by visualizing the reconstructed target images we can infer how the features are domain-invariant. We reconstruct the MDAT features of the test data and visualize them in Table 4. It is observed that the target features are reconstructed to source-like images by the decoder $G _ { r }$ . As discussed before, intuitively, MDAT forces the target features to mimic the source features, which conforms with our visualization. Similar to image-to-image translation, this indicates that our method conducts implicit feature-to-feature translation that transfers the target features to source-like features, and hence the features become domain-invariant.
+
+T-SNE embeddings. We analyze the performance of domain alignment for DANN (DAT) (Ganin & Lempitsky, 2015) and ARN (MDAT) by plotting T-SNE embeddings of the features $\mathbf { z }$ on the task SVHN MNIST. In Figure 3(a), the source-only model obtains diverse embeddings for each category but the domains are not aligned. In Figure 3(b), the DANN aligns two domains but the decision boundaries of the classifier are vague. In Figure 3(c), the proposed ARN effectively aligns two domains for all categories and the classifier boundaries are much clearer.
+
+![](images/1bdd1728d9463ce082756cdc92cdc0b4e757f2ee7ad1eb5dff92cdabfb33cf61.jpg)  
+Figure 3: T-SNE visualization on SVHN MNIST with their corresponding domain labels (red: target; blue: source) and category labels (10 classes) shown in the left and right subfigures, respectively.
+
+# 5 CONCLUSION
+
+We proposed a new domain alignment approach namely max-margin domain-adversarial training (MDAT) and a MDAT-based network for unsupervised domain adaptation. The proposed method offers effective and stable gradients for the feature learning via an adversarial game between the feature extractor and the reconstruction network. The theoretical analysis provides justifications on how it minimizes the distribution discrepancy. Extensive experiments demonstrate the effectiveness of our method and we further interpret the features by visualization that conforms with our insight. Potential evaluation on semi-supervised learning constitutes our future work.
+
+# REFERENCES
+
+Shai Ben-David, John Blitzer, Koby Crammer, Alex Kulesza, Fernando Pereira, and Jennifer Wortman Vaughan. A theory of learning from different domains. Machine learning, 79(1-2):151–175, 2010.
+
+Konstantinos Bousmalis, George Trigeorgis, Nathan Silberman, Dilip Krishnan, and Dumitru Erhan. Domain separation networks. In Advances in Neural Information Processing Systems, pp. 343–351, 2016.
+
+Konstantinos Bousmalis, Nathan Silberman, David Dohan, Dumitru Erhan, and Dilip Krishnan. Unsupervised pixel-level domain adaptation with generative adversarial networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3722–3731, 2017.
+
+Yuhua Chen, Wen Li, Christos Sakaridis, Dengxin Dai, and Luc Van Gool. Domain adaptive faster r-cnn for object detection in the wild. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3339–3348, 2018.
+
+Nello Cristianini, John Shawe-Taylor, et al. An introduction to support vector machines and other kernel-based learning methods. Cambridge university press, 2000.
+
+Yaroslav Ganin and Victor Lempitsky. Unsupervised domain adaptation by backpropagation. In Francis Bach and David Blei (eds.), Proceedings of the 32nd International Conference on Machine Learning, volume 37 of Proceedings of Machine Learning Research, pp. 1180–1189, Lille, France, 07–09 Jul 2015. PMLR.
+
+Yaroslav Ganin, Evgeniya Ustinova, Hana Ajakan, Pascal Germain, Hugo Larochelle, Franc¸ois Laviolette, Mario Marchand, and Victor Lempitsky. Domain-adversarial training of neural networks. The Journal of Machine Learning Research, 17(1):2096–2030, 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, pp. 597–613. Springer, 2016.
+
+Xavier Glorot, Antoine Bordes, and Yoshua Bengio. Domain adaptation for large-scale sentiment classification: A deep learning approach. In Proceedings of the 28th International Conference on Machine Learning (ICML-11), pp. 513–520, 2011.
+
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in Neural Information Processing Systems, pp. 2672–2680, 2014.
+
+Judy Hoffman, Eric Tzeng, Taesung Park, Jun-Yan Zhu, Phillip Isola, Kate Saenko, Alexei Efros, and Trevor Darrell. CyCADA: Cycle-consistent adversarial domain adaptation. In Proceedings of the 35th International Conference on Machine Learning, pp. 1989–1998, 2018.
+
+Jonathan J. Hull. A database for handwritten text recognition research. IEEE Transactions on Pattern Analysis and Machine Intelligence, 16(5):550–554, 1994.
+
+Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.
+
+Yann LeCun, Yoshua Bengio, and Geoffrey Hinton. Deep learning. nature, 521(7553):436, 2015.
+
+Mingsheng Long, Yue Cao, Jianmin Wang, and Michael I. Jordan. Learning transferable features with deep adaptation networks. In Proceedings of the 32Nd International Conference on International Conference on Machine Learning - Volume 37, ICML’15, pp. 97–105, 2015.
+
+Mingsheng Long, Zhangjie Cao, Jianmin Wang, and Michael I Jordan. Conditional adversarial domain adaptation. In Advances in Neural Information Processing Systems, 2018.
+
+Pietro Morerio, Jacopo Cavazza, and Vittorio Murino. Minimal-entropy correlation alignment for unsupervised deep domain adaptation. In International Conference on Learning Representations, 2018. URL https://openreview.net/forum?id=rJWechg0Z.
+
+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, volume 2011, pp. 5, 2011.
+
+Hidetoshi Shimodaira. Improving predictive inference under covariate shift by weighting the loglikelihood function. Journal of statistical planning and inference, 90(2):227–244, 2000.
+
+Rui Shu, Hung H Bui, Hirokazu Narui, and Stefano Ermon. A dirt-t approach to unsupervised domain adaptation. In Proc. 6th International Conference on Learning Representations, 2018.
+
+Baochen Sun and Kate Saenko. Deep coral: Correlation alignment for deep domain adaptation. In European Conference on Computer Vision, pp. 443–450. Springer, 2016.
+
+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, Kate Saenko, and Trevor Darrell. Adversarial discriminative domain adaptation. In Computer Vision and Pattern Recognition (CVPR), volume 1, pp. 4, 2017.
+
+David Vazquez, Antonio M Lopez, Javier Marin, Daniel Ponsa, and David Geronimo. Virtual and real world adaptation for pedestrian detection. IEEE Transactions on Pattern Analysis and Machine Intelligence, 36(4):797–809, 2013.
+
+Han Zou, Yuxun Zhou, Jianfei Yang, Huihan Liu, Hari Prasanna Das, and Costas J Spanos. Consensus adversarial domain adaptation. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, pp. 5997–6004, 2019.
+
+# APPENDIX
+
+# IMPLEMENTATION DETAILS
+
+Hyperparameter For all tasks, we simply use the same hyperparameters that are chosen from the sensitivity analysis. We use $\alpha = 0 . 0 2$ and $m = 5 . 0$ , and we reckon that better results can be obtained by tuning the hyperparameters for specific tasks.
+
+Network Architecture For a fair comparison, we follow the network in DANN (Ganin & Lempitsky, 2015) for digit adaptation and simply build the reconstruction network by the inverse network of the extractor. Here we draw the network architectures in Table 5. For WiFi gesture recognition, we adopt the same architecture as CADA (Zou et al., 2019) that is a modified version of LeNet-5.
+
+Table 5: The network architecture used in the experiments.   
+
+<table><tr><td rowspan=1 colspan=1>Layer Index|</td><td rowspan=1 colspan=1>Feature Extractor</td><td rowspan=1 colspan=2>Decoder Network一Label Predictor</td></tr><tr><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=3>32 × 32 × 3 Image</td></tr><tr><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1> 5 × 5 conv. 64 ReLU</td><td rowspan=1 colspan=1>2048 dense, ReLU</td><td rowspan=1 colspan=1>10 dense, softmax</td></tr><tr><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>3 × 3 max-pool, stride 2</td><td rowspan=1 colspan=1>3072 dense, ReLU</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>5 × 5 conv. 64 ReLU</td><td rowspan=1 colspan=2> 5 × 5 conv. 128 ReLU</td></tr><tr><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1> 3 × 3 max-pool, stride 2</td><td rowspan=1 colspan=1>upsample 2</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>5</td><td rowspan=1 colspan=1>5 × 5 conv. 128 ReLU</td><td rowspan=1 colspan=1>5 × 5 conv. 64 ReLU</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>6</td><td rowspan=1 colspan=1> 3072 dense,dropout, ReLU</td><td rowspan=1 colspan=1>upsample 2     一</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>7</td><td rowspan=1 colspan=1>2048 dense, dropout ReLU丨 5 × 5 conv. 64 ReLU</td><td rowspan=1 colspan=1>2048 dense, dropout ReLU丨 5 × 5 conv. 64 ReLU</td><td rowspan=1 colspan=1></td></tr></table>
+
+# SENSITIVITY
+
+We have presented all the results of the sensitivity study in Section 4.2, and now we show their detailed training procedures in Figure 4(a) and 4(b). It is observed that the accuracy increases when $\alpha$ drops or the margin $m$ increases. The reason is very simple: (1) when $\alpha$ is too large, it affects the effect of supervised training on source domain; (2) when the margin $m$ is small, the divergence between source and target domain (i.e. $\mathcal { H } \triangle \mathcal { H }$ -distance) cannot be measured well.
+
+![](images/51fdf51eb7f411f3f5d635607678c3149a1ab54683a9f9149fc92a99b18e13cf.jpg)  
+Figure 4: The training procedure of ARN with different hyper-parameters.
+
+# VISUALIZATION
+
+Here we provide more visualization of the reconstructed images of target samples. In Figure 5, the target samples are shown in the left column while their corresponding reconstructed samples are shown in the right. We can see that for low-level domain shift such as $\mathbf { M N I S T } {  } \mathbf { U S P } \mathbf { \xi }$ S, the reconstructed target samples are very source-like while preserving their original shapes and skeletons. However, for larger domain shift in Figure 5(c) and 5(d), they are reconstructed to source-like same digits but simultaneously some noises are removed. Specifically, in Figure 5(d), we can see that one target sample (SVHN) may contain more than one digits that are noises for recognition. After reconstruction, only the right digits are reconstructed. Some target samples may suffer from terrible illumination conditions but their reconstructed digits are very clear, which is amazing.
+
+![](images/c5f148db888d641992e5b170fed0b90b7901569b1c01614ca8392603fd460948.jpg)  
+Figure 5: Visualization of the target samples and their corresponding reconstructed target samples.

parse/train/BklEF3VFPB/BklEF3VFPB_content_list.json

@@ -0,0 +1,1346 @@
+[
+    {
+        "type": "text",
+        "text": "TOWARDS STABLE AND COMPREHENSIVE DOMAIN ALIGNMENT: MAX-MARGIN DOMAIN-ADVERSARIAL TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            99,
+            823,
+            171
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            195,
+            398,
+            223
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            261,
+            544,
+            275
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Domain adaptation tackles the problem of transferring knowledge from a labelrich source domain to an unlabeled or label-scarce target domain. Recently domain-adversarial training (DAT) has shown promising capacity to learn a domaininvariant feature space by reversing the gradient propagation of a domain classifier. However, DAT is still vulnerable in several aspects including (1) training instability due to the overwhelming discriminative ability of the domain classifier in adversarial training, (2) restrictive feature-level alignment, and (3) lack of interpretability or systematic explanation of the learned feature space. In this paper, we propose a novel Max-margin Domain-Adversarial Training (MDAT) by designing an Adversarial Reconstruction Network (ARN). The proposed MDAT stabilizes the gradient reversing in ARN by replacing the domain classifier with a reconstruction network, and in this manner ARN conducts both feature-level and pixel-level domain alignment without involving extra network structures. Furthermore, ARN demonstrates strong robustness to a wide range of hyper-parameters settings, greatly alleviating the task of model selection. Extensive empirical results validate that our approach outperforms other state-of-the-art domain alignment methods. Additionally, the reconstructed target samples are visualized to interpret the domain-invariant feature space which conforms with our intuition. ",
+        "bbox": [
+            233,
+            290,
+            766,
+            540
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            565,
+            336,
+            582
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep neural networks have gained great success on a wide range of tasks such as visual recognition and machine translation (LeCun et al., 2015). They usually require a large number of labeled data that can be prohibitively expensive to collect, and even with sufficient supervision their performance can still be poor when being generalized to a new environment. The problem of discrepancy between the training and testing data distribution is commonly referred to as domain shift (Shimodaira, 2000). To alleviate the effect of such shift, domain adaptation sets out to obtain a model trained in a label-rich source domain to generalize well in an unlabeled target domain. Domain adaptation has benefited various applications in many practical scenarios, including but not limited to object detection under challenging conditions (Chen et al., 2018), cost-effective learning using only synthetic data to generalize to real-world imagery (Vazquez et al., 2013), etc. ",
+        "bbox": [
+            174,
+            597,
+            825,
+            736
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Prevailing methods for unsupervised domain adaptation (UDA) are mostly based on domain alignment which aims to learn domain-invariant features by reducing the distribution discrepancy between the source and target domain using some pre-defined metrics such as maximum mean discrepancy (Tzeng et al., 2014). Recently, Ganin & Lempitsky (2015) proposed to achieve domain alignment by domainadversarial training (DAT) that reverses the gradients of a domain classifier to maximize domain confusion. Having yielded remarkable performance gain, DAT was employed in many subsequent UDA methods (Long et al., 2018; Shu et al., 2018). Even so, there still exist three critical issues of DAT that hinder its performance: (1) as the domain classifier has high-capacity to discriminate two domains, the unbalanced adversarial training cannot continuously provide effective gradients, which is usually overcome by manually adjusting the weights of adversarial training according to specific tasks; (2) DAT-based methods cannot deal with pixel-level domain shift (Hoffman et al., 2018); (3) the domain-invariant features learned by DAT are only based on intuition but difficult to interpret, which impedes the investigation of the underlying mechanism of adversarial domain adaptation. ",
+        "bbox": [
+            174,
+            743,
+            825,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To overcome the aforementioned difficulties, we propose an innovative DAT approach, namely Max-margin Domain-Adversarial Training (MDAT), to realize stable and comprehensive domain alignment. To demonstrate its effectiveness, we develop an Adversarial Reconstruction Network (ARN) that only utilizes MDAT for UDA. Specifically, ARN consists of a shared feature extractor, a label predictor, and a reconstruction network (i.e. decoder) that serves as a domain classifier. Supervised learning is conducted on source domain, and MDAT helps learn domain-invariant features. In MDAT, the decoder only focuses on reconstructing samples on source domain and pushing the target domain away from a margin, while the feature extractor aims to fool the decoder by learning to reconstruct samples on target domain. In this way, three critical issues can be solved by MDAT: (1) the max-margin loss reduces the discriminative capacity of domain classifier, leading to balanced and thus stable adversarial training; (2) without involving new network structures, MDAT achieves both pixel-level and feature-level domain alignment; (3) visualizing the reconstructed samples reveals how the source and target domains are aligned. We evaluate ARN with MDAT on five visual and non-visual UDA benchmarks. It achieves significant improvement to DAT on all tasks with pixel-level or higher-level domain shift. We also observe that it is insensitive to the choices of hyperparameters and as such is favorable for replication in practice. In principle, our approach is generic and can be used to enhance any UDA methods that leverage domain alignment as an ingredient. ",
+        "bbox": [
+            174,
+            104,
+            825,
+            339
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            359,
+            344,
+            376
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Domain adaptation aims to transfer knowledge from one domain to another. Ben-David et al. (2010) provide an upper bound of the test error on the target domain in terms of the source error and the $\\mathcal { H } \\triangle \\mathcal { H }$ -distance. As the source error is stationary for a fixed model, the goal of most UDA methods is to minimize the $\\mathcal { H } \\triangle \\mathcal { H }$ -distance by reducing some metrics such as Maximum Mean Discrepancy (MMD) (Tzeng et al., 2014; Long et al., 2015) and CORAL (Sun & Saenko, 2016). Inspired by Generative Adversarial Networks (GAN) (Goodfellow et al., 2014), Ganin & Lempitsky (2015) proposed to learn domain-invariant features by adversarial training, which has inspired many UDA methods thereafter. Adversarial Discriminative Domain Adaptation (ADDA) tried to fool the label classifier by adversarial training but not in an end-to-end manner. CyCADA (Hoffman et al., 2018) and PixelDA (Bousmalis et al., 2017) leveraged GAN to conduct both feature-level and pixel-level domain adaptation, which yields significant improvement yet the network complexity is high. ",
+        "bbox": [
+            174,
+            391,
+            825,
+            545
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Another line of approaches that are relevant to our method is the reconstruction network (i.e. the decoder network). The success of image-to-image translation corroborates that it helps learn pixellevel features in an unsupervised manner. In UDA, Ghifary et al. (2016) employed a decoder network for pixel-level adaptation, and Domain Separate Network (DSN) (Bousmalis et al., 2016) further leveraged multiple reconstruction networks to learn domain-specific features. These approaches treat the decoder network as an independent component that is irrelevant to domain alignment (Glorot et al., 2011). In this paper, our approach proposes to utilize the decoder network as domain classifier in MDAT which enables both feature-level and pixel-level domain alignment in a stable and straightforward fashion. ",
+        "bbox": [
+            174,
+            551,
+            825,
+            676
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 PROBLEM FORMULATION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            696,
+            416,
+            713
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3.1 PROBLEM DEFINITION AND NOTATIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            728,
+            490,
+            742
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In unsupervised domain adaptation, we assume that the model works with a labeled dataset $\\mathbf { X } _ { S }$ and an unlabeled dataset $\\mathbf { X } _ { T }$ . Let $\\mathbf { X } _ { S } = \\{ ( \\mathbf { x } _ { i } ^ { s } , y _ { i } ^ { s } ) \\} _ { i \\in [ N _ { s } ] }$ denote the labeled dataset of $N _ { s }$ samples from the source domain, and the certain label $y _ { i } ^ { s }$ belongs to the label space $Y$ that is a finite set $( Y = 1 , 2 , . . . , K )$ . The other dataset $\\mathbf { X } _ { T } = \\{ \\mathbf { x } _ { i } ^ { t } \\} _ { i \\in [ N _ { t } ] }$ has $N _ { t }$ samples from the target domain but has no labels. We further assume that two domains have different distributions, i.e. $\\mathbf { x } _ { i } ^ { s } \\sim \\mathcal { D } _ { S }$ and $\\mathbf { x } _ { i } ^ { t } \\sim \\mathcal { D } _ { T }$ . In other words, there exist some domain shift (Ben-David et al., 2010) between $\\mathcal { D } _ { S }$ and $\\mathcal { D } _ { T }$ . The ultimate goal is to learn a model that can predict the label $y _ { i } ^ { t }$ given the target input $\\mathbf { x } _ { i } ^ { t }$ . ",
+        "bbox": [
+            173,
+            753,
+            825,
+            852
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3.2 IMBALANCED MINIMAX GAME IN DOMAIN-ADVERSARIAL TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            869,
+            699,
+            883
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To achieve domain alignment, Domain-Adversarial Training (DAT) is a minimax game between a shared feature extractor $F$ for two domains and a domain classifier $D$ . The domain classifier is ",
+        "bbox": [
+            173,
+            895,
+            820,
+            922
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/001311f8f21980fa16dacf066d24b3fe311eef6861e67cfc41a97be754e1ac07.jpg",
+        "image_caption": [
+            "Figure 1: The proposed architecture is composed of a shared feature extractor $G _ { e }$ for two domains, a label predictor $G _ { y }$ and a reconstruction network $G _ { r }$ . In addition to the basic supervised learning in the source domain, our adversarial reconstruction training enables the extractor $G _ { e }$ to learn domain-invariant features. Specifically, the network $G _ { r }$ aims to reconstruct the source samples $x ^ { s }$ and to impede the reconstruction of the target samples $x ^ { t }$ , while the extractor $G _ { e }$ tries to fool the reconstruction network in order to reconstruct the target samples $x ^ { t }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            232,
+            102,
+            767,
+            265
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "trained to determine whether the input sample belongs to the source or the target domain while the feature extractor learns to deceive the domain classifier, which is formulated as: ",
+        "bbox": [
+            171,
+            377,
+            821,
+            406
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/865e3b6309d544bd6144ba052d6cd449253b0081a993ec3e3dd34029222b5e43.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { F } \\operatorname* { m a x } _ { D } \\mathcal { L } _ { D A T } ( D _ { s } , D _ { t } ) = \\mathbb { E } _ { x \\sim D _ { s } } [ \\ln F ( x ) ] + \\mathbb { E } _ { x \\sim D _ { t } } [ \\ln \\left( 1 - D ( F ( x ) ) \\right) ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            251,
+            415,
+            746,
+            439
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In DAT, we usually utilize CNN as the feature extractor and fully connected layers (FC) as the domain classifier. DAT reduces the cross-domain discrepancy, achieving significant performance improvement for UDA. Nevertheless, the training of DAT is rather unstable. Without sophisticated tuning of the hyper-parameters, DAT cannot reach the convergence. Through empirical experiments, we observe that such instability is due to the imbalanced minimax game. The binary domain classifier $D$ can easily achieve convergence with very high accuracy at an early training epoch, while it is much harder for the feature extractor $F$ to fool the domain classifier and to simultaneously perform well on the source domain. In this sense, the domain classifier dominates DAT, and the only solution is to palliate the training of $D$ by tuning the hyper-parameters according to different tasks. In our method, we restrict the capacity of the domain classifier so as to form a minimax game in a harmonious manner. Inspired by the max-margin loss in Support Vector Machine (SVM) (Cristianini et al., 2000) (i.e. hinge loss), if we push the source domain and the target domain away from a margin rather than as far as possible, then the training task of $F$ to fool $D$ becomes easier. For a binary domain classifier, we define the margin loss as ",
+        "bbox": [
+            173,
+            446,
+            826,
+            641
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b85a5605f31b0e1bc43921a7dcf0432c1ace247307f20881c6c5320962af2b18.jpg",
+        "text": "$$\n\\mathcal { L } _ { m a r g i n } ( y ) = [ 0 , m - t \\cdot y ] ^ { + } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            397,
+            642,
+            599,
+            660
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $y$ is the predicted domain label, $[ \\cdot ] ^ { + } : = m a x ( 0 , \\cdot )$ , $m$ is a positive margin and $t$ is the ground truth label for two domains $t = - 1$ for the source domain and $t = 1$ for the target domain). Then we introduce our MDAT scheme based on an innovative network architecture. ",
+        "bbox": [
+            174,
+            666,
+            826,
+            709
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.3 MAX-MARGIN DOMAIN-ADVERSARIAL TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            728,
+            565,
+            742
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Besides the training instability issue, DAT also suffers from restrictive feature-level alignment – lack of pixel-level alignment. To realize stable and comprehensive domain alignment together, we first propose an Adversarial Reconstruction Network (ARN) and then elaborate MDAT. ",
+        "bbox": [
+            174,
+            756,
+            825,
+            797
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "As depicted in Figure 1, our model consists of three parts including a shared feature extractor $G _ { e }$ for both domains, a label predictor $G _ { y }$ and a reconstruction network $G _ { r }$ . Let the feature extractor $G _ { e } ( \\mathbf { x } ; \\theta _ { e } )$ be a function parameterized by $\\theta _ { e }$ which maps an input sample $\\mathbf { X }$ to a deep embedding z. Let the label predictor $G _ { y } ( \\pmb { z } ; \\theta _ { y } )$ be a task-specific function parameterized by $\\theta _ { y }$ which maps an embedding $\\mathbf { z }$ to a task-specific prediction $\\hat { y }$ . The reconstruction network $G _ { r } ( \\pmb { z } ; \\bar { \\theta } _ { r } )$ is a decoding function parameterized by $\\theta _ { r }$ that maps an embedding $\\mathbf { z }$ to its corresponding reconstruction $\\hat { \\bf x }$ . ",
+        "bbox": [
+            174,
+            804,
+            825,
+            888
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The first learning objective for the feature extractor $G _ { e }$ and label predictor $G _ { y }$ is to perform well in the source domain. For a supervised $\\mathrm { K }$ -way classification problem, it is simply achieved by minimizing the negative log-likelihood of the ground truth class for each sample: ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            625,
+            118
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/783ff0d0837912ac8e3754526b684318e5c7a062bca0c4fd9dc8ba02f3c37501.jpg",
+        "text": "$$\n\\mathcal { L } _ { t a s k } = \\sum _ { i = 1 } ^ { N _ { s } } \\mathcal { L } _ { y } ( \\mathbf { x } _ { i } ^ { s } , \\mathbf { y } _ { i } ^ { s } ) = - \\sum _ { i = 1 } ^ { N _ { s } } \\mathbf { y } _ { i } ^ { s } \\cdot \\log G _ { y } ( G _ { e } ( \\mathbf { x } _ { i } ^ { s } ; \\boldsymbol { \\theta } _ { e } ) ; \\boldsymbol { \\theta } _ { y } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            297,
+            122,
+            699,
+            166
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { y } _ { i } ^ { s }$ is the one-hot encoding of the class label $y _ { i } ^ { s }$ and the logarithm operation is conducted on the softmax predictions of the model. ",
+        "bbox": [
+            173,
+            170,
+            821,
+            198
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The second objective is to render the feature learning to be domain-invariant. This is motivated by the covariate shift assumption (Shimodaira, 2000) that indicates if the feature distributions $\\dot { S } ( \\mathbf { z } ) = \\{ G _ { e } ( \\mathbf { x } ; \\theta _ { e } ) | \\mathbf { \\bar { x } } \\sim \\mathcal { D } _ { S } \\}$ and $T ( \\mathbf { z } ) = \\{ G _ { e } ( \\mathbf { x } ; \\boldsymbol { \\theta } _ { e } ) | \\mathbf { x } \\sim \\mathcal { D } _ { T } \\}$ are similar, the source label predictor $G _ { y }$ can achieve a similar high accuracy in the target domain. To this end, we design a decoder network $G _ { r }$ that serves as a domain classifier, and then MDAT could be applied for stable training. Different from the normal binary domain classifier, MDAT lets the decoder network $G _ { r }$ only reconstruct the features in the source domain and push the features in the target domain away from a margin $m$ . In this way, the decoder has the functionality of distinguishing the source domain from the target domain. The objective of training $G _ { r }$ is formulated as ",
+        "bbox": [
+            173,
+            204,
+            826,
+            330
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6761ad54604913ccc63b518aa86110fc3416fe5f55acc44defc7756ffdd7e9aa.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\theta _ { r } } \\sum _ { i = 1 } ^ { N _ { s } + N _ { t } } \\mathcal { L } _ { m a r g i n } ( \\mathcal { L } _ { r } ( \\mathbf { x } _ { i } ) ) = \\operatorname* { m i n } _ { \\theta _ { r } } \\sum _ { i = 1 } ^ { N _ { s } } \\mathcal { L } _ { r } ( \\mathbf { x } _ { i } ^ { s } ) + \\sum _ { j = 1 } ^ { N _ { t } } [ m - \\mathcal { L } _ { r } ( \\mathbf { x } _ { j } ^ { t } ) ] ^ { + } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            266,
+            334,
+            732,
+            380
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $m$ is a positive margin and $\\textstyle { \\mathcal { L } } _ { r } ( \\cdot )$ is the mean squared error (MSE) term for the reconstruction loss that is defined as ",
+        "bbox": [
+            173,
+            383,
+            826,
+            411
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e62e33fe92352f09cbfdc9aaad265a42c0f9c4a37d84829a196f1d0de21a66cb.jpg",
+        "text": "$$\n\\mathcal { L } _ { r } ( \\mathbf { x } ) = | | G _ { r } ( G _ { e } ( \\mathbf { x } ; \\boldsymbol { \\theta } _ { e } ) ; \\boldsymbol { \\theta } _ { r } ) - \\mathbf { x } | | _ { 2 } ^ { 2 } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            377,
+            410,
+            619,
+            428
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $| | \\cdot | | _ { 2 } ^ { 2 }$ denotes the squared $L _ { 2 }$ -norm. ",
+        "bbox": [
+            174,
+            429,
+            455,
+            444
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Oppositely, to form a minimax game, the feature extractor $G _ { e }$ learns to deceive $G _ { r }$ such that the learned target features are indistinguishable to the source ones, which is formulated by: ",
+        "bbox": [
+            173,
+            450,
+            825,
+            479
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/faf3d96881970cf85d3f4820a7c69fc76d5848e8dd69ad25ab2ca556bcf1576d.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\theta _ { e } } \\sum _ { j = 1 } ^ { N _ { t } } \\mathcal { L } _ { r } ( \\mathbf { x } _ { j } ^ { t } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            442,
+            483,
+            555,
+            529
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Then the whole learning procedure of ARN with MDAT can be formulated by: ",
+        "bbox": [
+            173,
+            531,
+            687,
+            547
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9a2954c8e7247d1087080837914553aca8bdf464fc85612c44ee63322be83544.jpg",
+        "text": "$$\n\\begin{array} { l } { { \\displaystyle \\operatorname* { m i n } _ { \\theta _ { e } , \\theta _ { c } } \\sum _ { i = 1 } ^ { N _ { s } } } \\mathcal { L } _ { y } ( \\mathbf { x } _ { i } ^ { s } , \\mathbf { y } _ { i } ^ { s } ) + \\alpha \\sum _ { j = 1 } ^ { N _ { t } } \\mathcal { L } _ { r } ( \\mathbf { x } _ { j } ^ { t } ) , \\ ~ } \\\\ { { \\displaystyle \\operatorname* { m i n } _ { \\theta _ { r } } \\sum _ { i = 1 } ^ { N _ { s } } } \\mathcal { L } _ { r } ( \\mathbf { x } _ { i } ^ { s } ) + \\sum _ { j = 1 } ^ { N _ { t } } [ m - \\mathcal { L } _ { r } ( \\mathbf { x } _ { j } ^ { t } ) ] ^ { + } , \\ ~ } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            370,
+            551,
+            625,
+            643
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathcal { L } _ { y }$ denotes the negative log-likelihood of the ground truth class for labeled sample $\\left( \\mathbf { x } _ { i } ^ { s } , \\mathbf { y } _ { i } ^ { s } \\right)$ and $\\alpha$ controls the interaction of the loss terms. In the following section, we provide theoretical justifications on how MDAT reduces the distribution discrepancy, and discuss why it is superior to the classic DAT. ",
+        "bbox": [
+            173,
+            646,
+            825,
+            703
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.4 THEORETICAL JUSTIFICATIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            719,
+            431,
+            734
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this section, we provide the theoretical justifications on how the proposed method reduces the distribution discrepancy for UDA. The rationale behind domain alignment is motivated from the learning theory of non-conservative domain adaptation problem by Ben-David et al. (Ben-David et al., 2010): ",
+        "bbox": [
+            173,
+            744,
+            825,
+            801
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Theorem 3.1 Let $\\mathcal { H }$ be the hypothesis space where $h \\in \\mathcal H$ . Let $( \\mathcal { D } _ { S } , \\epsilon _ { s } )$ and $( \\mathcal { D } _ { T } , \\epsilon _ { t } )$ be the two domains and their corresponding generalization error functions. The expected error for the target domain is upper bounded by ",
+        "bbox": [
+            173,
+            811,
+            825,
+            856
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3d327b6c73e550412fff37ca23c24a1f2a053e951733b121eecf8517ad64695a.jpg",
+        "text": "$$\n\\epsilon _ { t } ( h ) \\leq \\epsilon _ { s } ( h ) + \\frac { 1 } { 2 } d _ { \\mathscr { H } \\triangle \\mathscr { H } } ( \\mathscr { D } _ { S } , \\mathscr { D } _ { T } ) + \\lambda , \\forall h \\in \\mathscr { H } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            333,
+            859,
+            663,
+            890
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\begin{array} { r } { d _ { \\mathcal { H } \\triangle \\mathcal { H } } ( \\mathcal { D } _ { S } , \\mathcal { D } _ { T } ) = 2 \\operatorname* { s u p } _ { h _ { 1 } , h _ { 2 } \\in \\mathcal { H } } \\big | \\operatorname* { P r } _ { x \\sim \\mathcal { D } _ { S } } [ h _ { 1 } ( x ) \\neq h _ { 2 } ( x ) ] - \\operatorname* { P r } _ { x \\sim \\mathcal { D } _ { T } } [ h _ { 1 } ( x ) \\neq h _ { 2 } ( x ) ] \\big | } \\end{array}$ and $\\lambda = \\mathrm { m i n } _ { h } [ \\epsilon _ { s } ( h ) + \\epsilon _ { t } ( h ) ]$ . ",
+        "bbox": [
+            174,
+            892,
+            825,
+            925
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Theoretically, when we minimize the $\\mathcal { H } \\triangle \\mathcal { H }$ -distance, the upper bound of the expected error for the target domain is reduced accordingly. As derived in DAT (Ganin $\\&$ Lempitsky, 2015), assuming a family of domain classifiers $\\mathcal { H } _ { d }$ to be rich enough to contain the symmetric difference hypothesis set of $\\mathcal { H } _ { p }$ , such that $\\mathcal { H } _ { p } \\triangle \\mathcal { H } _ { p } = \\{ h | h = h _ { 1 } \\oplus \\bar { h } _ { 2 } , h _ { 1 } , h _ { 2 } \\in \\mathcal { H } _ { p } \\}$ where $\\oplus$ is XOR-function, the empirical $\\mathcal { H } _ { p } \\triangle \\mathcal { H } _ { p }$ -distance has an upper bound with regard to the optimal domain classifier $h$ : ",
+        "bbox": [
+            173,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b152177d9a633b49e19d8a82fb386a1a5476ff3b6f9249b901a01c8d209c7056.jpg",
+        "text": "$$\nd _ { \\mathcal H _ { p } \\triangle \\mathcal H _ { p } } ( \\hat { D } _ { S } , \\hat { D } _ { T } ) \\le 2 \\operatorname* { s u p } _ { h \\in \\mathcal H _ { d } } \\vert \\operatorname* { P r } _ { \\mathbf z \\sim \\hat { D } _ { S } } [ h ( \\mathbf z ) = 0 ] + \\operatorname* { P r } _ { \\mathbf z \\sim \\hat { D } _ { T } } [ h ( \\mathbf z ) = 1 ] - 1 \\vert ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            266,
+            181,
+            730,
+            210
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\hat { \\mathcal { D } } _ { S }$ and $\\hat { \\mathcal { D } } _ { T }$ denote the distributions of the source and target feature space ${ \\mathcal { Z } } _ { S }$ and ${ \\mathcal { Z } } _ { T }$ , respectively. Note that the MSE of $G _ { r }$ plus a ceiling function is a form of domain classifier $h ( \\mathbf { z } )$ , i.e. $\\lceil [ m - \\bar { \\mathcal { L } } _ { r } ( \\cdot ) ] ^ { + } - 0 . 5 \\rceil$ for $m = 1$ . It maps source samples to 0 and target samples to 1 which is exactly the upper bound in Eq.10. Therefore, our reconstruction network $G _ { r }$ maximizes the domain discrepancy with a margin and the feature extractor learns to minimize it oppositely. ",
+        "bbox": [
+            174,
+            219,
+            825,
+            290
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.5 DISCUSSIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            308,
+            310,
+            321
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Compared with the conventional DAT-based methods that are usually based on a binary logistic network (Ganin & Lempitsky, 2015), the proposed ARN with MDAT is more attractive and incorporates new merits conceptually and theoretically: ",
+        "bbox": [
+            174,
+            333,
+            825,
+            376
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "(1) Stable training and insensitivity to hyper-parameters. Using the decoder as domain classifier with a margin loss to restrain its overwhelming capacity in adversarial training, the minimax game can continuously provide effective gradients for training the feature extractor. Moreover, through the experiments in Section 4, we discover that our method shows strong robustness to the hyperparameters, i.e. $\\alpha$ and $m$ , greatly alleviating the parameters tuning for model selection. ",
+        "bbox": [
+            174,
+            383,
+            825,
+            453
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "(2) Richer information for comprehensive domain alignment. Rather than DAT that uses a bit of domain information, MDAT utilizes the reconstruction network as the domain classifier that could capture more domain-specific and pixel-level features during the unsupervised reconstruction (Bousmalis et al., 2016). Therefore, MDAT further helps address pixel-level domain shift apart from the feature-level shift, leading to comprehensive domain alignment in a straightforward manner. ",
+        "bbox": [
+            174,
+            460,
+            825,
+            530
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "(3) Feature visualization for method validation. Another key merit of MDAT is that MDAT allows us to visualize the features directly by the reconstruction network. It is crucial to understand to what extent the features are aligned since this helps to reveal the underlying mechanism of adversarial domain adaptation. We will detail the interpretability of these adapted features in Section 4.3. ",
+        "bbox": [
+            174,
+            536,
+            825,
+            593
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            613,
+            316,
+            628
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section, we evaluate the proposed ARN with MDAT on a number of visual and non-visual UDA tasks with varying degrees of domain shift. We conduct ablation study to corroborate the effectiveness of MDAT and unsupervised reconstruction for UDA. Then the sensitivity of the hyperparameters is investigated, and the adapted features are interpreted via the reconstruction network in ARN. ",
+        "bbox": [
+            174,
+            645,
+            825,
+            700
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Setup. We evaluate our method on four classic visual UDA datasets and a WiFi-based Gesture Recognition (WGR) dataset (Zou et al., 2019). The classic datasets have middle level of domain shift including MNIST (LeCun et al., 1998), USPS (Hull, 1994), Street View House Numbers (SVHN) (Netzer et al., 2011) and Synthetic Digits (SYN). For a fair comparison, we follow the same CNN architecture as DANN (Ganin & Lempitsky, 2015) while using the inverse of $G _ { e }$ as $G _ { r }$ with pooling operation replaced by upsampling. For the penalty term $\\alpha$ , we choose 0.02 by searching over the grid $\\lbrace 1 0 ^ { - 2 } , \\dot { 1 } \\rbrace$ . We also obtain the optimal margin $m = 5$ by a search over $\\{ 1 0 ^ { \\dot { - } 1 } , 1 0 \\}$ . Then we use the same hyperparameter settings for all tasks to show the robustness. For the optimization, we simply use Adam Optimizer $( l r = 2 \\times 1 0 ^ { - 4 } , \\beta _ { 1 } = 0 . 5 , \\beta _ { 2 } = 0 . 9 9 9 )$ and train all experiments for 50 epochs with batch size 128. We implemented our model and conducted all the experiments using the PyTorch framework. More implementation details are illustrated in the appendix. ",
+        "bbox": [
+            174,
+            708,
+            825,
+            861
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Baselines. We evaluate the efficacy of our approach by comparing it with existing UDA methods that perform three ways of domain alignment. Specifically, MMD regularization (Long et al., 2015) and Correlation Alignment (Sun & Saenko, 2016) employ the statistical distribution matching. DRCN (Ghifary et al., 2016) and DSN (Bousmalis et al., 2016) use the reconstruction error for UDA, ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/9af9048b7549ce86f7ba30b37c018586aff61659311ef402e9aaf8b857e365eb.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Source Target</td><td>MNIST USPS</td><td>USPS MNIST</td><td>SVHN MNIST</td><td>SYN SVHN</td></tr><tr><td>Source-Only model</td><td>78.2</td><td>63.4</td><td>54.9</td><td>86.7</td></tr><tr><td>Train on target</td><td>96.5</td><td>99.4</td><td>99.4</td><td>91.3</td></tr><tr><td>[S] MMD (Long et al., 2015)</td><td>81.1</td><td>-</td><td>71.1</td><td>88.0</td></tr><tr><td>[S] CORAL (Sun &amp; Saenko, 2016)</td><td>80.7</td><td>-</td><td>63.1</td><td>85.2</td></tr><tr><td>[R] DRCN* (Ghifary et al.,2016)</td><td>91.8</td><td>73.7</td><td>82.0</td><td>87.5</td></tr><tr><td>[R] DSN (Bousmalis et al., 2016)</td><td>91.3</td><td>-</td><td>82.7</td><td>91.2</td></tr><tr><td>[A] DANN (Ganin et al., 2016)</td><td>85.1</td><td>73.0</td><td>74.7</td><td>90.3</td></tr><tr><td>[A] ADDA (Tzeng et al., 2017)</td><td>89.4</td><td>90.1</td><td>76.0</td><td>-</td></tr><tr><td>[A] CyCADA (Hoffman et al., 2018)</td><td>95.6</td><td>96.5</td><td>90.4</td><td>-</td></tr><tr><td>[A] CADA (Zou et al., 2019)</td><td>96.4</td><td>97.0</td><td>90.9</td><td>1</td></tr><tr><td>[A] MECA (Morerio et al.,2018)</td><td>-</td><td>-</td><td>95.2</td><td>90.3</td></tr><tr><td>ARN w.0. MDAT</td><td>93.1±0.3</td><td>76.5±1.2</td><td>67.4±0.9</td><td>86.8±0.5</td></tr><tr><td>ARN with MDAT (proposed)</td><td>98.6±0.3</td><td>98.4±0.1</td><td>97.4±0.3</td><td>92.0±0.2</td></tr></table>",
+        "bbox": [
+            225,
+            102,
+            772,
+            337
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 1: We compare with general, statistics-based (S), reconstruction-based $\\mathbf { ( R ) }$ and adversarialbased (A) state-of-the-art approaches. We repeated each experiment for 3 times and report the average and standard deviation (std) of the test accuracy in the target domain. ",
+        "bbox": [
+            174,
+            353,
+            823,
+            396
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "while many prevailing UDA methods adopt domain-adversarial training including DANN (Ganin & Lempitsky, 2015), ADDA (Tzeng et al., 2017), MECA (Morerio et al., 2018), CyCADA (Hoffman et al., 2018) and CADA (Zou et al., 2019). For all transfer tasks, we follow the same protocol as DANN (Ganin & Lempitsky, 2015) that uses official training data split in both domains for training and evaluates the testing data split in the target domain. ",
+        "bbox": [
+            173,
+            405,
+            825,
+            477
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 OVERALL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            534,
+            349,
+            547
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "MNIST USPS. Both datasets are composed of grey-scale handwritten images with diverse stroke weights, leading to low-level domain shift. Since USPS has only 7291 training images, USPS ${ \\bf { \\Gamma } } \\to \\mathbf { M N I S T }$ is more difficult. As shown in Table 1, our method achieves state-of-the-art accuracy of $9 8 . 6 \\%$ on MNIST USPS and $9 8 . 4 \\%$ on USPS MNIST, which demonstrates that ARN can tackle low-level domain shift by only using ART (rather than many adversarial UDA methods that adopt other loss terms to adjust classifier boundaries or conduct style transfer). ",
+        "bbox": [
+            173,
+            575,
+            826,
+            660
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/bfbff349d542ae05b2faaed0607e66fe783b25520c9a3eeb039d2e5ec2258fe4.jpg",
+        "table_caption": [
+            "Table 2: Comparisons on WGR. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>SourceTarget</td><td rowspan=1 colspan=1>Room ARoom B</td></tr><tr><td rowspan=1 colspan=1>Method</td><td rowspan=1 colspan=1>Accuracy (%)</td></tr><tr><td rowspan=1 colspan=1>Source-only[S] MMD</td><td rowspan=2 colspan=1>58.4±0.761.2±0.569.3±0.3</td></tr><tr><td rowspan=1 colspan=1>[R] DRCN</td></tr><tr><td rowspan=1 colspan=1>[A]DANN</td><td rowspan=1 colspan=1>68.2±0.2</td></tr><tr><td rowspan=1 colspan=1>[A] ADDA</td><td rowspan=1 colspan=1>71.5±0.3</td></tr><tr><td rowspan=1 colspan=1>[A] CADA</td><td rowspan=1 colspan=1>88.8±0.1</td></tr><tr><td rowspan=1 colspan=1>ARN+MDAT</td><td rowspan=1 colspan=1>91.3±0.2</td></tr></table>",
+        "bbox": [
+            588,
+            695,
+            795,
+            842
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "SVHN MNIST and $\\mathbf { S Y N } {  } \\mathbf { S V H N }$ . The SVHN dataset contains RGB digit images that introduce significant variations such as scale, background, embossing, rotation, slanting and even multiple digits. The SYN data consists of $5 0 k$ RGB images of varying color, background, blur and orientation. These two tasks have tremendous pixel-level domain shfit. The proposed method achieves a state-ofthe-art performance of $9 7 . 4 \\%$ for $\\mathbf { S V H N { \\to } M N I S T }$ , far ahead of other DAT-based methods, significantly improving the classic DANN by $2 2 . 7 \\%$ . Similarly, ARN with MDAT also achieves a noticeable improvement of $5 . 3 \\%$ compared with the source-only model, even outperforming the supervised SVHN accuracy $9 1 . 3 \\%$ . ",
+        "bbox": [
+            174,
+            666,
+            550,
+            847
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "WiFi Gesture Recognition with Distant Domains. To evaluate the proposed method on a non-visual UDA task, we applied our method to the WiFi gesture recognition dataset (Zou et al., 2019). The WiFi data of six gestures was collected in two rooms regarded as two domains. The results in Table 2 demonstrate that our approach significantly improves classification accuracy against Source-Only and DANN by $3 2 . 9 \\%$ and $2 3 . 1 \\%$ , respectively. ",
+        "bbox": [
+            174,
+            854,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/d2ea4a21c9f6e39ad013915716916441f9c11113bbcc38f94344d04946b1e7e3.jpg",
+        "table_caption": [
+            "Table 3: The accuracy $( \\% )$ with different hyperparameters on SVHN MNIST. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>a</td><td>0.01</td><td>0.03</td><td>0.07</td><td>0.1</td><td>0.2</td><td>0.3</td><td>0.5</td><td>1.0</td></tr><tr><td>DANN</td><td>71.1</td><td>74.1</td><td>72.7</td><td>74.1</td><td>74.7</td><td>9.6</td><td>9.7</td><td>10.3</td></tr><tr><td>ARN (m = 1)</td><td>95.7</td><td>95.9</td><td>93.3</td><td>93.2</td><td>80.1</td><td>75.3</td><td>73.1</td><td>67.5</td></tr><tr><td>m</td><td>0.1</td><td>0.3</td><td>0.5</td><td>0.7</td><td>1.0</td><td>2.0</td><td>5.0</td><td>10.0</td></tr><tr><td>ARN(α = 2e-2)</td><td>64.5</td><td>75.2</td><td>90.0</td><td>92.6</td><td>96.0</td><td>97.4</td><td>97.7</td><td>96.7</td></tr></table>",
+        "bbox": [
+            253,
+            102,
+            745,
+            185
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 ABLATION STUDY AND SENSITIVITY ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            226,
+            547,
+            241
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The contribution of MDAT and image reconstruction in ARN. We design an ablation study to verify the contribution of MDAT and unsupervised reconstruction in ARN. To this end, we discard the term $\\dot { \\mathcal { L } } _ { r } ( \\mathbf { x } ^ { t } )$ in Eq.4, and evaluate the method, denoted as ARN w.o. MDAT in Table 1. (1) Comparing ARN w.o. MDAT with source-only model, we can infer the effect of unsupervised reconstruction for UDA. It is observed that ARN w.o. MDAT improves tasks with low-level domain shift such as MNIST USPS, which conforms with our discussion that the unsupervised reconstruction is instrumental in learning low-level features. (2) Comparing ARN w.o. MDAT with the original ARN, we can infer the contribution of MDAT. Table 1 shows that the MDAT achieves an impressive marginof-improvement. For USPS MNIST and SV $\\mathbf { H N } {  } \\mathbf { M N }$ IST, the MDAT improves ARN w.o. MDAT by around $30 \\%$ . It demonstrates that MDAT which helps learn domain-invariant representations is the main reason for the tremendous improvement. ",
+        "bbox": [
+            173,
+            261,
+            825,
+            414
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Parameter sensitivity. We investigate the effect of $\\alpha$ and $m$ on S $\\mathbf { \\nabla } \\sqrt { \\mathbf { H N } } \\to \\mathbf { M }$ NIST. The results in Table 3 show that ARN achieves good performance as $\\alpha \\in [ 0 . 0 1 , 0 . 1 ]$ and even with larger $\\alpha$ ARN is able to achieve convergence. In comparison, denoting $\\alpha$ as the weight of adversarial loss, the DANN cannot converge when $\\alpha > 0 . 2$ . For the sensitivity of $m$ , the accuracy of ARN exceeds $9 6 . 0 \\%$ as $m \\geq 1$ . These analyses validate that the training of ARN is not sensitive to the parameters and even in the worst cases ARN can achieve convergence. ",
+        "bbox": [
+            173,
+            420,
+            825,
+            505
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Gradients and training procedure. We draw the training procedure with regard to loss and target accuracy in Figure 2(b) and Figure 2(a), respectively. In Figure 2(b), ARN has smoother and more effective gradients $( \\mathcal { L } _ { r } )$ for all $\\alpha$ , while the loss of DAT domain classifier $( \\mathcal { L } _ { d } )$ gets extremely small at the beginning. This observation conforms with our intuition, which demonstrates that by restricting the capacity of domain classifier MDAT provides more effective gradients for training feature extractor, leading to a more stable training procedure. This could be further validated in Figure 2(b) where the ARN accuracy is more stable than that of DAT across training epochs. ",
+        "bbox": [
+            173,
+            511,
+            825,
+            609
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/52dba511d647d639645ebf2e30bb3449cb0c5632abfcd2262b3a859d0381b616.jpg",
+        "image_caption": [
+            "Figure 2: The training procedure with regard to loss and test accuracy. ( $\\mathcal { L } _ { e } : = \\mathrm { E q }$ . 6; $\\mathcal { L } _ { r }$ := Eq. 4; $\\mathcal { L } _ { d }$ is the domain loss of DAT (Ganin & Lempitsky, 2015); $\\alpha$ is the penalty term of $\\mathcal { L } _ { e }$ and $\\mathcal { L } _ { d }$ .) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            647,
+            810,
+            849
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/5acb62d70fb07c773536883b202f55b93481d60b958df9f7e0e81fadef8c9626.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Source Images</td><td>Target Images</td><td>R-Target Images</td></tr><tr><td>MNIST→USPS</td><td>72/04149 97349665 34727121</td><td>06181328 Li;97210 10140198</td><td>618132 108:019 3</td></tr><tr><td>USPS→MNIST</td><td>01870009 z568928i 35418305</td><td>7210414a 97349665 341727121</td><td>72104197 97s41665 34727121</td></tr><tr><td>SVHN→MNIST</td><td>0103457N0 2 19 5 5259.012 1310</td><td>59069015 0740131 2413512</td><td>9101e19101115 :1061:01511 gCk ES52</td></tr><tr><td>SYN-→SVHN</td><td>14366 40570 6.75/ 65 3607 37 1236:83811 094</td><td>6s 31 140885 3 96 品 3913b8m</td><td>64040003 30296651 39)-0s81</td></tr></table>",
+        "bbox": [
+            183,
+            102,
+            810,
+            332
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 4: Visualizing the source image, target images and reconstructed target images (R-Target Images) for four digit adaptation tasks. ",
+        "bbox": [
+            176,
+            342,
+            823,
+            371
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3 VISUALIZATION AND ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            381,
+            436,
+            395
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Interpreting MDAT features via reconstructed images. One of the key advantages of ARN is that by visualizing the reconstructed target images we can infer how the features are domain-invariant. We reconstruct the MDAT features of the test data and visualize them in Table 4. It is observed that the target features are reconstructed to source-like images by the decoder $G _ { r }$ . As discussed before, intuitively, MDAT forces the target features to mimic the source features, which conforms with our visualization. Similar to image-to-image translation, this indicates that our method conducts implicit feature-to-feature translation that transfers the target features to source-like features, and hence the features become domain-invariant. ",
+        "bbox": [
+            173,
+            406,
+            825,
+            518
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "T-SNE embeddings. We analyze the performance of domain alignment for DANN (DAT) (Ganin & Lempitsky, 2015) and ARN (MDAT) by plotting T-SNE embeddings of the features $\\mathbf { z }$ on the task SVHN MNIST. In Figure 3(a), the source-only model obtains diverse embeddings for each category but the domains are not aligned. In Figure 3(b), the DANN aligns two domains but the decision boundaries of the classifier are vague. In Figure 3(c), the proposed ARN effectively aligns two domains for all categories and the classifier boundaries are much clearer. ",
+        "bbox": [
+            173,
+            525,
+            825,
+            609
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/1bdd1728d9463ce082756cdc92cdc0b4e757f2ee7ad1eb5dff92cdabfb33cf61.jpg",
+        "image_caption": [
+            "Figure 3: T-SNE visualization on SVHN MNIST with their corresponding domain labels (red: target; blue: source) and category labels (10 classes) shown in the left and right subfigures, respectively. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            628,
+            820,
+            719
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            791,
+            318,
+            808
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We proposed a new domain alignment approach namely max-margin domain-adversarial training (MDAT) and a MDAT-based network for unsupervised domain adaptation. The proposed method offers effective and stable gradients for the feature learning via an adversarial game between the feature extractor and the reconstruction network. The theoretical analysis provides justifications on how it minimizes the distribution discrepancy. Extensive experiments demonstrate the effectiveness of our method and we further interpret the features by visualization that conforms with our insight. Potential evaluation on semi-supervised learning constitutes our future work. ",
+        "bbox": [
+            173,
+            823,
+            825,
+            921
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            287,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Shai Ben-David, John Blitzer, Koby Crammer, Alex Kulesza, Fernando Pereira, and Jennifer Wortman Vaughan. A theory of learning from different domains. Machine learning, 79(1-2):151–175, 2010. ",
+        "bbox": [
+            174,
+            126,
+            825,
+            155
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Konstantinos Bousmalis, George Trigeorgis, Nathan Silberman, Dilip Krishnan, and Dumitru Erhan. Domain separation networks. In Advances in Neural Information Processing Systems, pp. 343–351, 2016. ",
+        "bbox": [
+            176,
+            164,
+            825,
+            207
+        ],
+        "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 Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3722–3731, 2017. ",
+        "bbox": [
+            176,
+            217,
+            823,
+            260
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yuhua Chen, Wen Li, Christos Sakaridis, Dengxin Dai, and Luc Van Gool. Domain adaptive faster r-cnn for object detection in the wild. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3339–3348, 2018. ",
+        "bbox": [
+            174,
+            268,
+            826,
+            313
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Nello Cristianini, John Shawe-Taylor, et al. An introduction to support vector machines and other kernel-based learning methods. Cambridge university press, 2000. ",
+        "bbox": [
+            173,
+            321,
+            823,
+            351
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yaroslav Ganin and Victor Lempitsky. Unsupervised domain adaptation by backpropagation. In Francis Bach and David Blei (eds.), Proceedings of the 32nd International Conference on Machine Learning, volume 37 of Proceedings of Machine Learning Research, pp. 1180–1189, Lille, France, 07–09 Jul 2015. PMLR. ",
+        "bbox": [
+            174,
+            359,
+            826,
+            416
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yaroslav Ganin, Evgeniya Ustinova, Hana Ajakan, Pascal Germain, Hugo Larochelle, Franc¸ois Laviolette, Mario Marchand, and Victor Lempitsky. Domain-adversarial training of neural networks. The Journal of Machine Learning Research, 17(1):2096–2030, 2016. ",
+        "bbox": [
+            178,
+            426,
+            823,
+            469
+        ],
+        "page_idx": 8
+    },
+    {
+        "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, pp. 597–613. Springer, 2016. ",
+        "bbox": [
+            174,
+            478,
+            825,
+            522
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Xavier Glorot, Antoine Bordes, and Yoshua Bengio. Domain adaptation for large-scale sentiment classification: A deep learning approach. In Proceedings of the 28th International Conference on Machine Learning (ICML-11), pp. 513–520, 2011. ",
+        "bbox": [
+            174,
+            531,
+            825,
+            574
+        ],
+        "page_idx": 8
+    },
+    {
+        "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, pp. 2672–2680, 2014. ",
+        "bbox": [
+            174,
+            583,
+            826,
+            627
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Judy Hoffman, Eric Tzeng, Taesung Park, Jun-Yan Zhu, Phillip Isola, Kate Saenko, Alexei Efros, and Trevor Darrell. CyCADA: Cycle-consistent adversarial domain adaptation. In Proceedings of the 35th International Conference on Machine Learning, pp. 1989–1998, 2018. ",
+        "bbox": [
+            173,
+            636,
+            826,
+            679
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jonathan J. Hull. A database for handwritten text recognition research. IEEE Transactions on Pattern Analysis and Machine Intelligence, 16(5):550–554, 1994. ",
+        "bbox": [
+            171,
+            688,
+            823,
+            718
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998. ",
+        "bbox": [
+            171,
+            727,
+            823,
+            757
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Yoshua Bengio, and Geoffrey Hinton. Deep learning. nature, 521(7553):436, 2015. ",
+        "bbox": [
+            173,
+            765,
+            813,
+            781
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mingsheng Long, Yue Cao, Jianmin Wang, and Michael I. Jordan. Learning transferable features with deep adaptation networks. In Proceedings of the 32Nd International Conference on International Conference on Machine Learning - Volume 37, ICML’15, pp. 97–105, 2015. ",
+        "bbox": [
+            174,
+            790,
+            825,
+            833
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mingsheng Long, Zhangjie Cao, Jianmin Wang, and Michael I Jordan. Conditional adversarial domain adaptation. In Advances in Neural Information Processing Systems, 2018. ",
+        "bbox": [
+            171,
+            842,
+            823,
+            872
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Pietro Morerio, Jacopo Cavazza, and Vittorio Murino. Minimal-entropy correlation alignment for unsupervised deep domain adaptation. In International Conference on Learning Representations, 2018. URL https://openreview.net/forum?id=rJWechg0Z. ",
+        "bbox": [
+            176,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "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, volume 2011, pp. 5, 2011. ",
+        "bbox": [
+            178,
+            103,
+            821,
+            146
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hidetoshi Shimodaira. Improving predictive inference under covariate shift by weighting the loglikelihood function. Journal of statistical planning and inference, 90(2):227–244, 2000. ",
+        "bbox": [
+            173,
+            155,
+            825,
+            184
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Rui Shu, Hung H Bui, Hirokazu Narui, and Stefano Ermon. A dirt-t approach to unsupervised domain adaptation. In Proc. 6th International Conference on Learning Representations, 2018. ",
+        "bbox": [
+            173,
+            193,
+            823,
+            222
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Baochen Sun and Kate Saenko. Deep coral: Correlation alignment for deep domain adaptation. In European Conference on Computer Vision, pp. 443–450. Springer, 2016. ",
+        "bbox": [
+            173,
+            231,
+            825,
+            260
+        ],
+        "page_idx": 9
+    },
+    {
+        "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": [
+            174,
+            267,
+            825,
+            310
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Eric Tzeng, Judy Hoffman, Kate Saenko, and Trevor Darrell. Adversarial discriminative domain adaptation. In Computer Vision and Pattern Recognition (CVPR), volume 1, pp. 4, 2017. ",
+        "bbox": [
+            174,
+            319,
+            823,
+            349
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David Vazquez, Antonio M Lopez, Javier Marin, Daniel Ponsa, and David Geronimo. Virtual and real world adaptation for pedestrian detection. IEEE Transactions on Pattern Analysis and Machine Intelligence, 36(4):797–809, 2013. ",
+        "bbox": [
+            174,
+            357,
+            823,
+            400
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Han Zou, Yuxun Zhou, Jianfei Yang, Huihan Liu, Hari Prasanna Das, and Costas J Spanos. Consensus adversarial domain adaptation. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, pp. 5997–6004, 2019. ",
+        "bbox": [
+            174,
+            409,
+            826,
+            452
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            263,
+            117
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "IMPLEMENTATION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            137,
+            367,
+            151
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Hyperparameter For all tasks, we simply use the same hyperparameters that are chosen from the sensitivity analysis. We use $\\alpha = 0 . 0 2$ and $m = 5 . 0$ , and we reckon that better results can be obtained by tuning the hyperparameters for specific tasks. ",
+        "bbox": [
+            174,
+            166,
+            825,
+            208
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Network Architecture For a fair comparison, we follow the network in DANN (Ganin & Lempitsky, 2015) for digit adaptation and simply build the reconstruction network by the inverse network of the extractor. Here we draw the network architectures in Table 5. For WiFi gesture recognition, we adopt the same architecture as CADA (Zou et al., 2019) that is a modified version of LeNet-5. ",
+        "bbox": [
+            173,
+            215,
+            825,
+            272
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/cffbc1b636266ca74453a89956c605d17c0fba23e689f893ea7e780c67f4c7cc.jpg",
+        "table_caption": [
+            "Table 5: The network architecture used in the experiments. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Layer Index|</td><td rowspan=1 colspan=1>Feature Extractor</td><td rowspan=1 colspan=2>Decoder Network一Label Predictor</td></tr><tr><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=3>32 × 32 × 3 Image</td></tr><tr><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1> 5 × 5 conv. 64 ReLU</td><td rowspan=1 colspan=1>2048 dense, ReLU</td><td rowspan=1 colspan=1>10 dense, softmax</td></tr><tr><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>3 × 3 max-pool, stride 2</td><td rowspan=1 colspan=1>3072 dense, ReLU</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>5 × 5 conv. 64 ReLU</td><td rowspan=1 colspan=2> 5 × 5 conv. 128 ReLU</td></tr><tr><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1> 3 × 3 max-pool, stride 2</td><td rowspan=1 colspan=1>upsample 2</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>5</td><td rowspan=1 colspan=1>5 × 5 conv. 128 ReLU</td><td rowspan=1 colspan=1>5 × 5 conv. 64 ReLU</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>6</td><td rowspan=1 colspan=1> 3072 dense,dropout, ReLU</td><td rowspan=1 colspan=1>upsample 2     一</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>7</td><td rowspan=1 colspan=1>2048 dense, dropout ReLU丨 5 × 5 conv. 64 ReLU</td><td rowspan=1 colspan=1>2048 dense, dropout ReLU丨 5 × 5 conv. 64 ReLU</td><td rowspan=1 colspan=1></td></tr></table>",
+        "bbox": [
+            173,
+            291,
+            781,
+            481
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "SENSITIVITY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            551,
+            266,
+            565
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We have presented all the results of the sensitivity study in Section 4.2, and now we show their detailed training procedures in Figure 4(a) and 4(b). It is observed that the accuracy increases when $\\alpha$ drops or the margin $m$ increases. The reason is very simple: (1) when $\\alpha$ is too large, it affects the effect of supervised training on source domain; (2) when the margin $m$ is small, the divergence between source and target domain (i.e. $\\mathcal { H } \\triangle \\mathcal { H }$ -distance) cannot be measured well. ",
+        "bbox": [
+            173,
+            579,
+            825,
+            650
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/51fdf51eb7f411f3f5d635607678c3149a1ab54683a9f9149fc92a99b18e13cf.jpg",
+        "image_caption": [
+            "Figure 4: The training procedure of ARN with different hyper-parameters. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            676,
+            810,
+            877
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "VISUALIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            104,
+            287,
+            117
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Here we provide more visualization of the reconstructed images of target samples. In Figure 5, the target samples are shown in the left column while their corresponding reconstructed samples are shown in the right. We can see that for low-level domain shift such as $\\mathbf { M N I S T } {  } \\mathbf { U S P } \\mathbf { \\xi }$ S, the reconstructed target samples are very source-like while preserving their original shapes and skeletons. However, for larger domain shift in Figure 5(c) and 5(d), they are reconstructed to source-like same digits but simultaneously some noises are removed. Specifically, in Figure 5(d), we can see that one target sample (SVHN) may contain more than one digits that are noises for recognition. After reconstruction, only the right digits are reconstructed. Some target samples may suffer from terrible illumination conditions but their reconstructed digits are very clear, which is amazing. ",
+        "bbox": [
+            174,
+            128,
+            826,
+            256
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/c5f148db888d641992e5b170fed0b90b7901569b1c01614ca8392603fd460948.jpg",
+        "image_caption": [
+            "Figure 5: Visualization of the target samples and their corresponding reconstructed target samples. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            260,
+            816,
+            859
+        ],
+        "page_idx": 11
+    }
+]

parse/train/H178hw9ex/H178hw9ex.md

@@ -0,0 +1,341 @@
+# DYNAMIC STEERABLE FRAME NETWORKS
+
+Jorn-Henrik Jacobsen ¨ 1, Bert De Brabandere2, Arnold W.M. Smeulders1
+
+1Department of Computer Science, University of Amsterdam 2ESAT-PSI, KU Leuven {j.jacobsen,a.w.m.smeulders}@uva.nl bert.debrabandere@esat.kuleuven.be
+
+# ABSTRACT
+
+Filters in a convolutional network are typically parametrized in a pixel basis. As an orthonormal basis, pixels may represent any arbitrary vector in $\mathbb { R } ^ { n }$ . In this paper, we relax this orthonormality requirement and extend the set of viable bases to the generalized notion of frames. When applying suitable frame bases to ResNets on Cifar- $^ { 1 0 + }$ we demonstrate improved error rates by substitution only. By exploiting the transformation properties of such generalized bases, we arrive at steerable frames, that allow to continuously transform CNN filters under arbitrary Lie-groups. Further allowing us to locally separate pose from canonical appearance. We implement this in the Dynamic Steerable Frame Network, that dynamically estimates the transformations of filters, conditioned on its input. The derived method presents a hybrid of Dynamic Filter Networks and Spatial Transformer Networks that can be implemented in any convolutional architecture, as we illustrate in two examples. First, we illustrate estimation properties of steerable frames with a Dynamic Steerable Frame Network, compared to a Dynamic Filter Network on the task of edge detection, where we show clear advantages of the derived steerable frames. Lastly, we insert the Dynamic Steerable Frame Network as a module in a convolutional LSTM on the task of limited-data hand-gesture recognition from video and illustrate effective dynamic regularization and show clear advantages over Spatial Transformer Networks. In this paper, we have laid out the foundations of Frame-based convolutional networks and Dynamic Steerable Frame Networks while illustrating their advantages for continuously transforming features and data-efficient learning.
+
+# 1 INTRODUCTION
+
+For images, as well as any other sensory data, convolutional networks are typically learned from individual pixel values. Using them as a basis of the learned parameters is the standard approach for almost all CNNs. In this paper, we argue, that the pixel basis is not necessarily the best choice for representing signals. We show, that suitable alternatives yield increased classification performance by replacement only, while such a replacement adds additional properties to the learned filters that allow us to transform them under arbitrary pre-defined Lie groups.
+
+From our perspective, the pixel values span an orthogonal basis for the filters in the network (in every layer). Such a pixel basis is complete as it may represent an arbitrary vector in $\mathbb { R } ^ { n }$ by linear combination, where $n$ is the dimensionality of the filter. In this paper we consider alternatives to this basis, both orthogonal bases, and non-orthogonal frames, arriving at superior expressiveness through steerable function spaces that allow us to transform filters locally and continuously, conditioned on their input.
+
+Utilizing the steerability properties of frames in practice, we propose Dynamic Steerable Frame Networks (DSFNs) that fill the gap between Spatial Transformer Networks (STNs) (Jaderberg et al., 2015) and Dynamic Filter Networks (DFNs) (De Brabandere et al., 2016). STNs are not locally adaptive, thus they fail in many cases where it is not beneficial to transform the image globally as it would destroy discriminative information (multiple deformable objects, discriminative dynamic movements) or where global registration is performed as a preprocessing step (medical images).
+
+DFNs are overcoming this restriction by locally transforming filters instead of globally transforming the whole feature stack as STNs do. However, DFNs are black boxes and not data-efficient, as they introduce many unconstrained parameters. Such a behavior is undesirable when data is limited and interpretability is key. DSFNs are locally adaptive, interpretable and data-efficient. They overcome the weaknesses of both approaches by combining their strengths, as illustrated in multiple experiments.
+
+Our contributions:
+
+• We argue that suitable frame bases are beneficial when representing sensory data compared to the commonly used pixel basis. • Exploiting the transformation properties of frames further, we derive Dynamic Steerable Frame Networks that are able to continuously transform features locally and fill the gap between Spatial Transformer Networks and Dynamic Filter Networks. Dynamic Steerable Frame Networks learn to separate pose and feature. This enables the network to be locally equivariant or invariant with respect to certain feature poses, or even to perform in network quasi data-augmentation, while only the inputs and the backpropagated error signals determine which and to what extent these are applied.
+
+We introduce the generalized notion of frames to CNNs that extend possible bases to learn from to non-orthogonal and overcomplete sets without loss in generalization. We show that many choices are possible, while overcomplete, non-orthogonal bases consistently outperform the pixel basis when applied to a ResNet (He et al., 2016) for image classification, as illustrated on Cifar- $^ { 1 0 + }$ . We derive the Dynamic Steerable Frame Networks, based on the notion of steerable frames, that can locally adapt the filters in every feature map, conditioned on the input. We illustrate the strength of the approach in an edge detection task, where it outperforms a Dynamic Filter Network. We further show in a limited data video classification task, that Dynamic Steerable Frame Networks improve classification performance over Spatial Transformer Networks when global invariance is not desirable.
+
+# 2 DYNAMICALLY STEERABLE FRAME NETWORKS
+
+# 2.1 FRAMES
+
+Frames are a natural generalization of orthogonal bases (Christensen, 2003). In frame terminology, an orthonormal basis is a Parseval-tight frame with unit norm. Every tight frame preserves the signal norm and exhibits perfect reconstruction. Frames can be seen as a superset of orthogonal bases in the sense that every basis is a frame, but not the reverse, see figure 1. The advantage of considering frames over orthogonal bases is that intrinsic signal properties can be spelled out explicitly in the new representation with the advantage, that these properties are directly accessible during learning. From an overcomplete representation, it will be more easily visible which part of the features is robust and which part is sensitive to accidental noise variations.
+
+![](images/1209de074ff886412bb683f2c37e8c226b0b26766557f80a76c0ef5bd4c685d8.jpg)
+
+Figure 1: a) Is an orthonormal basis in $\mathbb { R } ^ { 2 }$ , $u _ { 1 }$ and $u _ { 2 }$ are linearly independent and span the space of $\mathbb { R } ^ { \tilde { 2 } }$ . A dot in this example represents a filter in a convolutional network with coefficients $\{ \bar { v } _ { 1 } , v _ { 2 } \}$ . b) A tight frame in $\mathbb { R } ^ { 2 }$ . $u _ { 1 } , u _ { 2 }$ and $u _ { 3 }$ are linearly dependent. A dot in this example represents a convolutional filter with coefficients $\{ v _ { 1 } , v _ { 2 } , v _ { 3 } \}$ . The frame is an overcomplete representation, again spanning $\mathbb { R } ^ { 2 }$ and again preserving the norm. Note that the set of filter coefficients as represented by the dot is not unique. Thus even if one $v$ is obstructed by noisy updates or measurements, the filter may still be robust.
+
+In a standard convolutional network, a filter kernel is a linear combination over the standard basis for $l ^ { 2 } ( \mathbb { N } )$ . The standard basis is composed from a delta function for every dimension and $W _ { i }$ is the $i _ { t h }$ filter of the network with parameters $w _ { n } ^ { i }$ :
+
+$$
+\begin{array} { l } { { \displaystyle e _ { 1 } = \{ 1 , 0 , 0 , . . . , 0 \} } } \\ { { \displaystyle e _ { 2 } = \{ 0 , 1 , 0 , . . . , 0 \} } } \\ { { \displaystyle . . . } } \\ { { \displaystyle e _ { n } = \{ 0 , 0 , 0 , . . . , 1 \} } } \\ { { \displaystyle W _ { i } = \sum _ { n = 1 } ^ { N } w _ { n } ^ { i } e _ { n } } } \end{array}
+$$
+
+Without loss of generalization the orthonormal standard basis can be replaced by a frame to include non-orthogonality, overcompleteness, increased symmetries or steerability into the representation. Changing from the pixel to an arbitrary frame is as simple as replacing the pixel basis $e _ { n }$ with a frame of choice with elements $v _ { n }$ as follows:
+
+$$
+W _ { i } = \sum _ { n = 1 } ^ { N } w _ { n } ^ { i } v _ { n }
+$$
+
+where $w _ { 1 } ^ { i } , . . . , w _ { n } ^ { i }$ are again the filter coefficients being learned.
+
+In practice for CNNs working on images we investigate derived bases from steerability requirements, orthogonal polynomials, Framelets and members of the Gaussian derivative family. See figure 2 for a selection of frames.
+
+![](images/7fe853bf5ccd983f773f17b6397559b1741d5d19c264fb985b2a4a5839b8e0eb.jpg)  
+Figure 2: An illustrative plot of multiple 3x3 spanning sets: a) Pixel-basis, b) Orthogonal Polynomial, c) Non-orthogonal Frame. Note the increased symmetries in b) and c).
+
+# 2.2 STEERING FRAMES UNDER ARBITRARY LIE-GROUPS
+
+A pleasant property of many frames is steerability (Unser & Chenouard, 2013; Hel-Or & Teo, 1998; Michaelis & Sommer, 1995), the power of a function to represent transformed versions of itself by linear combination. The advantage of steerability in CNNs working on images is the ability to produce infinitely many transformed variants of a visual feature $f ^ { \tau } ( \breve { x } , y ) \in \breve { \mathbb { R } ^ { 2 } } \to \mathbb { R }$ from its canonical appearance.
+
+To achieve this goal we cast these variations as the result of the action of a family of transformations $g ( \tau )$ on the canonical features $f ( x , y )$ , where $\tau \in R ^ { k }$ parametrizes these $k$ -parameter transformations. If the problem at hand requires the distinction between multiple unknown poses of the same feature in a typical CNN they all have to be computed exhaustively to determine if a particular pose is present or not. Things go out of hand when the search space is a continuous transformation group, such as the Lie group of affine transformations, requiring $k  \infty$ number of feature maps which is computationally intractable or requires expensive searches over all possible transformations (Gens & Domingos, 2014). One way out is to coarsely sample a few equally spaced points on the equivariant transformation manifold or to restrict the space to a smaller group (Cohen & Welling, 2016; Dieleman et al., 2016). What remains, however, is that the number of resulting feature maps for more general groups quickly becomes infeasible. An elegant way to overcome these limitations is the concept of steerability by (Freeman & Adelson, 1991; Perona, 1992; Unser & Chenouard, 2013) which is taken as inspiration here.
+
+In this work, we focus on Lie groups. Transformations $g ( \tau )$ over a range constitute a Lie group if they are closed under composition, they are associative, they are invertible, there exists an identity element, and their maps for inverse and composition are infinitely differentiable (Hel-Or & Teo, 1998). Teo and colleagues (Teo & Hel-Or, 1998) have given the following definition.
+
+Definition 1 (Steerability): $A$ function $f ( x , y )$ : $\mathbb { R } ^ { 2 } \to \mathbb { R }$ is steerable under a $k$ -parameter Lie transformation group $G$ if any transformation $g ( \tau ) \in G$ of f can be written as a linear combination of a fixed, finite set of frame functions $\phi _ { m } ( x , y )$ :
+
+$$
+g ( \tau ) f ( x , y ) = \sum _ { m = 1 } ^ { M } \beta _ { m } ( \tau ) \phi _ { m } ( x , y ) = \mathbf { B } ^ { T } ( \tau ) \Phi ( x , y )
+$$
+
+Where $\mathbf { B } ^ { T } ( \tau )$ denote the collected steering functions describing the transformation and $\Phi ( x , y )$ the collected steerable frame functions.
+
+A function steerable under a k-parameter Lie group is capable of representing infinitely many states of a particular set of transformations. In many cases, only a finite set of frame functions is needed to represent these. In CNN terms, this means that a limited number of feature maps are sufficient to represent complete continuous transformation groups when the frame functions and the steering functions are chosen appropriately. Finding appropriate frame functions is the biggest challenge in steering arbitrary functions over arbitrary Lie groups.
+
+To study the action of a Lie group $G$ on a function we use the close relation between the Lie group and its tangent space. The Algebra’s tangent space spanned by the group’s infinitesimal generators. The differential operators of the group action are obtained by computing the derivative of the group action with respect to its parameters at the identity element. A Lie Algebra can be considered as an ”infinitesimal” Lie group. If the group is simply connected, the group action on a visual feature $f ( x , y )$ can be obtained via the exponential map (Teo & Hel-Or, 1998):
+
+$$
+g ( \tau _ { 1 } , . . . , \tau _ { k } ) f ( x , y ) = e ^ { ( \sum _ { i = 1 } ^ { k } \tau _ { i } L _ { i } ) } f ( x , y )
+$$
+
+where
+
+$$
+e ^ { \tau _ { i } L _ { i } } = I + \tau _ { i } L _ { i } + \frac { 1 } { 2 ! } \tau _ { i } ^ { 2 } L _ { i } ^ { 2 } + . . .
+$$
+
+where $L _ { i }$ are the group’s infinitesimal generators and $I$ is the identity element. This implies that one can compute the Taylor expansion with respect to the desired transformation group parameters to obtain elements of the group. If a finite frame set is equivariant towards the desired transformation group (it contains the orbit of the function to be steered), the series expansion yields linearly dependent elements after a finite number of steps. Then the frame is globally steerable under the desired transformation group. If this is not the case, as for example when scaling a Gaussian function, a finite frame set is only sufficient to accurately steer the function over a bounded interval, the function is locally steerable, but not globally.
+
+# 2.3 SEPARATING POSE AND CANONICAL APPEARANCE
+
+When training a CNN the functions represented by each feature naturally change from update to update. It is desirable to separate the frame functions from the effective features as learned by the network. In such a Structured Receptive Fields Network (RFNN) (Jacobsen et al., 2016), each filters parameters are not its mere pixel values, but the coefficients weighting the sum over a fixed frame set. Thus, analogous to equation 1, every effective filter $W _ { i } ( x , y )$ has the following form:
+
+$$
+W _ { i } ( x , y ) = w _ { 1 } ^ { i } v _ { 1 } + w _ { 2 } ^ { i } v _ { 2 } + \ldots + w _ { n } ^ { i } v _ { n } ,
+$$
+
+where $v _ { n }$ denotes the $n _ { t h }$ element of the frame.
+
+To be able to separate a features pose from its canonical appearance, we are interested in a steerable version of an arbitrary filter $W _ { i } ( x , y )$ under a $\mathbf { k }$ -parameter Lie group. From 5 follows:
+
+$$
+g ( \tau ) W _ { i } ( x , y ) = \sum _ { n = 1 } ^ { N } w _ { n } ^ { i } g ( \tau ) v _ { n } ^ { i } .
+$$
+
+And by substituting according to equation 2 it follows:
+
+$$
+g ( \tau ) W _ { i } ( x , y ) = \sum _ { n = 1 } ^ { N } w _ { n } ^ { i } \sum _ { m = 1 } ^ { M } \beta _ { m } ( \tau ) \phi _ { m } ( x , y ) .
+$$
+
+Thus it is sufficient to determine the group action on the fixed frame by steering it to separate the canonical feature itself from its $\mathrm { k }$ -parameter variants, i.e. $v _ { n } ^ { i }$ govern the weight of each frame coefficient to form a feature $W _ { i } ( x , y )$ and $\beta _ { m }$ are the steering functions governing the transformation of $g ( \tau )$ acting on $W _ { i } ( x , y )$ as a whole. From now on learning and transforming features amounts to a point-wise multiplication of frame coefficients with cos, sin and exp activation functions, which is suitable for learning in a CNN.
+
+# 2.4 DERIVING THE FRAME AND STEERING FUNCTIONS
+
+Now the problem is reduced to finding a suitable frame as a function space underlying the learned filters. There are many approaches to derive a function space that is closed under the desired transformation group and as we show, many options give rise to bases that work considerably well when inserted into state-of-the-art CNNs. The most straightforward way is to derive it from the group’s infinitesimal generators, for brevity we refer the interested reader to (Hel-Or & Teo, 1998) and directly cite some derived equivariant function spaces from the paper.
+
+<table><tr><td colspan="2">Steerable Function Spaces</td></tr><tr><td>X,y Translation</td><td>xPyqeax+βy</td></tr><tr><td>X,y Scaling</td><td>xayβln(x)pln(y)q</td></tr><tr><td>Rotation &amp; Uniform Scaling</td><td>raln(r)peik</td></tr><tr><td>X,y Translation &amp; x,y Scaling&amp; Rotation</td><td>xpyq</td></tr></table>
+
+Table 1: Examples of function spaces closed under various non-Abelian multi-parameter groups, as derived in (Hel-Or & Teo, 1998). They can readily be used as a frame for CNNs by the procedure we derive here.
+
+Once a frame is chosen, we can simply check if it is closed under the given transformation group by verifying for each generator $L _ { i }$ that:
+
+$$
+{ \cal L } _ { i } \Phi ( x , y ) = { \bf B } _ { i } \Phi ( x , y ) ,
+$$
+
+where $\mathbf { B } _ { i }$ is some finite dimensional $n \times n$ matrix. If this is the case, the function space is equivariant under the transformation group and we can compute the steering equations of the group composed of multiple generators as:
+
+$$
+\mathbf { A } ( \tau ) = e ^ { \tau _ { k } \mathbf { B } _ { k } } \cdot \ldots \cdot e ^ { \tau _ { 1 } \mathbf { B } _ { 1 } } .
+$$
+
+To arrive at a practical solution, we have to consider the problem that locally bounded functions can not be steered globally with a finite steerable frame. To achieve a suitable approximation for our case, we separate scaling into two parts, an inner $\{ \sigma _ { x } , \sigma _ { y } \}$ and an outer scale $\sigma _ { a }$ , where a stands for aperture. The inner scale can directly be steered via the above derivation and represents the slope of the local measurement taken by a filter, while the outer scale represents the size and shape of the filters receptive field. To achieve anisotropic receptive fields, we propose to first steer the scale at every pixel and steer the derived function space on this non-uniformly scaled grid, resulting in locally deformable receptive fields. Due to associativity of convolution, we can combine steering the derived function space and the receptive field scale into one operation. In this work, we use a second order approximation of the Gaussian that is capable of giving a good approximation to common CNN receptive field sizes 3x3, 5x5 and $7 \mathbf { x } 7$ . For scaling over larger ranges, we recommend the spectral decomposition approach (Koutaki & Uchimura, 2014).
+
+# 2.5 DYNAMIC STEERABLE FRAME NETWORKS
+
+Estimating the local pose of a feature from a steerable function space is analytically intractable in the case of most multi-parameter groups. In this paper, we introduce the Dynamic Steerable Frame Network that combines the advantages of steerable function spaces with the power of neural network function estimators, by estimating pose parameters from a function space equivariant under the transformation group at hand. Specifically, our architecture is inspired by the recently introduced Dynamic Filter Networks (De Brabandere et al., 2016). The Dynamic Filter Network (DFN) generates one feature per location in a feature map, which boils down to a locally connected convolution layer, for which the parameters are generated by a different network that estimates them from the input, yielding a different filter kernel for every location in the input.
+
+![](images/8e9ca01d50e81f5ad21a8fc207c29b039e57abdf32a173fd09a8525ff1cb9e84.jpg)  
+Figure 3: The Dynamic Steerable Frame Network. The network transforms an input image to a steerable frame $\Phi$ (here an example with 3 frame functions) and estimates the local feature pose at each location in this equivariant space with a small pose estimating network. Then it outputs a set of pose coordinates $\tau _ { \mathbf { k } }$ , that are dependent on the group parametrization chosen. They are inserted into the matrix of steering equations $\beta ( \tau )$ and applied to the frame $\Phi$ , yielding the locally steered frame. In the same operation, we integrate the weights $w _ { n }$ , that govern the feature maps canonical feature appearance, these are the weights learned by a normal CNN. The Dynamic Steerable Frame Network can decide to commute with a set of poses, to be invariant to them, to only look for certain poses or to act like a normal CNN, where each feature map has one pose and one canonical appearance assigned to itself. This is only determined by the input data and the backpropagated error signals.
+
+The DFN takes the form:
+
+$$
+O ( x , y ) = F _ { \tau } ^ { x , y } ( I ( x , y ) ) ,
+$$
+
+where $F _ { \tau } ^ { x , y }$ are generated by another network from the input. We propose the Dynamic Steerable Frame Network, where the parameters $\theta$ that condition the filter are pose transformation parameters of the steerable function space, estimated from the input, similar to how it is done in the Spatial Transformer Networks, just that in our case we aim for locally adaptive filters. The filters $F _ { \tau } ^ { x , y }$ share the same set of weights in the whole feature map, so they represent the same canonical appearance everywhere. While their local pose is dynamically estimated by a Pose-Generating Network $\Psi$ that takes the form:
+
+$$
+\tau ( x , y ) = \Psi ( I ( x , y ) ) .
+$$
+
+Thus, the canonical appearance is translation invariant, but its geometrical pose is not. In terms of equation 5, this means the set of $w _ { n } ^ { i }$ is fixed, but the frame $v _ { n } ^ { \tau ( x , y ) }$ is locally transformed under a pre-defined k-parameter group with parameters $\tau$ . See figure 5 for an illustration.
+
+The method consists of two parts: i) A Pose-Generating network estimating local pose parameters of a feature conditioned on the input from a steerable input space. ii) A Dynamic Filtering mechanism, convolving transformed versions of a feature with every location in the input feature map, based on the estimates of the pose generating network. Due to linearity of convolution, we can first perform a transformation of the input into the steerable frame space and in this space we perform i) and ii) as point-wise multiplications.
+
+# 3 RELATED WORK
+
+Steerable Filters is a concept established early for signal processing. Initially introduced by (Freeman & Adelson, 1991), the concept was extended to the Steerable Pyramid by (Simoncelli & Freeman, 1995) and further extended to a Lie-group formulation by (Hel-Or & Teo, 1998; Michaelis & Sommer, 1995). Further, steerability has recently been extended to tight frames, presenting Simoncelli’s Steerable Pyramid and multiple other Wavelets arising as a special case of the non-orthogonal Riesz transform (Unser & Chenouard, 2013). Steerable pyramids have been applied to CNNs as a pre-processing step (Xue et al., 2016), but have not yet been learnable. We incorporate steerable frames in CNNs to increase their de facto expressiveness and to allow them to learn their configurations, rather than picking them a priori.
+
+Convolutional Networks with alternative bases have been proposed with various degrees of flexibility. A number of works utilizes change of basis to stabilize training and increase convergence behavior (Rippel et al., 2015; Arjovsky et al., 2015). Another line of research is concerned with complex-valued CNNs, either learned (Tygert et al., 2016), or fully designed like the Scattering networks (Bruna & Mallat, 2013; Oyallon & Mallat, 2015).
+
+Scattering, as well as the complex-valued networks, rest upon a direct connection between the signal processing literature and CNNs. Inspired by the former, Structured Receptive Field Networks are learned from an overcomplete multi-scale frame, effectively improving performance for small datasets due to restricted feature spaces (Jacobsen et al., 2016). Also related is the work on Groupequivariant CNNs (Cohen & Welling, 2016) and Cyclic Pooling (Dieleman et al., 2016), where equivariance towards the dihedral group is theoretically guaranteed, yielding increased accuracy. Inspired by CNNs learned from alternative bases, we introduce the general principle of Frame-based convolutional networks that allow for non-orthogonal, overcomplete and steerable feature spaces.
+
+Another way to impose structure onto CNN representations and subsequently increase their dataefficiency is to incorporate explicit geometrical transformations into them. Either by learning transformation operators and group representations (Cohen et al., 2014; Wang et al., 2009). Or by predefining the possible transformations, as done in Transforming Autoencoders (Hinton et al., 2011), which map their inputs from the image to pose space through a neural network. The Spatial Transformer Networks (Jaderberg et al., 2015) learn global transformation parameters in a similar way while applying them to a nonlinear co-registration of the feature stack to some learned pose. This yields especially high performance on tasks where centering the objects is beneficial. Dynamic Filter Networks move one step further and estimate filters for each location, conditioned on their input. These approaches are all dynamic in a sense that they condition their parameters on the input appearance. We combine the idea of Dynamic Filter Networks with explicit pose prediction into Dynamic Steerable Frame Networks that can estimate poses from continuous input space, conditioned on the input. As such, we overcome the difficulty of estimating local pose, while being able to separate pose and feature learning globally.
+
+# 4 EXPERIMENTS
+
+# 4.1 GENERALIZING PIXELS TO FRAMES ON CIFAR- $^ { 1 0 + }$
+
+To show the validity of general frame representations, we compare different bases in a state-of-theart pre-activation deep residual network architecture (He et al., 2016) on the Cifar- $^ { 1 0 + }$ (Krizhevsky & Hinton, 2009) dataset with moderate data augmentation of crops and flips.
+
+<table><tr><td colspan="4">Error on Cifar10+</td></tr><tr><td>Method</td><td>Pixel</td><td>Image Frame</td><td>Naive Frame</td></tr><tr><td>ResNet-20</td><td>7.85%</td><td>7.61%</td><td>8.97%</td></tr><tr><td>ResNet-56</td><td>6.68%</td><td>6.08%</td><td>7.30%</td></tr><tr><td>ResNet-110</td><td>5.84%</td><td>5.34%</td><td>6.96%</td></tr><tr><td>Densenet K12 L40</td><td>5.28%</td><td>4.99%</td><td>6.39%</td></tr><tr><td>Densenet K12 L100</td><td>4.16%</td><td>3.78%</td><td>5.21%</td></tr></table>
+
+Table 2: Results on Cifar10 with moderate data-augmentation (crops/flips) with the recently introduced pre-activation Residual network and Densenet with the standard pixel-basis, a steerable frame basis designed for natural images and the naive steerable $x ^ { p } y ^ { q }$ frame from table 3 that does not take natural image statistics into account. The natural image statistics based frame outperforms the pixelbasis consistently, while the naive frame consinstently performs about $1 \%$ worse than the baseline, highlighting the benefit of a frame suitable for the type of input data.
+
+We evaluated our approach on multiple networks and network sizes. The setup used for the ResNet is as described in (He et al., 2016). The batch size is chosen to be 64 and we train for 164 epochs with the described learning rate decrease. The ResNet architectures used are without bottlenecks having 20, 56 and 110 layers. For the Densenets we follow (Huang et al., 2016) and evaluate on the ${ \mathrm { K } } { = } 1 2$ and $_ { \mathrm { L = 4 0 } }$ , and the ${ \mathrm { K } } { = } 1 2$ and ${ \mathrm { L } } { = } 1 0 0$ models. We run our experiments in Keras (Chollet, 2015) and Tensorflow (Abadi et al., 2016). In the first experiment, we run the models on the standard pixel basis to get a viable baseline. Secondly, we replace the pixel-basis with widely-used frames that take natural image statistics into account, namely non-orthogonal, overcomplete Gaussian derivatives (Florack et al., 1992) and non-orthogonal framelets (Daubechies et al., 2003) in an alternating fashion, yielding superior performance compared to the pixel-basis by replacement only.
+
+We also show that the naive $x ^ { p } y ^ { q }$ frame (see table 1) performs consistently worse than the other two choices, as it does not take natural image properties into account, while it is important to mention that this $1 \%$ performance decrease also comes with additional properties that might be highly beneficial in particular tasks. We have also found orthogonal polynomials to not work very well (around $3 \%$ performance decrease), which is in line with our expectation that suitable frames should take natural image statistics into account. 2D frames are generated from 1D functions via the following generating process:
+
+$$
+F r a m e = \{ v _ { 0 } , v _ { 1 } , v _ { 2 } , v _ { 3 } \} \otimes \{ v _ { 0 } , v _ { 1 } , v _ { 2 } , v _ { 3 } \} ^ { T } .
+$$
+
+The results are reported in table 2. The fact that the pixel-basis can be replaced by steerable frames and performance even improves when the frame is chosen well, is remarkable, as this means every filter in the CNN enjoys additional properties, while performance improves in the standard setting already and finding suitable frames is not more expensive than running the same smallest CNN as many times as one has frames to choose from, as the performance we observed was consistent across multiple model sizes. Frame-based CNNs run at the same runtime as vanilla CNNs.
+
+# 4.2 DYNAMIC STEERABLE FRAME NETWORKS
+
+In this section we report two experiments. The first experiment is an edge detection task, highlighting the difference between our approach and multiple baselines in a fine-grained pixel-wise labeling task. In the second experiment, we apply a 2D convolutional LSTM on a small hand gesture recognition video dataset to illustrate how the Dynamic Steerable Frame Network regularizes the model effectively and to illustrate its benefits over Spatial Transform Networks.
+
+The model used in both experiments is learned from a steerable Gauss-Hermite frame. The Dynamic Steerable Frame Network consists of three processing steps. 1) Change to frame space on the input, 2) the Pose-Generating network estimates the pose from this transformed input, outputting a set of pose variables for each location in the image. 3) the steering functions derived in section 2.4 are applied to these pose variable maps and effectively act as nonlinear pose-parametrized activation functions that regularize the Pose-Generating network to output an explicitly interpretable pose space. Finally, a 1x1 convolution layer is applied to the already transformed output maps, representing the weights $w _ { n } ^ { i }$ , governing the canonical appearance of the $i _ { t h }$ feature map, see also figure 5. Dynamic Steerable Frame Networks run at the same computational cost as vanilla Dynamic Filter Networks.
+
+# 4.2.1 EDGE DETECTION
+
+In this experiment, we compare a Dynamic Filter Network (De Brabandere et al., 2016) baseline with an autoencoder and a Dynamic Steerable Frame Network on the task of edge detection. The problem is formulated as a pixel-wise classification task and reported is the root mean-squared error on an unseen test set. The labels are the edges. The dataset is infinite, as we produce random blobs and create the edge labels with a standard scikit image function. The standard DFN can freely learn an input layer with 2 filters and 3 subsequent 1x1 layers that can non-linearly recombine the inputs, whereas the Frame DFN receives a steerable frame as an input, allowing it to leverage the finegrained orientation information without the need to learn it. The Dynamic Steerable Frame Network has the exact same architecture as the DFN but is geometrically regularized on its output as can be seen in figure 5, as an input it receives a first order Gauss-Hermite frame that can be steered globally towards rotation and locally towards scale.
+
+Location varying methods are clearly superior in this task, compared to the location invariant autoencoder. The DFN increases its performance substantially when getting the steerable frame as an input, indicating its inability to learn a continuously transforming frame by itself. Finally, the Dynamic Steerable Frame Network clearly outperforms all baselines due to its ability to continuously transform its filters in a well-regularized manner. As an extra, we get the local feature pose for free from the output of the DSFN, the baseline has no notion of an explicit pose parameter, see figure 4.
+
+<table><tr><td>Method</td><td>RMSE</td></tr><tr><td>Autoencoder</td><td>18.034</td></tr><tr><td>DFN</td><td>5.669</td></tr><tr><td>Frame DFN DSFN</td><td>1.554 0.778</td></tr></table>
+
+![](images/ca567f4a07cbb3397f5d4e2eb6bc964b829aa9540d512d619b4fe1c0dec6590b.jpg)  
+Figure 4: Results on the edge detection task. Top is an illustration of a test image, bottom one sample from the actual infinite dataset, reported is root mean squared error. Autoencoder denotes a vanilla location invariant autoencoder. DFN denotes the plain Dynamic Filter Network, Frame DFN denotes a DFN whos input is a frame, DSFN denotes the Dynamic Steerable Frame Network. a) is the input, b) is the label, c) the prediction and d) the angular pose variable. d) is an output we get for free when training DSFNs, while a DFN has no notion of interpretable angle variables. Location varying methods clearly outperform the static autoencoder, while learning the DFN from a steerable frame increases performance again substantially. The DSFN substantially outperforms all other methods due to its continuously transforming input and output space.
+
+# 4.2.2 SMALL SCALE VIDEO CLASSIFICATION
+
+To show the ability of the Dynamic Steerable Frame Network to effectively regularize in dynamic settings where poses play an important role and where Spatial Transformer Networks do not work well, we apply it on the task of Hand-Gesture Recognition. Namely, on the Cambridge Hand-Gesture dataset (Kim & Cipolla, 2009), consisting of 9 classes of hand movement and poses in 900 videos, we use 750 for training, 50 for validation and 100 for testing. The dataset is very small and contains classes where global movement plays an important role and thus provides a good test bed to show effectiveness of the DSFN regularization ability compared to Spatial Transformers.
+
+<table><tr><td>convLSTM</td><td>1 Layer</td><td>2 Layer</td><td>rot/scale-DSFN</td><td>rot/scale-STN</td><td>affine-STN</td></tr><tr><td># Params</td><td>905k</td><td>913k</td><td>907k</td><td>971k</td><td>1037k</td></tr><tr><td> Accuracy</td><td>35.42%</td><td>39.31%</td><td>62.18%</td><td>21.34%</td><td>12.21 %</td></tr></table>
+
+Table 3: Results on the Cambridge Hand-Gesture Recognition dataset, to illustrate the effectiveness of pose regularization provided by the Dynamic Steerable Frame Network. Adding the DSFN module to the convLSTM drastically improves performance. Increasing the capacity of the baseline to two layers, does not make up for the difference in performance, while adding the STN to the convLSTM decreases performance significantly, as the STN does not manage to learn meaningful global transformations that do not remove the class-specific information content. This is further substantiated by an increased performance when removing the ability to shear and translate the input from the STN. The DSFN outperforms all other approaches while only adding 2k free parameters to the baseline.
+
+Our baseline model is a convolutional LSTM with 10 output feature maps, batch normalization and a dense layer for classification. As a second baseline, we increase the capacity of the model by adding a second LSTM layer and a second batch normalization step. We combine two instances of a Spatial Transformer Network with a convolutional LSTM, one that can perform full affine transformations and one that is restricted to rotation and scaling. The DSFN module is applied to the input layer of the smaller model with 4 output feature maps. The setup of the steerable frame used in this model is a Gauss-Hermite frame.
+
+The steerability is uniquely parametrized as: $\{ B _ { s } B _ { \theta } \}$ . Allowing for scaling and rotation. Both Spatial Transformer Networks do not manage to learn useful warps of the input image and therefore decrease performance of the baseline. The affine model only manages to correctly classify multiple instances of a static class that has no movement information related to its label, while the rot/scale model increases performance, but still does not manage to learn useful scalings or rotations. The DSFN manages to learn locally rotation and scale invariant filters, that follow the boundaries and other features across the video as desired. Results are reported in Table 3.
+
+For visualizations of the learned transformations, see Appendix A. The results illustrate the effectiveness of the DSFN to regularize the LSTM on a small-scale task where mostly local invariance is desired, but global invariance destroys most of the class-specific information. The DSFN improves performance over the baseline by about $22 \%$ , while the Spatial Transformer Network decreases performance by about $15 \%$ , or even to random in the full-affine case.
+
+# 5 DISCUSSION
+
+We have introduced the notion of Frame-based convolutional networks. Our experiments illustrate that a simple replacement of the standard basis by a frame suitable for natural images leads to increased performance.
+
+The insight that multiple frames can be considered as viable spanning sets for CNN representations leads us to steerable frames whose properties we exploit explicitly in our derived Dynamic Steerable Frame Networks, such that they can readily be accessed during training. The proposed method is a hybrid of Dynamic Filter Networks and Spatial Transformer Networks, enabling locally adaptive filtering with geometrical constraints.
+
+We illustrate the effectiveness of the approach on an edge detection task, that requires fine-grained pixel-wise labeling, where Dynamic Steerable Frame Networks outperform a standard Dynamic Filter Network and an autoencoder baseline. Further, we illustrate the ability of the Dynamic Steerable Frame Network to regularize recurrent networks in a small-data video classification scenario where Spatial Transformer Networks fail to learn meaningful transformations.
+
+Future work is to apply the model to other problem domains like egocentric video, robotics applications, as well as volumetric medical imaging videos of moving organs. We expect our Dynamic Steerable Frame Network approach to be beneficial in any problem where spatiotemporal continuity, data-efficiency, or interpretable pose spaces are key.
+
+# ACKNOWLEDGEMENTS
+
+We would like to thank Edouard Oyallon and Taco Cohen for insightful comments and discussions.
+
+# 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.   
+Martin Arjovsky, Amar Shah, and Yoshua Bengio. Unitary evolution recurrent neural networks. arXiv preprint arXiv:1511.06464, 2015.   
+Joan Bruna and Stephane Mallat. Invariant scattering convolution networks. ´ IEEE transactions on pattern analysis and machine intelligence, 35(8):1872–1886, 2013.   
+Franc¸ois Chollet. Keras. https://github.com/fchollet/keras, 2015.   
+Ole Christensen. An introduction to frames and Riesz bases, volume 7. Springer, 2003.   
+Taco Cohen, Max Welling, et al. Learning the irreducible representations of commutative lie groups. In ICML, pp. 1755–1763, 2014.   
+Taco S Cohen and Max Welling. Group equivariant convolutional networks. arXiv preprint arXiv:1602.07576, 2016.   
+Ingrid Daubechies, Bin Han, Amos Ron, and Zuowei Shen. Framelets: Mra-based constructions of wavelet frames. Applied and computational harmonic analysis, 14(1):1–46, 2003.   
+Bert De Brabandere, Xu Jia, Tinne Tuytelaars, and Luc Van Gool. Dynamic filter networks. arXiv preprint arXiv:1605.09673, 2016.
+
+Sander Dieleman, Jeffrey De Fauw, and Koray Kavukcuoglu. Exploiting cyclic symmetry in convolutional neural networks. arXiv preprint arXiv:1602.02660, 2016.
+
+Luc MJ Florack, Bart M ter Haar Romeny, Jan J Koenderink, and Max A Viergever. Scale and the differential structure of images. Image and Vision Computing, 10(6):376–388, 1992.
+
+William T Freeman and Edward H Adelson. The design and use of steerable filters. IEEE Transactions on Pattern analysis and machine intelligence, 13(9):891–906, 1991.
+
+Robert Gens and Pedro M Domingos. Deep symmetry networks. In Advances in neural information processing systems, pp. 2537–2545, 2014.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Identity mappings in deep residual networks. arXiv preprint arXiv:1603.05027, 2016.
+
+Yacov Hel-Or and Patrick C Teo. Canonical decomposition of steerable functions. Journal of Mathematical Imaging and Vision, 9(1):83–95, 1998.
+
+Geoffrey E Hinton, Alex Krizhevsky, and Sida D Wang. Transforming auto-encoders. In International Conference on Artificial Neural Networks, pp. 44–51. Springer, 2011.
+
+Gao Huang, Zhuang Liu, and Kilian Q Weinberger. Densely connected convolutional networks. arXiv preprint arXiv:1608.06993, 2016.
+
+Jorn-Henrik Jacobsen, Jan van Gemert, Zhongyu Lou, and Arnold W.M. Smeulders. Structured ¨ receptive fields in cnns. 2016.
+
+Max Jaderberg, Karen Simonyan, Andrew Zisserman, et al. Spatial transformer networks. In Advances in Neural Information Processing Systems, pp. 2017–2025, 2015.
+
+Tae-Kyun Kim and Roberto Cipolla. Canonical correlation analysis of video volume tensors for action categorization and detection. IEEE Transactions on Pattern Analysis and Machine Intelligence, 31(8):1415–1428, 2009.
+
+Gou Koutaki and Keiichi Uchimura. Scale-space processing using polynomial representations. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2744– 2751, 2014.
+
+Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009.
+
+Markus Michaelis and Gerald Sommer. A lie group approach to steerable filters. Pattern Recognition Letters, 16(11):1165–1174, 1995.
+
+Edouard Oyallon and Stephane Mallat. Deep roto-translation scattering for object classification. ´ In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2865– 2873, 2015.
+
+Pietro Perona. Steerable-scalable kernels for edge detection and junction analysis. In ECCV, pp. 3–18. Springer, 1992.
+
+Oren Rippel, Jasper Snoek, and Ryan P Adams. Spectral representations for convolutional neural networks. In Advances in Neural Information Processing Systems, pp. 2449–2457, 2015.
+
+Eero P Simoncelli and William T Freeman. The steerable pyramid: a flexible architecture for multiscale derivative computation. In ICIP (3), pp. 444–447, 1995.
+
+Patrick C Teo and Yacov Hel-Or. Lie generators for computing steerable functions. Pattern Recognition Letters, 19(1):7–17, 1998.
+
+Mark Tygert, Joan Bruna, Soumith Chintala, Yann LeCun, Serkan Piantino, and Arthur Szlam. A mathematical motivation for complex-valued convolutional networks. Neural computation, 2016.
+
+Michael Unser and Nicolas Chenouard. A unifying parametric framework for 2d steerable wavelet transforms. SIAM Journal on Imaging Sciences, 6(1):102–135, 2013.
+
+Jimmy Wang, Jascha Sohl-Dickstein, and Bruno Olshausen. Unsupervised learning of lie group operators from image sequences. In Frontiers in Systems Neuroscience. Conference Abstract: Computational and systems neuroscience, 2009.
+
+Tianfan Xue, Jiajun Wu, Katherine L Bouman, and William T Freeman. Visual dynamics: Probabilistic future frame synthesis via cross convolutional networks. arXiv preprint arXiv:1607.02586, 2016.
+
+# APPENDIX A VISUALIZING DSFN AND STN TRANSFORMATIONS
+
+![](images/ba16a429ace081cd119c5f0c94f8051e776c1f7bcd05a93e2649f06f2e02d355.jpg)  
+Figure 5: Visualizations of the learned transformations by the Dynamic Steerable Frame Network (DSFN top) and the Spatial Transformer Network (STN bottom) on the hand-gesture recognition dataset. The STN zooms and rotates the hands arbitrarily and apparently removes important information content thereby, leading to low classification accuracy. The DSFN acts locally and adaptively filters the hands in multiple ways. Note that the DSFN did not learn fully rotation invariant filters in all 4 cases, but in 3 cases produces different filter responses for different sides of the hand. However, it does follow the contours of the hand and segments the borders from the background. This indicates that full rotation invariance is not suitable for this task. This would be hard to assess if one had to choose the degree of invariance a priori, while the DSFN has the means to learn the necessary amount of local invariance.
+
+# APPENDIX B EQUIVARIANCE PROOF & STEERING EQUATION DERIVATION
+
+To prove that a frame is equivariant with respect to the action of a group transformation, determined by its generator $L _ { i }$ , we simply have to show that:
+
+$$
+{ \cal L } _ { i } \Phi ( x , y ) = { \bf B } _ { i } \Phi ( x , y ) ,
+$$
+
+Where $\mathbf { B } _ { i }$ is some $n \times n$ matrix.
+
+In case of the Hermite polynomials (here considered up to second order), we have:
+
+$$
+\Phi ( x , y ) = \{ 1 , x , y , x ^ { 2 } - 1 , x y , y ^ { 2 } - 1 \} .
+$$
+
+To verify that these functions span an equivariant function space with respect to rotation, we apply the generator of rotations to the frame and verify that equation 13 holds. The generator of rotations
+
+in the plane is given by $\begin{array} { r } { L _ { r } = - x \frac { d } { d y } + y \frac { d } { d x } } \end{array}$ , applied to each frame element, we get:
+
+$$
+L _ { r } \Phi ( x , y ) = \left[ \begin{array} { c } { 0 } \\ { y } \\ { - x } \\ { 2 x y } \\ { - x ^ { 2 } + y ^ { 2 } } \\ { - 2 x y } \end{array} \right] = \mathbf { B } _ { r } \left[ \begin{array} { c } { 1 } \\ { x } \\ { y } \\ { x ^ { 2 } - 1 } \\ { x y } \\ { y ^ { 2 } - 1 } \end{array} \right] .
+$$
+
+It is straightforward to solve this linear system and obtain the $6 \times 6$ matrix $B _ { r }$ :
+
+$$
+\mathbf { B } _ { r } = \left[ \begin{array} { c c c c c c c } { 0 } & { 0 } & { 0 } & { 0 } & { 0 } & { 0 } \\ { 0 } & { 0 } & { 1 } & { 0 } & { 0 } & { 0 } \\ { 0 } & { - 1 } & { 0 } & { 0 } & { 0 } & { 0 } \\ { 0 } & { 0 } & { 0 } & { 0 } & { 2 } & { 0 } \\ { 0 } & { 0 } & { 0 } & { - 1 } & { 0 } & { 1 } \\ { 0 } & { 0 } & { 0 } & { 0 } & { - 2 } & { 0 } \end{array} \right] . \quad \left[ \begin{array} { c c c c c c } \end{array} \right.
+$$
+
+Thus, we have proven that the function space is closed under the action of the group and the Hermite polynomials constitute an equivariant function space with respect to rotation.
+
+Subsequently, the exponential map directly yields the steering equations collected in the interpolation matrix $\dot { \mathbf { A } } ^ { \theta }$ , that can rotate the whole frame by $\theta$ :
+
+$$
+\begin{array} { l l } { { \Phi ^ { \theta } ( x , y ) = e ^ { \theta \mathbf { B } _ { r } } \Phi ( x , y ) = \mathbf { A } ^ { \theta } \Phi ( x , y ) , } } & { { } } \\ { { \ } } & { { } } \\ { { \Phi ^ { \theta } ( x , y ) = \left[ \begin{array} { c c c c c c } { { 1 } } & { { 0 } } & { { 0 } } & { { 0 } } & { { 0 } } \\ { { 0 } } & { { \cos \theta } } & { { \sin \theta } } & { { 0 } } & { { 0 } } & { { 0 } } \\ { { 0 } } & { { - \sin \theta } } & { { \cos \theta } } & { { 0 } } & { { 0 } } & { { 0 } } \\ { { 0 } } & { { 0 } } & { { 0 } } & { { { \frac { 1 } { 2 } } + { \frac { 1 } { 2 } } \cos 2 \theta } } & { { \sin 2 \theta } } & { { { \frac { 1 } { 2 } } - { \frac { 1 } { 2 } } \cos 2 \theta } } \\ { { 0 } } & { { 0 } } & { { 0 } } & { { - { \frac { 1 } { 2 } } \sin 2 \theta } } & { { \cos 2 \theta } } & { { { \frac { 1 } { 2 } } \sin 2 \theta } } \\ { { 0 } } & { { 0 } } & { { 0 } } & { { { \frac { 1 } { 2 } } - { \frac { 1 } { 2 } } \cos 2 \theta } } & { { - \sin 2 \theta } } & { { { \frac { 1 } { 2 } } + { \frac { 1 } { 2 } } \cos 2 \theta } } \end{array} \right] \left[ \begin{array} { c } { { 1 } } \\ { { x } } \\ { { y } } \\ { { x ^ { 2 } - 1 } } \\ { { x y } } \\ { { y ^ { 2 } - 1 } } \end{array} \right] . } } \end{array}
+$$
+
+$\Phi ^ { \theta } ( x , y )$ is the frame rotated by some angle $\theta$ . Combining this result with equation 7, gives us the possibility to rotate any learned feature by arbitrary and continuous angles $\theta$ . The whole procedure is completely analogous for any other Lie group transformation. Further, k-parameter transformation groups can be composed according to equation 9 from smaller groups. Here an example of the general linear group of rotation, anisotropic scalings and skew:
+
+$$
+\Phi ^ { \{ \theta _ { 1 } , s _ { x } , s _ { y } , \theta _ { 2 } \} } ( x , y ) = { \bf A } ^ { \{ \theta _ { 1 } , s _ { x } , s _ { y } , \theta _ { 2 } \} } \Phi ( x , y ) = e ^ { \theta _ { 2 } \mathbf { B } _ { r } } \cdot e ^ { s _ { x } \mathbf { B } _ { s x } } \cdot e ^ { s _ { y } \mathbf { B } _ { s y } } \cdot e ^ { \theta _ { 1 } \mathbf { B } _ { r } } \Phi ( x , y ) .
+$$
+
+# APPENDIX C BACKPROPAGATION THROUGH STEERABLE FILTERS
+
+Will be added to final manuscript.

parse/train/H178hw9ex/H178hw9ex_content_list.json

@@ -0,0 +1,1697 @@
+[
+    {
+        "type": "text",
+        "text": "DYNAMIC STEERABLE FRAME NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            686,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Jorn-Henrik Jacobsen ¨ 1, Bert De Brabandere2, Arnold W.M. Smeulders1 ",
+        "bbox": [
+            186,
+            143,
+            684,
+            160
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1Department of Computer Science, University of Amsterdam 2ESAT-PSI, KU Leuven {j.jacobsen,a.w.m.smeulders}@uva.nl bert.debrabandere@esat.kuleuven.be ",
+        "bbox": [
+            183,
+            172,
+            583,
+            229
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            267,
+            544,
+            282
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Filters in a convolutional network are typically parametrized in a pixel basis. As an orthonormal basis, pixels may represent any arbitrary vector in $\\mathbb { R } ^ { n }$ . In this paper, we relax this orthonormality requirement and extend the set of viable bases to the generalized notion of frames. When applying suitable frame bases to ResNets on Cifar- $^ { 1 0 + }$ we demonstrate improved error rates by substitution only. By exploiting the transformation properties of such generalized bases, we arrive at steerable frames, that allow to continuously transform CNN filters under arbitrary Lie-groups. Further allowing us to locally separate pose from canonical appearance. We implement this in the Dynamic Steerable Frame Network, that dynamically estimates the transformations of filters, conditioned on its input. The derived method presents a hybrid of Dynamic Filter Networks and Spatial Transformer Networks that can be implemented in any convolutional architecture, as we illustrate in two examples. First, we illustrate estimation properties of steerable frames with a Dynamic Steerable Frame Network, compared to a Dynamic Filter Network on the task of edge detection, where we show clear advantages of the derived steerable frames. Lastly, we insert the Dynamic Steerable Frame Network as a module in a convolutional LSTM on the task of limited-data hand-gesture recognition from video and illustrate effective dynamic regularization and show clear advantages over Spatial Transformer Networks. In this paper, we have laid out the foundations of Frame-based convolutional networks and Dynamic Steerable Frame Networks while illustrating their advantages for continuously transforming features and data-efficient learning. ",
+        "bbox": [
+            233,
+            297,
+            764,
+            603
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            628,
+            336,
+            643
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "For images, as well as any other sensory data, convolutional networks are typically learned from individual pixel values. Using them as a basis of the learned parameters is the standard approach for almost all CNNs. In this paper, we argue, that the pixel basis is not necessarily the best choice for representing signals. We show, that suitable alternatives yield increased classification performance by replacement only, while such a replacement adds additional properties to the learned filters that allow us to transform them under arbitrary pre-defined Lie groups. ",
+        "bbox": [
+            174,
+            659,
+            823,
+            742
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "From our perspective, the pixel values span an orthogonal basis for the filters in the network (in every layer). Such a pixel basis is complete as it may represent an arbitrary vector in $\\mathbb { R } ^ { n }$ by linear combination, where $n$ is the dimensionality of the filter. In this paper we consider alternatives to this basis, both orthogonal bases, and non-orthogonal frames, arriving at superior expressiveness through steerable function spaces that allow us to transform filters locally and continuously, conditioned on their input. ",
+        "bbox": [
+            174,
+            750,
+            823,
+            833
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Utilizing the steerability properties of frames in practice, we propose Dynamic Steerable Frame Networks (DSFNs) that fill the gap between Spatial Transformer Networks (STNs) (Jaderberg et al., 2015) and Dynamic Filter Networks (DFNs) (De Brabandere et al., 2016). STNs are not locally adaptive, thus they fail in many cases where it is not beneficial to transform the image globally as it would destroy discriminative information (multiple deformable objects, discriminative dynamic movements) or where global registration is performed as a preprocessing step (medical images). ",
+        "bbox": [
+            174,
+            840,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "DFNs are overcoming this restriction by locally transforming filters instead of globally transforming the whole feature stack as STNs do. However, DFNs are black boxes and not data-efficient, as they introduce many unconstrained parameters. Such a behavior is undesirable when data is limited and interpretability is key. DSFNs are locally adaptive, interpretable and data-efficient. They overcome the weaknesses of both approaches by combining their strengths, as illustrated in multiple experiments. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our contributions: ",
+        "bbox": [
+            174,
+            194,
+            294,
+            208
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We argue that suitable frame bases are beneficial when representing sensory data compared to the commonly used pixel basis. • Exploiting the transformation properties of frames further, we derive Dynamic Steerable Frame Networks that are able to continuously transform features locally and fill the gap between Spatial Transformer Networks and Dynamic Filter Networks. Dynamic Steerable Frame Networks learn to separate pose and feature. This enables the network to be locally equivariant or invariant with respect to certain feature poses, or even to perform in network quasi data-augmentation, while only the inputs and the backpropagated error signals determine which and to what extent these are applied. ",
+        "bbox": [
+            215,
+            220,
+            825,
+            357
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We introduce the generalized notion of frames to CNNs that extend possible bases to learn from to non-orthogonal and overcomplete sets without loss in generalization. We show that many choices are possible, while overcomplete, non-orthogonal bases consistently outperform the pixel basis when applied to a ResNet (He et al., 2016) for image classification, as illustrated on Cifar- $^ { 1 0 + }$ . We derive the Dynamic Steerable Frame Networks, based on the notion of steerable frames, that can locally adapt the filters in every feature map, conditioned on the input. We illustrate the strength of the approach in an edge detection task, where it outperforms a Dynamic Filter Network. We further show in a limited data video classification task, that Dynamic Steerable Frame Networks improve classification performance over Spatial Transformer Networks when global invariance is not desirable. ",
+        "bbox": [
+            174,
+            369,
+            825,
+            507
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 DYNAMICALLY STEERABLE FRAME NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            529,
+            606,
+            545
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 FRAMES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            560,
+            274,
+            575
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Frames are a natural generalization of orthogonal bases (Christensen, 2003). In frame terminology, an orthonormal basis is a Parseval-tight frame with unit norm. Every tight frame preserves the signal norm and exhibits perfect reconstruction. Frames can be seen as a superset of orthogonal bases in the sense that every basis is a frame, but not the reverse, see figure 1. The advantage of considering frames over orthogonal bases is that intrinsic signal properties can be spelled out explicitly in the new representation with the advantage, that these properties are directly accessible during learning. From an overcomplete representation, it will be more easily visible which part of the features is robust and which part is sensitive to accidental noise variations. ",
+        "bbox": [
+            173,
+            587,
+            825,
+            698
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/1209de074ff886412bb683f2c37e8c226b0b26766557f80a76c0ef5bd4c685d8.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            352,
+            710,
+            648,
+            821
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Figure 1: a) Is an orthonormal basis in $\\mathbb { R } ^ { 2 }$ , $u _ { 1 }$ and $u _ { 2 }$ are linearly independent and span the space of $\\mathbb { R } ^ { \\tilde { 2 } }$ . A dot in this example represents a filter in a convolutional network with coefficients $\\{ \\bar { v } _ { 1 } , v _ { 2 } \\}$ . b) A tight frame in $\\mathbb { R } ^ { 2 }$ . $u _ { 1 } , u _ { 2 }$ and $u _ { 3 }$ are linearly dependent. A dot in this example represents a convolutional filter with coefficients $\\{ v _ { 1 } , v _ { 2 } , v _ { 3 } \\}$ . The frame is an overcomplete representation, again spanning $\\mathbb { R } ^ { 2 }$ and again preserving the norm. Note that the set of filter coefficients as represented by the dot is not unique. Thus even if one $v$ is obstructed by noisy updates or measurements, the filter may still be robust. ",
+        "bbox": [
+            173,
+            843,
+            825,
+            940
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In a standard convolutional network, a filter kernel is a linear combination over the standard basis for $l ^ { 2 } ( \\mathbb { N } )$ . The standard basis is composed from a delta function for every dimension and $W _ { i }$ is the $i _ { t h }$ filter of the network with parameters $w _ { n } ^ { i }$ : ",
+        "bbox": [
+            173,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8441fd7c3be5e9bbc9381d851513ee4c55cc69dacee6b7593e19b3735133f160.jpg",
+        "text": "$$\n\\begin{array} { l } { { \\displaystyle e _ { 1 } = \\{ 1 , 0 , 0 , . . . , 0 \\} } } \\\\ { { \\displaystyle e _ { 2 } = \\{ 0 , 1 , 0 , . . . , 0 \\} } } \\\\ { { \\displaystyle . . . } } \\\\ { { \\displaystyle e _ { n } = \\{ 0 , 0 , 0 , . . . , 1 \\} } } \\\\ { { \\displaystyle W _ { i } = \\sum _ { n = 1 } ^ { N } w _ { n } ^ { i } e _ { n } } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            429,
+            150,
+            570,
+            265
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Without loss of generalization the orthonormal standard basis can be replaced by a frame to include non-orthogonality, overcompleteness, increased symmetries or steerability into the representation. Changing from the pixel to an arbitrary frame is as simple as replacing the pixel basis $e _ { n }$ with a frame of choice with elements $v _ { n }$ as follows: ",
+        "bbox": [
+            173,
+            267,
+            825,
+            323
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/228a26df3bc175d9a9b3b388c9be343303e3a2191af3ed63d8c3b14753a2d4ab.jpg",
+        "text": "$$\nW _ { i } = \\sum _ { n = 1 } ^ { N } w _ { n } ^ { i } v _ { n }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            442,
+            325,
+            555,
+            369
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $w _ { 1 } ^ { i } , . . . , w _ { n } ^ { i }$ are again the filter coefficients being learned. ",
+        "bbox": [
+            173,
+            372,
+            584,
+            388
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In practice for CNNs working on images we investigate derived bases from steerability requirements, orthogonal polynomials, Framelets and members of the Gaussian derivative family. See figure 2 for a selection of frames. ",
+        "bbox": [
+            176,
+            395,
+            823,
+            435
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/7fe853bf5ccd983f773f17b6397559b1741d5d19c264fb985b2a4a5839b8e0eb.jpg",
+        "image_caption": [
+            "Figure 2: An illustrative plot of multiple 3x3 spanning sets: a) Pixel-basis, b) Orthogonal Polynomial, c) Non-orthogonal Frame. Note the increased symmetries in b) and c). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            352,
+            439,
+            643,
+            523
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 STEERING FRAMES UNDER ARBITRARY LIE-GROUPS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            577,
+            578,
+            592
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A pleasant property of many frames is steerability (Unser & Chenouard, 2013; Hel-Or & Teo, 1998; Michaelis & Sommer, 1995), the power of a function to represent transformed versions of itself by linear combination. The advantage of steerability in CNNs working on images is the ability to produce infinitely many transformed variants of a visual feature $f ^ { \\tau } ( \\breve { x } , y ) \\in \\breve { \\mathbb { R } ^ { 2 } } \\to \\mathbb { R }$ from its canonical appearance. ",
+        "bbox": [
+            174,
+            603,
+            825,
+            674
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To achieve this goal we cast these variations as the result of the action of a family of transformations $g ( \\tau )$ on the canonical features $f ( x , y )$ , where $\\tau \\in R ^ { k }$ parametrizes these $k$ -parameter transformations. If the problem at hand requires the distinction between multiple unknown poses of the same feature in a typical CNN they all have to be computed exhaustively to determine if a particular pose is present or not. Things go out of hand when the search space is a continuous transformation group, such as the Lie group of affine transformations, requiring $k  \\infty$ number of feature maps which is computationally intractable or requires expensive searches over all possible transformations (Gens & Domingos, 2014). One way out is to coarsely sample a few equally spaced points on the equivariant transformation manifold or to restrict the space to a smaller group (Cohen & Welling, 2016; Dieleman et al., 2016). What remains, however, is that the number of resulting feature maps for more general groups quickly becomes infeasible. An elegant way to overcome these limitations is the concept of steerability by (Freeman & Adelson, 1991; Perona, 1992; Unser & Chenouard, 2013) which is taken as inspiration here. ",
+        "bbox": [
+            174,
+            680,
+            825,
+            861
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this work, we focus on Lie groups. Transformations $g ( \\tau )$ over a range constitute a Lie group if they are closed under composition, they are associative, they are invertible, there exists an identity element, and their maps for inverse and composition are infinitely differentiable (Hel-Or & Teo, 1998). Teo and colleagues (Teo & Hel-Or, 1998) have given the following definition. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Definition 1 (Steerability): $A$ function $f ( x , y )$ : $\\mathbb { R } ^ { 2 } \\to \\mathbb { R }$ is steerable under a $k$ -parameter Lie transformation group $G$ if any transformation $g ( \\tau ) \\in G$ of f can be written as a linear combination of a fixed, finite set of frame functions $\\phi _ { m } ( x , y )$ : ",
+        "bbox": [
+            173,
+            102,
+            825,
+            147
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8743887e9f779f7b091dc88bf8ad807f7770344cc387f5d808755bf87455af8d.jpg",
+        "text": "$$\ng ( \\tau ) f ( x , y ) = \\sum _ { m = 1 } ^ { M } \\beta _ { m } ( \\tau ) \\phi _ { m } ( x , y ) = \\mathbf { B } ^ { T } ( \\tau ) \\Phi ( x , y )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            321,
+            154,
+            676,
+            196
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Where $\\mathbf { B } ^ { T } ( \\tau )$ denote the collected steering functions describing the transformation and $\\Phi ( x , y )$ the collected steerable frame functions. ",
+        "bbox": [
+            173,
+            205,
+            823,
+            234
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "A function steerable under a k-parameter Lie group is capable of representing infinitely many states of a particular set of transformations. In many cases, only a finite set of frame functions is needed to represent these. In CNN terms, this means that a limited number of feature maps are sufficient to represent complete continuous transformation groups when the frame functions and the steering functions are chosen appropriately. Finding appropriate frame functions is the biggest challenge in steering arbitrary functions over arbitrary Lie groups. ",
+        "bbox": [
+            173,
+            241,
+            825,
+            325
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To study the action of a Lie group $G$ on a function we use the close relation between the Lie group and its tangent space. The Algebra’s tangent space spanned by the group’s infinitesimal generators. The differential operators of the group action are obtained by computing the derivative of the group action with respect to its parameters at the identity element. A Lie Algebra can be considered as an ”infinitesimal” Lie group. If the group is simply connected, the group action on a visual feature $f ( x , y )$ can be obtained via the exponential map (Teo & Hel-Or, 1998): ",
+        "bbox": [
+            173,
+            330,
+            825,
+            416
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0ac891cee9ed4e653feefd71b04f801689d7a04752806b4b5d5bd63a4ec12ac7.jpg",
+        "text": "$$\ng ( \\tau _ { 1 } , . . . , \\tau _ { k } ) f ( x , y ) = e ^ { ( \\sum _ { i = 1 } ^ { k } \\tau _ { i } L _ { i } ) } f ( x , y )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            359,
+            422,
+            638,
+            444
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where ",
+        "bbox": [
+            174,
+            452,
+            217,
+            465
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/faef8b868c70aa1482baacf72220eeb14c9959ca8089f8fec76a99a35b000c46.jpg",
+        "text": "$$\ne ^ { \\tau _ { i } L _ { i } } = I + \\tau _ { i } L _ { i } + \\frac { 1 } { 2 ! } \\tau _ { i } ^ { 2 } L _ { i } ^ { 2 } + . . .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            388,
+            462,
+            609,
+            492
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $L _ { i }$ are the group’s infinitesimal generators and $I$ is the identity element. This implies that one can compute the Taylor expansion with respect to the desired transformation group parameters to obtain elements of the group. If a finite frame set is equivariant towards the desired transformation group (it contains the orbit of the function to be steered), the series expansion yields linearly dependent elements after a finite number of steps. Then the frame is globally steerable under the desired transformation group. If this is not the case, as for example when scaling a Gaussian function, a finite frame set is only sufficient to accurately steer the function over a bounded interval, the function is locally steerable, but not globally. ",
+        "bbox": [
+            173,
+            494,
+            825,
+            608
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.3 SEPARATING POSE AND CANONICAL APPEARANCE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            626,
+            563,
+            640
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "When training a CNN the functions represented by each feature naturally change from update to update. It is desirable to separate the frame functions from the effective features as learned by the network. In such a Structured Receptive Fields Network (RFNN) (Jacobsen et al., 2016), each filters parameters are not its mere pixel values, but the coefficients weighting the sum over a fixed frame set. Thus, analogous to equation 1, every effective filter $W _ { i } ( x , y )$ has the following form: ",
+        "bbox": [
+            173,
+            650,
+            825,
+            722
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5236c9dc9a1efc6a663e9278dc95a4a93e004771f58fb767fed1596b969c78d9.jpg",
+        "text": "$$\nW _ { i } ( x , y ) = w _ { 1 } ^ { i } v _ { 1 } + w _ { 2 } ^ { i } v _ { 2 } + \\ldots + w _ { n } ^ { i } v _ { n } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            364,
+            729,
+            632,
+            747
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $v _ { n }$ denotes the $n _ { t h }$ element of the frame. ",
+        "bbox": [
+            174,
+            756,
+            485,
+            770
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To be able to separate a features pose from its canonical appearance, we are interested in a steerable version of an arbitrary filter $W _ { i } ( x , y )$ under a $\\mathbf { k }$ -parameter Lie group. From 5 follows: ",
+        "bbox": [
+            173,
+            776,
+            825,
+            806
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3516aa94f2dcc7134e268e55d9d4afd339a59facd02bb74ea7a6d2171235d2e3.jpg",
+        "text": "$$\ng ( \\tau ) W _ { i } ( x , y ) = \\sum _ { n = 1 } ^ { N } w _ { n } ^ { i } g ( \\tau ) v _ { n } ^ { i } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            392,
+            813,
+            606,
+            856
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "And by substituting according to equation 2 it follows: ",
+        "bbox": [
+            174,
+            863,
+            532,
+            878
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/492fb49717e4af90e712aff31c93341c11189ffd13d4b432c41f0cbf28158270.jpg",
+        "text": "$$\ng ( \\tau ) W _ { i } ( x , y ) = \\sum _ { n = 1 } ^ { N } w _ { n } ^ { i } \\sum _ { m = 1 } ^ { M } \\beta _ { m } ( \\tau ) \\phi _ { m } ( x , y ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            346,
+            885,
+            650,
+            928
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Thus it is sufficient to determine the group action on the fixed frame by steering it to separate the canonical feature itself from its $\\mathrm { k }$ -parameter variants, i.e. $v _ { n } ^ { i }$ govern the weight of each frame coefficient to form a feature $W _ { i } ( x , y )$ and $\\beta _ { m }$ are the steering functions governing the transformation of $g ( \\tau )$ acting on $W _ { i } ( x , y )$ as a whole. From now on learning and transforming features amounts to a point-wise multiplication of frame coefficients with cos, sin and exp activation functions, which is suitable for learning in a CNN. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2.4 DERIVING THE FRAME AND STEERING FUNCTIONS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            204,
+            566,
+            218
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Now the problem is reduced to finding a suitable frame as a function space underlying the learned filters. There are many approaches to derive a function space that is closed under the desired transformation group and as we show, many options give rise to bases that work considerably well when inserted into state-of-the-art CNNs. The most straightforward way is to derive it from the group’s infinitesimal generators, for brevity we refer the interested reader to (Hel-Or & Teo, 1998) and directly cite some derived equivariant function spaces from the paper. ",
+        "bbox": [
+            176,
+            229,
+            823,
+            314
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/702dc275f77d752401d91c9a6d68438e61e8cab2c0b7319c2002089f055cb097.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">Steerable Function Spaces</td></tr><tr><td>X,y Translation</td><td>xPyqeax+βy</td></tr><tr><td>X,y Scaling</td><td>xayβln(x)pln(y)q</td></tr><tr><td>Rotation &amp; Uniform Scaling</td><td>raln(r)peik</td></tr><tr><td>X,y Translation &amp; x,y Scaling&amp; Rotation</td><td>xpyq</td></tr></table>",
+        "bbox": [
+            287,
+            324,
+            709,
+            412
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Examples of function spaces closed under various non-Abelian multi-parameter groups, as derived in (Hel-Or & Teo, 1998). They can readily be used as a frame for CNNs by the procedure we derive here. ",
+        "bbox": [
+            178,
+            417,
+            820,
+            460
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Once a frame is chosen, we can simply check if it is closed under the given transformation group by verifying for each generator $L _ { i }$ that: ",
+        "bbox": [
+            174,
+            472,
+            823,
+            500
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f11080a1e4b93c533781111422ea3b7601b121aa7e5bea2009ab5cce8e302ab0.jpg",
+        "text": "$$\n{ \\cal L } _ { i } \\Phi ( x , y ) = { \\bf B } _ { i } \\Phi ( x , y ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            415,
+            506,
+            583,
+            522
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { B } _ { i }$ is some finite dimensional $n \\times n$ matrix. If this is the case, the function space is equivariant under the transformation group and we can compute the steering equations of the group composed of multiple generators as: ",
+        "bbox": [
+            174,
+            529,
+            825,
+            569
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2db75ae21bb88508a80369282050ab6c79a97eb903ff3832d56068df0fc493db.jpg",
+        "text": "$$\n\\mathbf { A } ( \\tau ) = e ^ { \\tau _ { k } \\mathbf { B } _ { k } } \\cdot \\ldots \\cdot e ^ { \\tau _ { 1 } \\mathbf { B } _ { 1 } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            408,
+            568,
+            589,
+            587
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To arrive at a practical solution, we have to consider the problem that locally bounded functions can not be steered globally with a finite steerable frame. To achieve a suitable approximation for our case, we separate scaling into two parts, an inner $\\{ \\sigma _ { x } , \\sigma _ { y } \\}$ and an outer scale $\\sigma _ { a }$ , where a stands for aperture. The inner scale can directly be steered via the above derivation and represents the slope of the local measurement taken by a filter, while the outer scale represents the size and shape of the filters receptive field. To achieve anisotropic receptive fields, we propose to first steer the scale at every pixel and steer the derived function space on this non-uniformly scaled grid, resulting in locally deformable receptive fields. Due to associativity of convolution, we can combine steering the derived function space and the receptive field scale into one operation. In this work, we use a second order approximation of the Gaussian that is capable of giving a good approximation to common CNN receptive field sizes 3x3, 5x5 and $7 \\mathbf { x } 7$ . For scaling over larger ranges, we recommend the spectral decomposition approach (Koutaki & Uchimura, 2014). ",
+        "bbox": [
+            173,
+            588,
+            825,
+            756
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2.5 DYNAMIC STEERABLE FRAME NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            772,
+            511,
+            786
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Estimating the local pose of a feature from a steerable function space is analytically intractable in the case of most multi-parameter groups. In this paper, we introduce the Dynamic Steerable Frame Network that combines the advantages of steerable function spaces with the power of neural network function estimators, by estimating pose parameters from a function space equivariant under the transformation group at hand. Specifically, our architecture is inspired by the recently introduced Dynamic Filter Networks (De Brabandere et al., 2016). The Dynamic Filter Network (DFN) generates one feature per location in a feature map, which boils down to a locally connected convolution layer, for which the parameters are generated by a different network that estimates them from the input, yielding a different filter kernel for every location in the input. ",
+        "bbox": [
+            173,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/8e9ca01d50e81f5ad21a8fc207c29b039e57abdf32a173fd09a8525ff1cb9e84.jpg",
+        "image_caption": [
+            "Figure 3: The Dynamic Steerable Frame Network. The network transforms an input image to a steerable frame $\\Phi$ (here an example with 3 frame functions) and estimates the local feature pose at each location in this equivariant space with a small pose estimating network. Then it outputs a set of pose coordinates $\\tau _ { \\mathbf { k } }$ , that are dependent on the group parametrization chosen. They are inserted into the matrix of steering equations $\\beta ( \\tau )$ and applied to the frame $\\Phi$ , yielding the locally steered frame. In the same operation, we integrate the weights $w _ { n }$ , that govern the feature maps canonical feature appearance, these are the weights learned by a normal CNN. The Dynamic Steerable Frame Network can decide to commute with a set of poses, to be invariant to them, to only look for certain poses or to act like a normal CNN, where each feature map has one pose and one canonical appearance assigned to itself. This is only determined by the input data and the backpropagated error signals. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            253,
+            97,
+            745,
+            218
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The DFN takes the form: ",
+        "bbox": [
+            174,
+            383,
+            339,
+            397
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b8e822c49dead61465881b6c3655e2f64fe8b08a35a4d010d471a2c7754cd7cb.jpg",
+        "text": "$$\nO ( x , y ) = F _ { \\tau } ^ { x , y } ( I ( x , y ) ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            413,
+            397,
+            583,
+            414
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $F _ { \\tau } ^ { x , y }$ are generated by another network from the input. We propose the Dynamic Steerable Frame Network, where the parameters $\\theta$ that condition the filter are pose transformation parameters of the steerable function space, estimated from the input, similar to how it is done in the Spatial Transformer Networks, just that in our case we aim for locally adaptive filters. The filters $F _ { \\tau } ^ { x , y }$ share the same set of weights in the whole feature map, so they represent the same canonical appearance everywhere. While their local pose is dynamically estimated by a Pose-Generating Network $\\Psi$ that takes the form: ",
+        "bbox": [
+            173,
+            417,
+            825,
+            513
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f6ab69166cb2a028b4dd73d78a407e99b328671fc0f3183c1b9f898ffd3f918e.jpg",
+        "text": "$$\n\\tau ( x , y ) = \\Psi ( I ( x , y ) ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            424,
+            513,
+            573,
+            530
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Thus, the canonical appearance is translation invariant, but its geometrical pose is not. In terms of equation 5, this means the set of $w _ { n } ^ { i }$ is fixed, but the frame $v _ { n } ^ { \\tau ( x , y ) }$ is locally transformed under a pre-defined k-parameter group with parameters $\\tau$ . See figure 5 for an illustration. ",
+        "bbox": [
+            174,
+            534,
+            825,
+            579
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The method consists of two parts: i) A Pose-Generating network estimating local pose parameters of a feature conditioned on the input from a steerable input space. ii) A Dynamic Filtering mechanism, convolving transformed versions of a feature with every location in the input feature map, based on the estimates of the pose generating network. Due to linearity of convolution, we can first perform a transformation of the input into the steerable frame space and in this space we perform i) and ii) as point-wise multiplications. ",
+        "bbox": [
+            174,
+            585,
+            825,
+            670
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            689,
+            344,
+            705
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Steerable Filters is a concept established early for signal processing. Initially introduced by (Freeman & Adelson, 1991), the concept was extended to the Steerable Pyramid by (Simoncelli & Freeman, 1995) and further extended to a Lie-group formulation by (Hel-Or & Teo, 1998; Michaelis & Sommer, 1995). Further, steerability has recently been extended to tight frames, presenting Simoncelli’s Steerable Pyramid and multiple other Wavelets arising as a special case of the non-orthogonal Riesz transform (Unser & Chenouard, 2013). Steerable pyramids have been applied to CNNs as a pre-processing step (Xue et al., 2016), but have not yet been learnable. We incorporate steerable frames in CNNs to increase their de facto expressiveness and to allow them to learn their configurations, rather than picking them a priori. ",
+        "bbox": [
+            173,
+            720,
+            825,
+            848
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Convolutional Networks with alternative bases have been proposed with various degrees of flexibility. A number of works utilizes change of basis to stabilize training and increase convergence behavior (Rippel et al., 2015; Arjovsky et al., 2015). Another line of research is concerned with complex-valued CNNs, either learned (Tygert et al., 2016), or fully designed like the Scattering networks (Bruna & Mallat, 2013; Oyallon & Mallat, 2015). ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Scattering, as well as the complex-valued networks, rest upon a direct connection between the signal processing literature and CNNs. Inspired by the former, Structured Receptive Field Networks are learned from an overcomplete multi-scale frame, effectively improving performance for small datasets due to restricted feature spaces (Jacobsen et al., 2016). Also related is the work on Groupequivariant CNNs (Cohen & Welling, 2016) and Cyclic Pooling (Dieleman et al., 2016), where equivariance towards the dihedral group is theoretically guaranteed, yielding increased accuracy. Inspired by CNNs learned from alternative bases, we introduce the general principle of Frame-based convolutional networks that allow for non-orthogonal, overcomplete and steerable feature spaces. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            214
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Another way to impose structure onto CNN representations and subsequently increase their dataefficiency is to incorporate explicit geometrical transformations into them. Either by learning transformation operators and group representations (Cohen et al., 2014; Wang et al., 2009). Or by predefining the possible transformations, as done in Transforming Autoencoders (Hinton et al., 2011), which map their inputs from the image to pose space through a neural network. The Spatial Transformer Networks (Jaderberg et al., 2015) learn global transformation parameters in a similar way while applying them to a nonlinear co-registration of the feature stack to some learned pose. This yields especially high performance on tasks where centering the objects is beneficial. Dynamic Filter Networks move one step further and estimate filters for each location, conditioned on their input. These approaches are all dynamic in a sense that they condition their parameters on the input appearance. We combine the idea of Dynamic Filter Networks with explicit pose prediction into Dynamic Steerable Frame Networks that can estimate poses from continuous input space, conditioned on the input. As such, we overcome the difficulty of estimating local pose, while being able to separate pose and feature learning globally. ",
+        "bbox": [
+            174,
+            222,
+            825,
+            416
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            439,
+            326,
+            455
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.1 GENERALIZING PIXELS TO FRAMES ON CIFAR- $^ { 1 0 + }$ ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            472,
+            568,
+            486
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To show the validity of general frame representations, we compare different bases in a state-of-theart pre-activation deep residual network architecture (He et al., 2016) on the Cifar- $^ { 1 0 + }$ (Krizhevsky & Hinton, 2009) dataset with moderate data augmentation of crops and flips. ",
+        "bbox": [
+            174,
+            498,
+            825,
+            541
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/21a66c3bcc01df1babb3c2eed5f1e2f3b14fedd3fc7e84cf3717ed158137d32e.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"4\">Error on Cifar10+</td></tr><tr><td>Method</td><td>Pixel</td><td>Image Frame</td><td>Naive Frame</td></tr><tr><td>ResNet-20</td><td>7.85%</td><td>7.61%</td><td>8.97%</td></tr><tr><td>ResNet-56</td><td>6.68%</td><td>6.08%</td><td>7.30%</td></tr><tr><td>ResNet-110</td><td>5.84%</td><td>5.34%</td><td>6.96%</td></tr><tr><td>Densenet K12 L40</td><td>5.28%</td><td>4.99%</td><td>6.39%</td></tr><tr><td>Densenet K12 L100</td><td>4.16%</td><td>3.78%</td><td>5.21%</td></tr></table>",
+        "bbox": [
+            294,
+            558,
+            702,
+            678
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 2: Results on Cifar10 with moderate data-augmentation (crops/flips) with the recently introduced pre-activation Residual network and Densenet with the standard pixel-basis, a steerable frame basis designed for natural images and the naive steerable $x ^ { p } y ^ { q }$ frame from table 3 that does not take natural image statistics into account. The natural image statistics based frame outperforms the pixelbasis consistently, while the naive frame consinstently performs about $1 \\%$ worse than the baseline, highlighting the benefit of a frame suitable for the type of input data. ",
+        "bbox": [
+            173,
+            686,
+            825,
+            770
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We evaluated our approach on multiple networks and network sizes. The setup used for the ResNet is as described in (He et al., 2016). The batch size is chosen to be 64 and we train for 164 epochs with the described learning rate decrease. The ResNet architectures used are without bottlenecks having 20, 56 and 110 layers. For the Densenets we follow (Huang et al., 2016) and evaluate on the ${ \\mathrm { K } } { = } 1 2$ and $_ { \\mathrm { L = 4 0 } }$ , and the ${ \\mathrm { K } } { = } 1 2$ and ${ \\mathrm { L } } { = } 1 0 0$ models. We run our experiments in Keras (Chollet, 2015) and Tensorflow (Abadi et al., 2016). In the first experiment, we run the models on the standard pixel basis to get a viable baseline. Secondly, we replace the pixel-basis with widely-used frames that take natural image statistics into account, namely non-orthogonal, overcomplete Gaussian derivatives (Florack et al., 1992) and non-orthogonal framelets (Daubechies et al., 2003) in an alternating fashion, yielding superior performance compared to the pixel-basis by replacement only. ",
+        "bbox": [
+            174,
+            785,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We also show that the naive $x ^ { p } y ^ { q }$ frame (see table 1) performs consistently worse than the other two choices, as it does not take natural image properties into account, while it is important to mention that this $1 \\%$ performance decrease also comes with additional properties that might be highly beneficial in particular tasks. We have also found orthogonal polynomials to not work very well (around $3 \\%$ performance decrease), which is in line with our expectation that suitable frames should take natural image statistics into account. 2D frames are generated from 1D functions via the following generating process: ",
+        "bbox": [
+            173,
+            103,
+            825,
+            202
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fdefd0f853d4846aa7302f8e1cf0db2c34a77fac6eb638bb1210ac376eb4569d.jpg",
+        "text": "$$\nF r a m e = \\{ v _ { 0 } , v _ { 1 } , v _ { 2 } , v _ { 3 } \\} \\otimes \\{ v _ { 0 } , v _ { 1 } , v _ { 2 } , v _ { 3 } \\} ^ { T } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            344,
+            218,
+            653,
+            237
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The results are reported in table 2. The fact that the pixel-basis can be replaced by steerable frames and performance even improves when the frame is chosen well, is remarkable, as this means every filter in the CNN enjoys additional properties, while performance improves in the standard setting already and finding suitable frames is not more expensive than running the same smallest CNN as many times as one has frames to choose from, as the performance we observed was consistent across multiple model sizes. Frame-based CNNs run at the same runtime as vanilla CNNs. ",
+        "bbox": [
+            174,
+            257,
+            825,
+            342
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.2 DYNAMIC STEERABLE FRAME NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            373,
+            511,
+            387
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this section we report two experiments. The first experiment is an edge detection task, highlighting the difference between our approach and multiple baselines in a fine-grained pixel-wise labeling task. In the second experiment, we apply a 2D convolutional LSTM on a small hand gesture recognition video dataset to illustrate how the Dynamic Steerable Frame Network regularizes the model effectively and to illustrate its benefits over Spatial Transform Networks. ",
+        "bbox": [
+            174,
+            405,
+            825,
+            474
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The model used in both experiments is learned from a steerable Gauss-Hermite frame. The Dynamic Steerable Frame Network consists of three processing steps. 1) Change to frame space on the input, 2) the Pose-Generating network estimates the pose from this transformed input, outputting a set of pose variables for each location in the image. 3) the steering functions derived in section 2.4 are applied to these pose variable maps and effectively act as nonlinear pose-parametrized activation functions that regularize the Pose-Generating network to output an explicitly interpretable pose space. Finally, a 1x1 convolution layer is applied to the already transformed output maps, representing the weights $w _ { n } ^ { i }$ , governing the canonical appearance of the $i _ { t h }$ feature map, see also figure 5. Dynamic Steerable Frame Networks run at the same computational cost as vanilla Dynamic Filter Networks. ",
+        "bbox": [
+            174,
+            481,
+            825,
+            621
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.2.1 EDGE DETECTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            650,
+            354,
+            665
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this experiment, we compare a Dynamic Filter Network (De Brabandere et al., 2016) baseline with an autoencoder and a Dynamic Steerable Frame Network on the task of edge detection. The problem is formulated as a pixel-wise classification task and reported is the root mean-squared error on an unseen test set. The labels are the edges. The dataset is infinite, as we produce random blobs and create the edge labels with a standard scikit image function. The standard DFN can freely learn an input layer with 2 filters and 3 subsequent 1x1 layers that can non-linearly recombine the inputs, whereas the Frame DFN receives a steerable frame as an input, allowing it to leverage the finegrained orientation information without the need to learn it. The Dynamic Steerable Frame Network has the exact same architecture as the DFN but is geometrically regularized on its output as can be seen in figure 5, as an input it receives a first order Gauss-Hermite frame that can be steered globally towards rotation and locally towards scale. ",
+        "bbox": [
+            174,
+            680,
+            825,
+            833
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Location varying methods are clearly superior in this task, compared to the location invariant autoencoder. The DFN increases its performance substantially when getting the steerable frame as an input, indicating its inability to learn a continuously transforming frame by itself. Finally, the Dynamic Steerable Frame Network clearly outperforms all baselines due to its ability to continuously transform its filters in a well-regularized manner. As an extra, we get the local feature pose for free from the output of the DSFN, the baseline has no notion of an explicit pose parameter, see figure 4. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/01b7c5a3157936c1ec093e87cb66a480d7d65112e320a78035fe67b992a1f67d.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>RMSE</td></tr><tr><td>Autoencoder</td><td>18.034</td></tr><tr><td>DFN</td><td>5.669</td></tr><tr><td>Frame DFN DSFN</td><td>1.554 0.778</td></tr></table>",
+        "bbox": [
+            573,
+            118,
+            746,
+            205
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/ca567f4a07cbb3397f5d4e2eb6bc964b829aa9540d512d619b4fe1c0dec6590b.jpg",
+        "image_caption": [
+            "Figure 4: Results on the edge detection task. Top is an illustration of a test image, bottom one sample from the actual infinite dataset, reported is root mean squared error. Autoencoder denotes a vanilla location invariant autoencoder. DFN denotes the plain Dynamic Filter Network, Frame DFN denotes a DFN whos input is a frame, DSFN denotes the Dynamic Steerable Frame Network. a) is the input, b) is the label, c) the prediction and d) the angular pose variable. d) is an output we get for free when training DSFNs, while a DFN has no notion of interpretable angle variables. Location varying methods clearly outperform the static autoencoder, while learning the DFN from a steerable frame increases performance again substantially. The DSFN substantially outperforms all other methods due to its continuously transforming input and output space. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            199,
+            113,
+            540,
+            218
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.2.2 SMALL SCALE VIDEO CLASSIFICATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            366,
+            501,
+            381
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "To show the ability of the Dynamic Steerable Frame Network to effectively regularize in dynamic settings where poses play an important role and where Spatial Transformer Networks do not work well, we apply it on the task of Hand-Gesture Recognition. Namely, on the Cambridge Hand-Gesture dataset (Kim & Cipolla, 2009), consisting of 9 classes of hand movement and poses in 900 videos, we use 750 for training, 50 for validation and 100 for testing. The dataset is very small and contains classes where global movement plays an important role and thus provides a good test bed to show effectiveness of the DSFN regularization ability compared to Spatial Transformers. ",
+        "bbox": [
+            173,
+            390,
+            825,
+            488
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/1faf539aa182a380a6f8fc65d132170be542a422b484905ad4c7ac2a91772850.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>convLSTM</td><td>1 Layer</td><td>2 Layer</td><td>rot/scale-DSFN</td><td>rot/scale-STN</td><td>affine-STN</td></tr><tr><td># Params</td><td>905k</td><td>913k</td><td>907k</td><td>971k</td><td>1037k</td></tr><tr><td> Accuracy</td><td>35.42%</td><td>39.31%</td><td>62.18%</td><td>21.34%</td><td>12.21 %</td></tr></table>",
+        "bbox": [
+            225,
+            502,
+            771,
+            568
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Table 3: Results on the Cambridge Hand-Gesture Recognition dataset, to illustrate the effectiveness of pose regularization provided by the Dynamic Steerable Frame Network. Adding the DSFN module to the convLSTM drastically improves performance. Increasing the capacity of the baseline to two layers, does not make up for the difference in performance, while adding the STN to the convLSTM decreases performance significantly, as the STN does not manage to learn meaningful global transformations that do not remove the class-specific information content. This is further substantiated by an increased performance when removing the ability to shear and translate the input from the STN. The DSFN outperforms all other approaches while only adding 2k free parameters to the baseline. ",
+        "bbox": [
+            173,
+            583,
+            825,
+            709
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Our baseline model is a convolutional LSTM with 10 output feature maps, batch normalization and a dense layer for classification. As a second baseline, we increase the capacity of the model by adding a second LSTM layer and a second batch normalization step. We combine two instances of a Spatial Transformer Network with a convolutional LSTM, one that can perform full affine transformations and one that is restricted to rotation and scaling. The DSFN module is applied to the input layer of the smaller model with 4 output feature maps. The setup of the steerable frame used in this model is a Gauss-Hermite frame. ",
+        "bbox": [
+            173,
+            720,
+            825,
+            819
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The steerability is uniquely parametrized as: $\\{ B _ { s } B _ { \\theta } \\}$ . Allowing for scaling and rotation. Both Spatial Transformer Networks do not manage to learn useful warps of the input image and therefore decrease performance of the baseline. The affine model only manages to correctly classify multiple instances of a static class that has no movement information related to its label, while the rot/scale model increases performance, but still does not manage to learn useful scalings or rotations. The DSFN manages to learn locally rotation and scale invariant filters, that follow the boundaries and other features across the video as desired. Results are reported in Table 3. ",
+        "bbox": [
+            173,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "For visualizations of the learned transformations, see Appendix A. The results illustrate the effectiveness of the DSFN to regularize the LSTM on a small-scale task where mostly local invariance is desired, but global invariance destroys most of the class-specific information. The DSFN improves performance over the baseline by about $22 \\%$ , while the Spatial Transformer Network decreases performance by about $15 \\%$ , or even to random in the full-affine case. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            172
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            194,
+            310,
+            210
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We have introduced the notion of Frame-based convolutional networks. Our experiments illustrate that a simple replacement of the standard basis by a frame suitable for natural images leads to increased performance. ",
+        "bbox": [
+            176,
+            226,
+            825,
+            268
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The insight that multiple frames can be considered as viable spanning sets for CNN representations leads us to steerable frames whose properties we exploit explicitly in our derived Dynamic Steerable Frame Networks, such that they can readily be accessed during training. The proposed method is a hybrid of Dynamic Filter Networks and Spatial Transformer Networks, enabling locally adaptive filtering with geometrical constraints. ",
+        "bbox": [
+            174,
+            275,
+            823,
+            344
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We illustrate the effectiveness of the approach on an edge detection task, that requires fine-grained pixel-wise labeling, where Dynamic Steerable Frame Networks outperform a standard Dynamic Filter Network and an autoencoder baseline. Further, we illustrate the ability of the Dynamic Steerable Frame Network to regularize recurrent networks in a small-data video classification scenario where Spatial Transformer Networks fail to learn meaningful transformations. ",
+        "bbox": [
+            176,
+            352,
+            825,
+            421
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Future work is to apply the model to other problem domains like egocentric video, robotics applications, as well as volumetric medical imaging videos of moving organs. We expect our Dynamic Steerable Frame Network approach to be beneficial in any problem where spatiotemporal continuity, data-efficiency, or interpretable pose spaces are key. ",
+        "bbox": [
+            176,
+            429,
+            823,
+            484
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGEMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            507,
+            367,
+            522
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We would like to thank Edouard Oyallon and Taco Cohen for insightful comments and discussions. ",
+        "bbox": [
+            173,
+            537,
+            821,
+            553
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            574,
+            285,
+            589
+        ],
+        "page_idx": 9
+    },
+    {
+        "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.   \nMartin Arjovsky, Amar Shah, and Yoshua Bengio. Unitary evolution recurrent neural networks. arXiv preprint arXiv:1511.06464, 2015.   \nJoan Bruna and Stephane Mallat. Invariant scattering convolution networks. ´ IEEE transactions on pattern analysis and machine intelligence, 35(8):1872–1886, 2013.   \nFranc¸ois Chollet. Keras. https://github.com/fchollet/keras, 2015.   \nOle Christensen. An introduction to frames and Riesz bases, volume 7. Springer, 2003.   \nTaco Cohen, Max Welling, et al. Learning the irreducible representations of commutative lie groups. In ICML, pp. 1755–1763, 2014.   \nTaco S Cohen and Max Welling. Group equivariant convolutional networks. arXiv preprint arXiv:1602.07576, 2016.   \nIngrid Daubechies, Bin Han, Amos Ron, and Zuowei Shen. Framelets: Mra-based constructions of wavelet frames. Applied and computational harmonic analysis, 14(1):1–46, 2003.   \nBert De Brabandere, Xu Jia, Tinne Tuytelaars, and Luc Van Gool. Dynamic filter networks. arXiv preprint arXiv:1605.09673, 2016. ",
+        "bbox": [
+            171,
+            597,
+            828,
+            926
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sander Dieleman, Jeffrey De Fauw, and Koray Kavukcuoglu. Exploiting cyclic symmetry in convolutional neural networks. arXiv preprint arXiv:1602.02660, 2016. ",
+        "bbox": [
+            169,
+            103,
+            823,
+            133
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Luc MJ Florack, Bart M ter Haar Romeny, Jan J Koenderink, and Max A Viergever. Scale and the differential structure of images. Image and Vision Computing, 10(6):376–388, 1992. ",
+        "bbox": [
+            171,
+            141,
+            821,
+            171
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "William T Freeman and Edward H Adelson. The design and use of steerable filters. IEEE Transactions on Pattern analysis and machine intelligence, 13(9):891–906, 1991. ",
+        "bbox": [
+            171,
+            179,
+            821,
+            209
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Robert Gens and Pedro M Domingos. Deep symmetry networks. In Advances in neural information processing systems, pp. 2537–2545, 2014. ",
+        "bbox": [
+            173,
+            217,
+            825,
+            247
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Identity mappings in deep residual networks. arXiv preprint arXiv:1603.05027, 2016. ",
+        "bbox": [
+            174,
+            256,
+            823,
+            286
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yacov Hel-Or and Patrick C Teo. Canonical decomposition of steerable functions. Journal of Mathematical Imaging and Vision, 9(1):83–95, 1998. ",
+        "bbox": [
+            176,
+            294,
+            823,
+            324
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey E Hinton, Alex Krizhevsky, and Sida D Wang. Transforming auto-encoders. In International Conference on Artificial Neural Networks, pp. 44–51. Springer, 2011. ",
+        "bbox": [
+            174,
+            332,
+            821,
+            362
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Gao Huang, Zhuang Liu, and Kilian Q Weinberger. Densely connected convolutional networks. arXiv preprint arXiv:1608.06993, 2016. ",
+        "bbox": [
+            174,
+            369,
+            821,
+            400
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jorn-Henrik Jacobsen, Jan van Gemert, Zhongyu Lou, and Arnold W.M. Smeulders. Structured ¨ receptive fields in cnns. 2016. ",
+        "bbox": [
+            174,
+            409,
+            823,
+            438
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Max Jaderberg, Karen Simonyan, Andrew Zisserman, et al. Spatial transformer networks. In Advances in Neural Information Processing Systems, pp. 2017–2025, 2015. ",
+        "bbox": [
+            173,
+            446,
+            823,
+            477
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tae-Kyun Kim and Roberto Cipolla. Canonical correlation analysis of video volume tensors for action categorization and detection. IEEE Transactions on Pattern Analysis and Machine Intelligence, 31(8):1415–1428, 2009. ",
+        "bbox": [
+            173,
+            484,
+            825,
+            529
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Gou Koutaki and Keiichi Uchimura. Scale-space processing using polynomial representations. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2744– 2751, 2014. ",
+        "bbox": [
+            174,
+            536,
+            825,
+            580
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009. ",
+        "bbox": [
+            173,
+            589,
+            823,
+            606
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Markus Michaelis and Gerald Sommer. A lie group approach to steerable filters. Pattern Recognition Letters, 16(11):1165–1174, 1995. ",
+        "bbox": [
+            171,
+            613,
+            825,
+            643
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Edouard Oyallon and Stephane Mallat. Deep roto-translation scattering for object classification. ´ In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2865– 2873, 2015. ",
+        "bbox": [
+            174,
+            651,
+            823,
+            695
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Pietro Perona. Steerable-scalable kernels for edge detection and junction analysis. In ECCV, pp. 3–18. Springer, 1992. ",
+        "bbox": [
+            169,
+            704,
+            823,
+            733
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Oren Rippel, Jasper Snoek, and Ryan P Adams. Spectral representations for convolutional neural networks. In Advances in Neural Information Processing Systems, pp. 2449–2457, 2015. ",
+        "bbox": [
+            173,
+            742,
+            823,
+            772
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Eero P Simoncelli and William T Freeman. The steerable pyramid: a flexible architecture for multiscale derivative computation. In ICIP (3), pp. 444–447, 1995. ",
+        "bbox": [
+            169,
+            780,
+            823,
+            810
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Patrick C Teo and Yacov Hel-Or. Lie generators for computing steerable functions. Pattern Recognition Letters, 19(1):7–17, 1998. ",
+        "bbox": [
+            171,
+            818,
+            823,
+            848
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mark Tygert, Joan Bruna, Soumith Chintala, Yann LeCun, Serkan Piantino, and Arthur Szlam. A mathematical motivation for complex-valued convolutional networks. Neural computation, 2016. ",
+        "bbox": [
+            174,
+            856,
+            823,
+            886
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Michael Unser and Nicolas Chenouard. A unifying parametric framework for 2d steerable wavelet transforms. SIAM Journal on Imaging Sciences, 6(1):102–135, 2013. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jimmy Wang, Jascha Sohl-Dickstein, and Bruno Olshausen. Unsupervised learning of lie group operators from image sequences. In Frontiers in Systems Neuroscience. Conference Abstract: Computational and systems neuroscience, 2009. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tianfan Xue, Jiajun Wu, Katherine L Bouman, and William T Freeman. Visual dynamics: Probabilistic future frame synthesis via cross convolutional networks. arXiv preprint arXiv:1607.02586, 2016. ",
+        "bbox": [
+            174,
+            159,
+            825,
+            202
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX A VISUALIZING DSFN AND STN TRANSFORMATIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            232,
+            733,
+            250
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/ba16a429ace081cd119c5f0c94f8051e776c1f7bcd05a93e2649f06f2e02d355.jpg",
+        "image_caption": [
+            "Figure 5: Visualizations of the learned transformations by the Dynamic Steerable Frame Network (DSFN top) and the Spatial Transformer Network (STN bottom) on the hand-gesture recognition dataset. The STN zooms and rotates the hands arbitrarily and apparently removes important information content thereby, leading to low classification accuracy. The DSFN acts locally and adaptively filters the hands in multiple ways. Note that the DSFN did not learn fully rotation invariant filters in all 4 cases, but in 3 cases produces different filter responses for different sides of the hand. However, it does follow the contours of the hand and segments the borders from the background. This indicates that full rotation invariance is not suitable for this task. This would be hard to assess if one had to choose the degree of invariance a priori, while the DSFN has the means to learn the necessary amount of local invariance. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            250,
+            271,
+            735,
+            555
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX B EQUIVARIANCE PROOF & STEERING EQUATION DERIVATION ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            727,
+            808,
+            743
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "To prove that a frame is equivariant with respect to the action of a group transformation, determined by its generator $L _ { i }$ , we simply have to show that: ",
+        "bbox": [
+            173,
+            760,
+            823,
+            789
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/03db89ed260421c3e667d772c69725f7fa9430c59dadf5afbc5d91f4904d1f68.jpg",
+        "text": "$$\n{ \\cal L } _ { i } \\Phi ( x , y ) = { \\bf B } _ { i } \\Phi ( x , y ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            415,
+            797,
+            583,
+            815
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Where $\\mathbf { B } _ { i }$ is some $n \\times n$ matrix. ",
+        "bbox": [
+            174,
+            824,
+            390,
+            838
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "In case of the Hermite polynomials (here considered up to second order), we have: ",
+        "bbox": [
+            171,
+            844,
+            714,
+            861
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/07c7e8858ac15e35ece186d6f8bdb0f438211aa570d3a82db0482a6a87c2fcf8.jpg",
+        "text": "$$\n\\Phi ( x , y ) = \\{ 1 , x , y , x ^ { 2 } - 1 , x y , y ^ { 2 } - 1 \\} .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            366,
+            867,
+            632,
+            887
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "To verify that these functions span an equivariant function space with respect to rotation, we apply the generator of rotations to the frame and verify that equation 13 holds. The generator of rotations ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "in the plane is given by $\\begin{array} { r } { L _ { r } = - x \\frac { d } { d y } + y \\frac { d } { d x } } \\end{array}$ , applied to each frame element, we get: ",
+        "bbox": [
+            173,
+            101,
+            717,
+            122
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6dfa866edbfcb21723b4a57a9a8b89a1983b25e51c584c84fd3bc5f8f07a7001.jpg",
+        "text": "$$\nL _ { r } \\Phi ( x , y ) = \\left[ \\begin{array} { c } { 0 } \\\\ { y } \\\\ { - x } \\\\ { 2 x y } \\\\ { - x ^ { 2 } + y ^ { 2 } } \\\\ { - 2 x y } \\end{array} \\right] = \\mathbf { B } _ { r } \\left[ \\begin{array} { c } { 1 } \\\\ { x } \\\\ { y } \\\\ { x ^ { 2 } - 1 } \\\\ { x y } \\\\ { y ^ { 2 } - 1 } \\end{array} \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            348,
+            127,
+            648,
+            217
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "It is straightforward to solve this linear system and obtain the $6 \\times 6$ matrix $B _ { r }$ : ",
+        "bbox": [
+            171,
+            222,
+            689,
+            238
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1ddc53b0628a4b5b991c8d5090fdffdb0f53022e0115088e5b4c6f46befac189.jpg",
+        "text": "$$\n\\mathbf { B } _ { r } = \\left[ \\begin{array} { c c c c c c c } { 0 } & { 0 } & { 0 } & { 0 } & { 0 } & { 0 } \\\\ { 0 } & { 0 } & { 1 } & { 0 } & { 0 } & { 0 } \\\\ { 0 } & { - 1 } & { 0 } & { 0 } & { 0 } & { 0 } \\\\ { 0 } & { 0 } & { 0 } & { 0 } & { 2 } & { 0 } \\\\ { 0 } & { 0 } & { 0 } & { - 1 } & { 0 } & { 1 } \\\\ { 0 } & { 0 } & { 0 } & { 0 } & { - 2 } & { 0 } \\end{array} \\right] . \\quad \\left[ \\begin{array} { c c c c c c } \\end{array} \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            362,
+            242,
+            625,
+            332
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Thus, we have proven that the function space is closed under the action of the group and the Hermite polynomials constitute an equivariant function space with respect to rotation. ",
+        "bbox": [
+            173,
+            337,
+            823,
+            366
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Subsequently, the exponential map directly yields the steering equations collected in the interpolation matrix $\\dot { \\mathbf { A } } ^ { \\theta }$ , that can rotate the whole frame by $\\theta$ : ",
+        "bbox": [
+            174,
+            372,
+            823,
+            401
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c1caac7fdf6992deb086f43d07a8639e16c899a53f22bacd0a8431515f95d41c.jpg",
+        "text": "$$\n\\begin{array} { l l } { { \\Phi ^ { \\theta } ( x , y ) = e ^ { \\theta \\mathbf { B } _ { r } } \\Phi ( x , y ) = \\mathbf { A } ^ { \\theta } \\Phi ( x , y ) , } } & { { } } \\\\ { { \\ } } & { { } } \\\\ { { \\Phi ^ { \\theta } ( x , y ) = \\left[ \\begin{array} { c c c c c c } { { 1 } } & { { 0 } } & { { 0 } } & { { 0 } } & { { 0 } } \\\\ { { 0 } } & { { \\cos \\theta } } & { { \\sin \\theta } } & { { 0 } } & { { 0 } } & { { 0 } } \\\\ { { 0 } } & { { - \\sin \\theta } } & { { \\cos \\theta } } & { { 0 } } & { { 0 } } & { { 0 } } \\\\ { { 0 } } & { { 0 } } & { { 0 } } & { { { \\frac { 1 } { 2 } } + { \\frac { 1 } { 2 } } \\cos 2 \\theta } } & { { \\sin 2 \\theta } } & { { { \\frac { 1 } { 2 } } - { \\frac { 1 } { 2 } } \\cos 2 \\theta } } \\\\ { { 0 } } & { { 0 } } & { { 0 } } & { { - { \\frac { 1 } { 2 } } \\sin 2 \\theta } } & { { \\cos 2 \\theta } } & { { { \\frac { 1 } { 2 } } \\sin 2 \\theta } } \\\\ { { 0 } } & { { 0 } } & { { 0 } } & { { { \\frac { 1 } { 2 } } - { \\frac { 1 } { 2 } } \\cos 2 \\theta } } & { { - \\sin 2 \\theta } } & { { { \\frac { 1 } { 2 } } + { \\frac { 1 } { 2 } } \\cos 2 \\theta } } \\end{array} \\right] \\left[ \\begin{array} { c } { { 1 } } \\\\ { { x } } \\\\ { { y } } \\\\ { { x ^ { 2 } - 1 } } \\\\ { { x y } } \\\\ { { y ^ { 2 } - 1 } } \\end{array} \\right] . } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            210,
+            405,
+            784,
+            521
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "$\\Phi ^ { \\theta } ( x , y )$ is the frame rotated by some angle $\\theta$ . Combining this result with equation 7, gives us the possibility to rotate any learned feature by arbitrary and continuous angles $\\theta$ . The whole procedure is completely analogous for any other Lie group transformation. Further, k-parameter transformation groups can be composed according to equation 9 from smaller groups. Here an example of the general linear group of rotation, anisotropic scalings and skew: ",
+        "bbox": [
+            173,
+            525,
+            826,
+            597
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cf179c950630df582d1daf52f4c921c8466c056e581d84803f2dd02db324fac9.jpg",
+        "text": "$$\n\\Phi ^ { \\{ \\theta _ { 1 } , s _ { x } , s _ { y } , \\theta _ { 2 } \\} } ( x , y ) = { \\bf A } ^ { \\{ \\theta _ { 1 } , s _ { x } , s _ { y } , \\theta _ { 2 } \\} } \\Phi ( x , y ) = e ^ { \\theta _ { 2 } \\mathbf { B } _ { r } } \\cdot e ^ { s _ { x } \\mathbf { B } _ { s x } } \\cdot e ^ { s _ { y } \\mathbf { B } _ { s y } } \\cdot e ^ { \\theta _ { 1 } \\mathbf { B } _ { r } } \\Phi ( x , y ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            196,
+            603,
+            774,
+            622
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX C BACKPROPAGATION THROUGH STEERABLE FILTERS",
+        "text_level": 1,
+        "bbox": [
+            176,
+            641,
+            728,
+            659
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Will be added to final manuscript. ",
+        "bbox": [
+            174,
+            672,
+            398,
+            688
+        ],
+        "page_idx": 12
+    }
+]

parse/train/gEzN9bBbLt8/gEzN9bBbLt8.md

@@ -0,0 +1,294 @@
+# STEM: A Stochastic Two-Sided Momentum Algorithm Achieving Near-Optimal Sample and Communication Complexities for Federated Learning
+
+Prashant Khanduri University of Minnesota khand095@umn.edu
+
+Pranay Sharma Carnegie Mellon University pranaysh@andrew.cmu.edu
+
+Haibo Yang The Ohio State University yang.5952@buckeyemail.osu.edu
+
+Mingyi Hong⇤ University of Minnesota mhong@umn.edu
+
+Jia Liu The Ohio State University liu@ece.osu.edu
+
+Ketan Rajawat Indian Institute of Technology Kanpur ketan@iitk.ac.in
+
+Pramod K. Varshney Syracuse University varshney@syr.edu
+
+# Abstract
+
+Federated Learning (FL) refers to the paradigm where multiple worker nodes (WNs) build a joint model by using local data. Despite extensive research, for a generic non-convex FL problem, it is not clear, how to choose the WNs’ and the server’s update directions, the minibatch sizes, and the number of local updates, so that the WNs use the minimum number of samples and communication rounds to achieve the desired solution. This work addresses the above question and considers a class of stochastic algorithms where the WNs perform a few local updates before communication. We show that when both the WN’s and the server’s directions are chosen based on certain stochastic momentum estimator, the algorithm requires $\tilde { \mathcal O } ( \epsilon ^ { - 3 / 2 } )$ samples and $\tilde { \mathcal { O } } ( \epsilon ^ { - 1 } )$ communication rounds to compute an $\epsilon$ -stationary solution. To the best of our knowledge, this is the first FL algorithm that achieves such near-optimal sample and communication complexities simultaneously. Further, we show that there is a trade-off curve between the number of local updates and the minibatch sizes, on which the above sample and communication complexities can be maintained. Finally, we show that for the classical FedAvg (a.k.a. Local SGD, which is a momentum-less special case of the STEM), a similar trade-off curve exists, albeit with worse sample and communication complexities. Our insights on this trade-off provides guidelines for choosing the four important design elements for FL algorithms, the number of local updates, WNs’ and server’s update directions, and minibatch sizes to achieve the best performance.
+
+# 1 Introduction
+
+In Federated Learning (FL), multiple worker nodes (WNs) collaborate with the goal of learning a joint model, by only using local data. Therefore it has become popular for machine learning problems where datasets are massively distributed [1]. In FL, the data is often collected at or off-loaded to multiple WNs which in collaboration with a server node (SN) jointly aim to learn a centralized model [2, 3]. The local WNs share the computational load and since the data is local to each WN, FL also provides some level of data privacy $\mathbb { H }$ . A classical distributed optimization problem that $K$ WNs aim to solve:
+
+![](images/8b109c70673d05d4fb4863253d56729a5c2b37b6a73924b30a5e660d7b6d1078.jpg)  
+Figure 1: The 3D surface in (a) plots the communication complexity of the proposed STEM for different minibatch sizes and number of local updates. The surface is generated such that each point represents STEM with a particular choice of $( b , I )$ , so that it requires $\tilde { \mathcal { O } } ( \epsilon ^ { - 3 / 2 } )$ samples to achieve $\epsilon$ -stationarity. Plot (b) shows the optimal trade off between the minibatch sizes and the number of local updates at each WN (i.e., achieving the lowest communication and sample complexities). Both plots are generated for an accuracy of $\epsilon = 1 0 ^ { - 3 }$ and all the constants dependent on system parameters (variance of stochastic gradients, heterogeneity parameter, optimality gap, Lipschitz constants, etc.) are assumed to be 1. Fed STEM is a special case of STEM where $\mathcal { O } ( 1 )$ minibatch is used; Minibatch STEM is a special case of STEM where $\mathcal { O } ( 1 )$ local updates are used.
+
+$$
+\operatorname* { m i n } _ { x \in \mathbb { R } ^ { d } } \bigg \{ f ( x ) : = \frac { 1 } { K } \sum _ { k = 1 } ^ { K } f ^ { ( k ) } ( x ) : = \frac { 1 } { K } \sum _ { k = 1 } ^ { K } \mathbb { E } _ { \xi ^ { ( k ) } \sim \mathcal { D } ^ { ( k ) } } \big [ f ^ { ( k ) } ( x ; \xi ^ { ( k ) } ) \big ] \bigg \} .
+$$
+
+where $f ^ { ( k ) } : \mathbb { R } ^ { d }  \mathbb { R }$ denotes the smooth (possibly non-convex) objective function and $\xi ^ { ( k ) } \sim \mathcal { D } ^ { ( k ) }$ represents the sample/s drawn from distribution $\mathcal { D } ^ { ( k ) }$ at the $k ^ { \mathrm { { t h } } }$ WN with $k \in [ K ]$ . When the distributions $\mathcal { D } ^ { ( k ) }$ are different across the WNs, it is referred to as the heterogeneous data setting.
+
+The optimization performance of non-convex FL algorithms is typically measured by the total number of samples accessed (cf. Definition $\boxed { 2 . 2 }$ and the total rounds of communication (cf. Definition $2 . 3 )$ required by each WN to achieve an $\epsilon$ -stationary solution (cf. Definition $\boxed { 2 . 1 }$ . To minimize the sample and the communication complexities, FL algorithms rely on the following four key design elements: (i) the WNs’ local model update directions, (ii) Minibatch size to compute each local direction, (iii) the number of local updates before WNs share their parameters, and (iv) the SN’s update direction. How to find effective FL algorithms by (optimally) designing these parameters has received significant research interest recently.
+
+Contributions. The main contributions of this work are listed below:
+
+1) We propose the Stochastic Two-Sided Momentum (STEM) algorithm, that utilizes certain momentum-assisted stochastic gradient directions for both the WNs and SN updates. We show that there exists an optimal trade off between the minibatch sizes and number of local updates, such that on the trade-off curve STEM requires $\tilde { \mathcal { O } } ( \epsilon ^ { - 3 / 2 } ) ^ { 2 }$ samples and $\tilde { \mathcal { O } } ( \epsilon ^ { - 1 } )$ communication rounds to reach an $\epsilon$ -stationary solution; see Figure $\bigstar$ for an illustration. These complexity results are the best achievable for first-order stochastic FL algorithms (under certain assumptions, cf. Assumption $\bigstar \bigstar$ ; see $\pm \boxed { 5 } \boxed { 8 } \parallel$ and $\mathbb { B } \mathbb { n o }$ , as well as Remark $\checkmark$ of this paper for discussions regarding optimality. To the best of our knowledge, STEM is the first algorithm which – (i) simultaneously achieves the optimal sample and communication complexities for FL and (ii) can optimally trade off the minibatch sizes and the number of local updates.
+
+2) A momentum-less special case of our STEM result further reveals some interesting insights of the classical FedAvg algorithm (a.k.a. the Local SGD) [11–13]. Specifically, we show that for FedAvg, there also exists a trade-off between the minibatch sizes and the number of local updates, such that it requires $\mathcal { O } ( \epsilon ^ { - 2 } )$ samples and $\mathcal { O } ( \epsilon ^ { - 3 / 2 } )$ communication rounds to achieve an $\epsilon$ -stationary solution.
+
+<table><tr><td>Algorithm</td><td>Work</td><td>Sample</td><td>Comm.</td><td>Minibatch (b)</td><td>Local Updates (I) /round</td></tr><tr><td>FedAvg</td><td>国园 国国</td><td>0(€-2)</td><td>0(c-3/2) 0(c-2)</td><td>0(1) 0(1) 2(1-v)</td><td>0(c-1/2) 0(1) 3v</td></tr><tr><td>SCAFFOLD*</td><td>this work 国</td><td>0(c-2）</td><td>O(e-3/2) 0（c-2）</td><td>O(c 4-v) 0(1)</td><td>O(c−2（4-D)） 0(1)</td></tr><tr><td>FedPD/FedProx*</td><td>四/□</td><td>O(c-2）</td><td>0(e-1)</td><td>0(1)</td><td>0(e-1）</td></tr><tr><td>MIME†/FedGLOMO</td><td>/8</td><td>0(c-3/2)</td><td>O(€-3/2)</td><td>0(1)</td><td>0(1)</td></tr><tr><td>STEM Fed STEM Minibatch STEM*</td><td> this work</td><td>O(€-3/2)</td><td>O(e-1)</td><td>( 0(1) O(e-1/2)</td><td>O(∈−(3)) O(∈-1/2) 0(1)</td></tr></table>
+
+Table 1: Comparison of FedAvg and STEM with different FL algorithms for various choices of the minibatch sizes $( b )$ and the number of per node local updates between two rounds of communication $( I )$ . $^ \circ \nu \in [ 0 , 1 ]$ trades off $^ { b }$ and $I$ ; $\nu = 1$ (resp. $\nu = 0$ ) uses multiple (resp. $\mathcal { O } ( 1 ) .$ ) local updates and $\mathcal { O } ( 1 )$ (resp. multiple) samples. Fed STEM and Minibatch STEM are two variants of the proposed STEM. ‡The data heterogeneity assumption is weaker than Assumption $2$ (please see $\bigstar \bigstar$ for details). †Requires bounded Hessian dissimilarity to model data heterogeneity across WNs. ⇤Guarantees for Minibatch STEM with $I = 1$ and SCAFFOLD are independent of the data heterogeneity.
+
+Collectively, our insights on the trade-offs provide practical guidelines for choosing different design elements for FL algorithms.
+
+Related Works. FL algorithms were first proposed in the form of FedAvg [11], where the local update directions at each WN were chosen to be the SGD updates. Earlier works analyzed these algorithms in the homogeneous data setting [19–25], while many recent studies have focused on designing new algorithms to deal with heterogeneous data settings, as well as problems where the local loss functions are non-convex [9, 10, 12–16, 18, 26–32]. In $\bar { \mathbb { E } 2 } \mathbb { I }$ , the authors showed that Parallel Restarted SGD (Local SGD or FedAvg [11]) achieves linear speed up while requiring $\mathcal { O } ( \epsilon ^ { - 2 } )$ samples and $\mathcal { O } ( \epsilon ^ { - 3 / 2 } )$ rounds of communication to reach an $\epsilon$ -stationary solution. In $\bar { \textregistered }$ , a Momentum SGD was proposed, which achieved the same sample and communication complexities as Parallel Restarted SGD $\mathbb { \lVert 1 2 \rVert }$ , without requiring that the second moments of the gradients be bounded. Further, it was shown that under the homogeneous data setting, the communication complexity can be improved to $\mathcal { O } ( \epsilon ^ { - 1 } )$ while maintaining the same sample complexity. The works in $\boxed { 1 5 } \boxed { 1 6 }$ conducted tighter analysis for FedAvg with partial WN participation with $\mathcal { O } ( 1 )$ local updates and batch sizes. Their analysis showed that FedAvg’s sample and communication complexities are both $\mathcal { O } ( \epsilon ^ { - 2 } )$ . Additionally, SCAFFOLD was proposed in $\bar { \| 1 5 \| }$ , which utilized variance reduction based local update directions $\mathbb { \lVert 3 3 \rVert }$ to achieve the same sample and communication complexities as FedAvg. Similarly, VRL-SGD proposed in $\left[ \left[ 2 9 \right] \right]$ also utilized variance reduction and showed improved communication complexity of $\mathcal { O } ( \epsilon ^ { - 1 } )$ , while requiring the same computations as FedAvg. Importantly, both SCAFFOLD and VRL-SGD’s guarantees were independent of the data heterogeneity. The FedProx proposed in $\mathbb { I O } ]$ used a penalty based method to improve the communication complexity of FedAvg (i.e., the Parallel Restarted and Momentum SGD [14, $\mathbb { L } 2 \mathbb { I }$ ) to $\mathcal { O } ( \epsilon ^ { - 1 } )$ . FedProx used a gradient similarity assumption to model data heterogeneity which can be stringent for many practical applications. This assumption was relaxed by FedPD proposed in $\mathbb { \left[ 9 \right] }$ .
+
+Recently, the works [17, 18] proposed to utilize hybrid momentum gradient estimators [7, 8]. The MIME algorithm $\mathbb { \ m }$ matched the optimal sample complexity (under certain smoothness assumptions) of $\mathcal { O } ( \epsilon ^ { - 3 / 2 } )$ of the centralized non-convex stochastic optimization algorithms [5–8]. Similarly, Fed-GLOMO $[ \overline { { 1 8 } } ]$ achieved the same sample complexity while employing compression to further reduce communication. Both MIME and Fed-GLOMO required $\mathcal { O } ( \epsilon ^ { - 3 / 2 } )$ communication rounds to achieve an $\epsilon$ -stationary solution. Please see Table $\bigtriangledown$ for a summary of the above discussion.
+
+The comparison of Local SGD (FedAvg) to Minibatch SGD for convex and strongly convex problems with homogeneous data setting was first conducted in $\mathbb { \underline { { \ m } } }$ and later extended to heterogeneous setting in $\mathbb { \lVert \rVert 3 \rVert }$ . It was shown that Minibatch SGD almost always dominates the Local SGD. In contrast, it was shown in $\pmb { \Vert 2 4 \Vert }$ that Local SGD dominates Minibatch SGD in terms of generalization performance. Although existing FL results are rich, but they are somehow ad hoc and there is a lack of principled understanding of the algorithms. We note that the proposed STEM algorithmic framework provides a theoretical framework that unifies all existing $\mathrm { F L }$ results on sample and communication complexities.
+
+Notations. The expected value of a random variable $X$ is denoted by $\mathbb { E } [ X ]$ and its expectation conditioned on an Event $A$ is denoted as $\mathbb { E } [ X | \mathrm { E v e n t ~ } A ]$ . We denote by $\mathbb { R }$ (and $\mathbb { R } ^ { d }$ ) the real line (and the $d$ -dimensional Euclidean space). The set of natural numbers is denoted by $\mathbb { N }$ . Given a positive integer $K \in \mathbb N$ , we denote $[ K ] \triangleq \{ 1 , 2 , \dots , K \}$ . Notation $\| \cdot \|$ denotes the $\ell _ { 2 }$ -norm and $\langle \cdot , \cdot \rangle$ the Euclidean inner product. For a discrete set $\boldsymbol { B }$ , $| B |$ denotes the cardinality of the set. Uniform distribution over a discrete set $\{ 1 , \ldots , T \}$ is denoted as ${ \dot { \mathcal { U } } } \{ 1 , \dots , T \}$ .
+
+# 2 Preliminaries
+
+Before we proceed to the algorithms, we make the following assumptions about problem $( 1 )$ .
+
+Assumption 1 (Sample Gradient Lipschitz Smoothness). The stochastic functions $f ^ { ( k ) } ( \cdot , \xi ^ { ( k ) } )$ with $\xi ^ { ( k ) } \sim \mathcal { D } ^ { ( k ) }$ for all $k \in [ K ]$ , satisfy the mean squared smoothness property, i.e, we have
+
+$$
+\begin{array} { r } { \mathbb { E } \| \nabla f ^ { ( k ) } ( x ; \xi ^ { ( k ) } ) - \nabla f ^ { ( k ) } ( y ; \xi ^ { ( k ) } ) \| ^ { 2 } \leq L ^ { 2 } \| x - y \| ^ { 2 } \mathrm { ~ f o r ~ a l l ~ } x , y \in \mathbb { R } ^ { d } . } \end{array}
+$$
+
+Assumption 2 (Unbiased gradient and Variance Bounds). (i) Unbiased Gradient. The stochastic gradients computed at each WN are unbiased
+
+$$
+\mathbb { E } [ \nabla f ^ { ( k ) } ( x ; \xi ^ { ( k ) } ) ] = \nabla f ^ { ( k ) } ( x ) , \forall \xi ^ { ( k ) } \sim \mathcal { D } ^ { ( k ) } , \forall k \in [ K ] .
+$$
+
+(ii) Intra- and inter- node Variance Bound. The following bounds hold:
+
+$$
+\begin{array} { r } { \mathbb { \tilde { z } } \| \nabla f ^ { ( k ) } ( x ; \xi ^ { ( k ) } ) - \nabla f ^ { ( k ) } ( x ) \| ^ { 2 } \leq \sigma ^ { 2 } , \| \nabla f ^ { ( k ) } ( x ) - \nabla f ^ { ( \ell ) } ( x ) \| ^ { 2 } \leq \zeta ^ { 2 } , \forall \xi ^ { ( k ) } \sim \mathcal { D } ^ { ( k ) } , \forall k , \ell \in [ K ] . } \end{array}
+$$
+
+Note that Assumption $^ 1$ is stronger than directly assuming $f ^ { ( k ) }$ ’s are Lipschitz smooth (which we will refer to as the averaged gradient Lipschitz smooth condition), but it is still a rather standard assumption in SGD analysis. For example it has been used in analyzing centralized SGD algorithms such as SPIDER $ { \mathbb { I } }$ , SNVRG $\pmb { \Vert 6 \Vert }$ , STORM $\mathbb { [ [ \big ] ] }$ (and many others) as well as in FL algorithms such as MIME $ { \mathbb { I } } ^ { [ 1 2 ] }$ and Fed-GLOMO $\pm \textcircled { 1 8 } \textcircled { 1 }$ . The second relation in Assumption $2 \cdot$ (ii) quantifies the data heterogeneity, and we call $\zeta > 0$ as the heterogeneity parameter. This is a typical assumption required to evaluate the performance of FL algorithms. If data distributions across individual WNs are identical, i.e., $\mathcal { D } ^ { ( k ) } \stackrel { = } { = } \mathcal { D } ^ { ( \ell ) }$ for all $k , \ell \in [ K ]$ then we have $\zeta = 0$ .
+
+Next, we define the $\epsilon$ -stationary solution for non-convex optimization problems, as well as quantify the computation and communication complexities to achieve an $\epsilon$ -stationary point.
+
+Definition 2.1 $\epsilon$ -Stationary Point). A point $x$ is called $\epsilon$ -stationary if $\| \nabla f ( x ) \| ^ { 2 } \leq \epsilon$ . Moreover, a stochastic algorithm is said to achieve an $\epsilon$ -stationary point in $t$ iterations if $\begin{array} { r } { \ddot { \mathbb { E } } [ \| \nabla f ( x _ { t } ) \| ^ { 2 } ] \le \epsilon . } \end{array}$ where the expectation is over the stochasticity of the algorithm until time instant $t$ .
+
+Definition 2.2 (Sample complexity). We assume an Incremental First-order Oracle (IFO) framework $\pmb { \Vert 3 4 \Vert }$ where, given a sample $\xi ^ { ( k ) } \sim \mathcal { D } ^ { ( k ) }$ at the $k ^ { \mathrm { { t h } } }$ node and iterate $x$ , the oracle returns $( f ^ { ( k ) } ( x ; \xi ^ { ( k ) } ) , \nabla f ^ { ( k ) } ( x ; \xi ^ { ( k ) } ) )$ . Each access to the oracle is counted as a single IFO operation. We measure the sample (and computational) complexity in terms of the total number of calls to the IFO by all WNs to achieve an $\epsilon$ -stationary point given in Definition 2.1.
+
+Definition 2.3 (Communication complexity). We define a communication round as a one back-andforth sharing of parameters between the WNs and the SN. Then the communication complexity is defined to be the total number of communication rounds between any WN and the SN required to achieve an $\epsilon$ -stationary point given in Definition 2.1.
+
+# 3 The STEM algorithm and the trade-off analysis
+
+In this section, we discuss the proposed algorithm and present the main results. The key in the algorithm design is to carefully balance all the four design elements mentioned in Sec. $^ { 1 , }$ so that sufficient and useful progress can be made between two rounds of communication.
+
+Let us discuss the key steps of STEM, listed in Algorithm $\nsupseteq$ In Step 10, each node locally updates its model parameters using the local direction $d _ { t } ^ { k }$ , computed by using $b$ stochastic gradients at two
+
+1: Input: Parameters: $c > 0$ , the number of local updates $I$ , batch size $b$ , stepsizes $\{ \eta _ { t } \}$ .   
+2: Initialize: Iterate $\begin{array} { r } { x _ { 1 } ^ { ( k ) } = \bar { x } _ { 1 } = \frac { 1 } { K } \sum _ { k = 1 } ^ { K } x _ { 1 } ^ { ( k ) } } \end{array}$ , descent direction $\begin{array} { r } { d _ { 1 } ^ { ( k ) } = \bar { d } _ { 1 } = \frac { 1 } { K } \sum _ { k = 1 } ^ { K } d _ { 1 } ^ { ( k ) } } \end{array}$   
+with $\begin{array} { r } { d _ { 1 } ^ { ( k ) } = \frac { 1 } { B } \sum _ { \xi _ { 1 } ^ { ( k ) } \in \mathcal { B } _ { 1 } ^ { ( k ) } } \nabla f ^ { ( k ) } ( x _ { 1 } ^ { ( k ) } ; \xi _ { 1 } ^ { ( k ) } ) } \end{array}$ and $| B _ { 1 } ^ { ( k ) } | = B$ for $k \in [ K ]$ .   
+3: Perform: $x _ { 2 } ^ { ( k ) } = x _ { 1 } ^ { k } - \eta _ { 1 } d _ { 1 } ^ { ( k ) }$ , $\forall k \in [ K ]$   
+4: for $t = 1$ to $T$ do   
+5: for $k = 1$ to $K$ do #at the WN   
+6: $\mathcal { d } _ { t + 1 } ^ { ( k ) } = \frac { 1 } { b } \sum _ { \xi _ { t + 1 } ^ { ( k ) } \in \mathcal { B } _ { t + 1 } ^ { ( k ) } } ^ { \pi \Delta } \nabla f ^ { ( k ) } ( x _ { t + 1 } ^ { ( k ) } ; \xi _ { t + 1 } ^ { ( k ) } ) + \left( 1 - a _ { t + 1 } \right) \bigg ( d _ { t } ^ { ( k ) } - \frac { 1 } { b } \sum _ { \xi _ { t + 1 } ^ { ( k ) } \in \mathcal { B } _ { t + 1 } ^ { ( k ) } } \nabla f ^ { ( k ) } ( x _ { t } ^ { ( k ) } ; \xi _ { t + 1 } ^ { ( k ) } ) \bigg )$   
+where we choose $| B _ { t + 1 } ^ { ( k ) } | = b$ , and $a _ { t + 1 } = c \cdot \eta _ { t } ^ { 2 }$ ;   
+7: 8: if $t$ $I = 0$ #at the SN   
+$\begin{array} { r } { d _ { t + 1 } ^ { ( k ) } = \bar { d } _ { t + 1 } : = \frac { 1 } { K } \sum _ { k = 1 } ^ { K } d _ { t + 1 } ^ { ( k ) } } \end{array}$   
+9: 10: e $\begin{array} { r l } & { x _ { t + 2 } ^ { ( k ) ^ { \bot } } : = \bar { x } _ { t + 1 } - \eta _ { t + 1 } \bar { d } _ { t + 1 } = \frac { 1 } { K } \sum _ { k = 1 } ^ { K } x _ { t + 1 } ^ { ( k ) } - \eta _ { t + 1 } \bar { d } _ { t + 1 } } \end{array}$ $x _ { t + 2 } ^ { ( k ) } = x _ { t + 1 } ^ { ( k ) } - \eta _ { t + 1 } d _ { t + 1 } ^ { ( k ) }$ #server-side momentum   
+11: end if   
+12: end for   
+13: end for   
+14: Return: $\scriptstyle { \bar { x } } _ { a }$ where $a \sim \mathcal { U } \{ 1 , . . . , T \}$ .
+
+consecutive iterates $x _ { t + 1 } ^ { ( k ) }$ and $x _ { t } ^ { ( k ) }$ . After every $I$ local steps, the WNs share their current local models $\{ x _ { t + 1 } ^ { ( k ) } \} _ { k = 1 } ^ { K }$ and directions $\{ d _ { t + 1 } ^ { ( k ) } \} _ { k = 1 } ^ { K }$ with the SN. The SN aggregates these quantities, and performs a server-side momentum step, before returning $\bar { x } _ { t + 1 }$ and $\bar { d } _ { t + 1 }$ to all the WNs. Because both the WNs and the SN perform momentum based updates, we call the algorithm a stochastic two-sided momentum algorithm. The key parameters are: $b$ the minibatch size, $I$ the local update steps between two communication rounds, $\eta _ { t }$ the stepsizes, and $a _ { t }$ the momentum parameters.
+
+One key technical innovation of our algorithm design is to identify the most suitable way to incorporate momentum based directions in FL algorithms. Although the momentum-based gradient estimator itself is not new and has been used in the literature before (see e.g., in $\mathbb { \left[ \bigstar \bigstar \right] }$ and $\lVert \overline { { 1 7 } } \rVert \overline { { 1 8 } } \rVert$ to improve the sample complexities of centralized and decentralized stochastic optimization problems, respectively), it is by no means clear if and how it can contribute to improve the communication complexity of FL algorithms. We show that in the FL setting, the local directions together with the local models have to be aggregated by the SN so to avoid being influenced too much by the local data. More importantly, besides the WNs, the SN also needs to perform updates using the (aggregated) momentum directions. Finally, such two-sided momentum updates have to be done carefully with the correct choice of minibatch size $b$ , and the number of local updates $I$ . Overall, it is the judicious choice of all these design elements that results in the optimal sample and communication complexities.
+
+Next, we present the convergence guarantees of the STEM algorithm.
+
+# 3.1 Main results: convergence guarantees for STEM
+
+In this section, we analyze the performance of STEM. We first present our main result, and then provide discussions about a few parameter choices. In the next subsection, we discuss a special case of STEM related to the classical FedAvg and minibatch SGD algorithms.
+
+Theorem 3.1. Under the Assumptions 1 and 2, suppose the stepsize sequence is chosen as:
+
+$$
+\eta _ { t } = \frac { \bar { \kappa } } { ( w _ { t } + \sigma ^ { 2 } t ) ^ { 1 / 3 } } ,
+$$
+
+where we define :
+
+$$
+\bar { \kappa } = \frac { ( b K ) ^ { 2 / 3 } \sigma ^ { 2 / 3 } } { L } , \quad w _ { t } = \operatorname * { m a x } \bigg \{ 2 \sigma ^ { 2 } , 4 0 9 6 L ^ { 3 } I ^ { 3 } \bar { \kappa } ^ { 3 } - \sigma ^ { 2 } t , \frac { c ^ { 3 } \bar { \kappa } ^ { 3 } } { 4 0 9 6 L ^ { 3 } I ^ { 3 } } \bigg \} .
+$$
+
+Further, let us set $\begin{array} { r } { c = \frac { 6 4 L ^ { 2 } } { b K } + \frac { \sigma ^ { 2 } } { 2 4 \bar { \kappa } ^ { 3 } L I } = L ^ { 2 } \bigg ( \frac { 6 4 } { b K } + \frac { 1 } { 2 4 ( b K ) ^ { 2 } I } \bigg ) } \end{array}$ and set the initial batch size as $B = b I$ ; set the local updates $I$ and minibatch size b as follows:
+
+$$
+I = \mathcal { O } \big ( ( T / K ^ { 2 } ) ^ { \nu / 3 } \big ) , \quad b = \mathcal { O } \big ( ( T / K ^ { 2 } ) ^ { 1 / 2 - \nu / 2 } \big )
+$$
+
+where $\nu$ satisfies $\nu \in [ 0 , 1 ]$ . Then for STEM the following holds:
+
+(i) For $\scriptstyle { \bar { x } } _ { a }$ chosen according to Algorithm $\perp$ we have:
+
+$$
+\mathbb { E } \Vert \nabla f ( \bar { x } _ { a } ) \Vert ^ { 2 } = \mathcal { O } \Bigg ( \frac { f ( \bar { x } _ { 1 } ) - f ^ { * } } { K ^ { 2 \nu / 3 } T ^ { 1 - \nu / 3 } } \Bigg ) + \tilde { \mathcal { O } } \Bigg ( \frac { \sigma ^ { 2 } } { K ^ { 2 \nu / 3 } T ^ { 1 - \nu / 3 } } \Bigg ) + \tilde { \mathcal { O } } \Bigg ( \frac { \zeta ^ { 2 } } { K ^ { 2 \nu / 3 } T ^ { 1 - \nu / 3 } } \Bigg ) .
+$$
+
+(ii) For any $\nu \in [ 0 , 1 ]$ , we have
+
+Sample Complexity: The sample complexity of STEM is $\tilde { \mathcal { O } } ( \epsilon ^ { - 3 / 2 } )$ . This implies that each WN requires at most $\tilde { \mathcal { O } } ( K ^ { - 1 } \epsilon ^ { - 3 / 2 } )$ gradient computations, thereby achieving linear speedup with the number of WNs present in the network.
+
+Communication Complexity: The communication complexity of STEM is $\tilde { \mathcal { O } } ( \epsilon ^ { - 1 } )$ .
+
+The proof of this result is relegated to the Supplemental Material. A few remarks are in order.
+
+Remark 1 (Near-Optimal sample and communication complexities). Theorem $3 . 1$ suggests that when $I$ and $b$ are selected appropriately, then STEM achieves $\tilde { \mathcal { O } } ( \epsilon ^ { - 3 / 2 } )$ and $\tilde { \mathcal { O } } ( \overline { { \epsilon ^ { - 1 } } } )$ sample and communication complexities. Taking them separately, these complexity bounds are the best achievable by the existing FL algorithms (upto logarithmic factors regardless of sample or batch Lipschitz smooth assumption) $[ [ 3 5 ] ]$ ; see Table $\bigstar \bigstar$ We note that the $\mathcal { O } ( \epsilon ^ { - 3 / 2 } )$ complexity is the best possible that can be achieved by centralized SGD with the sample Lipschitz gradient assumption; see $\pmb { \Vert 5 \Vert }$ . On the other hand, the $\bar { \mathcal { O } } ( \epsilon ^ { - 1 } )$ complexity bound is also likely to be the optimal, since in $\mathbb { P }$ the authors showed that even when the local steps use a class of (deterministic) first-order algorithms, $\mathcal { O } ( \epsilon ^ { - 1 } )$ is the best achievable communication complexity. The only difference is that $\pmb { \mathbb { Q } } \|$ does not explicitly assume the inter-node variance bound (i.e., the second relation in Assumption $2 \cdot$ -(ii)). We leave the precise characterization of the communication lower bound with inter-node variance as future work. □
+
+Remark 2 (Large Batch Sizes and/or Local Updates). At first glance, it may seem that the requirement of STEM to compute large mini-batches and/or local updates (cf. Table $^ { 1 ) }$ to achieve this (near) optimal performance is a drawback, however, we note that it is in fact an advantage of STEM that it allows the WNs to perform larger number of local updates (or compute large minibatches) without communicating often. This follows from the fact that irrespective of the number of local updates (or batch sizes) STEM achieves near-optimal communication complexity while attaining optimal overall sample complexity. Moreover, note that even with $b = I = \mathcal { O } ( 1 )$ (i.e., $b$ and $I$ are chosen as constants), STEM achieves the same (optimal) sample and communication complexities as achieved by FedGLOMO [18] and MIME [17]. We further note that to the best of our knowledge the algorithms that achieve the communication complexity of $\mathcal { O } ( \epsilon ^ { - 1 } )$ either require the number of local updates or the batch-sizes that depend on the solution accuracy $\epsilon$ . For example, FedProx $\mathbb { \ m }$ , FedPD $\pmb { \mathbb { Q } } \mathbf { \| }$ , and FedDyn $\textcircled { \lvert 3 6 \rvert }$ rely on solving the “local problems" to achieve an $\epsilon$ -accuracy, which implies that the number of local updates (or the batch sizes) implicitly depends on the desired solution accuracy $\epsilon$ , as is the case for STEM. Similarly, as shown in $\bar { \lVert 1 2 \rVert }$ and $\bar { \lVert 1 4 \rVert }$ the communication complexity of FedAvg and its momentum version can be improved from $\mathcal { O } ( \epsilon ^ { - 2 } )$ to $\mathcal { O } ( \epsilon ^ { - 3 / 2 } )$ when the number of local updates (or batch size) is chosen as $\mathcal { O } ( \epsilon ^ { - 1 / 2 } )$ (cf. Section $\boxed { 3 . 2 }$ for a more detailed discussion).
+
+Remark 3 (The Optimal Batch Sizes and Local Updates Trade-off). The parameter $\nu \in [ 0 , 1 ]$ is used to balance the local minibatch sizes $b$ , and the number of local updates $I$ . Eqs. in $( 3 )$ suggest that when $\nu$ increases from 0 to 1, $b$ decreases and $I$ increases. Specifically, if $\nu = 1$ , then $b$ is a constant but $I = \mathcal { O } ( T ^ { 1 / 3 } / K ^ { 2 / 3 } )$ . In this case, each WN chooses a small minibatch while executing multiple local updates, and STEM resembles a FedAvg (a.k.a. Local SGD) algorithm but with double-sided momentum update directions, and is referred to as Fed STEM. In contrast, if $\nu = 0$ , then $b = \mathcal { O } ( T ^ { 1 / 2 } / K )$ but $I$ is a constant. In this case, each WN chooses a large batch size while executing only a few, or even one, local updates, and STEM resembles the Minibatch SGD, but again with different update directions, and is referred to as Minibatch STEM. Such a trade-off can be seen in Fig. 1b. Due to space limitation, these two special cases will be precisely stated in the supplementary materials as corollaries of Theorem 3.1. □
+
+# Algorithm 2 The FedAvg Algorithm
+
+1: Input: $\{ \eta _ { t } \} _ { t = 0 } ^ { T } ; I$ , the # of local updates per communication round; $b$ , the minibatch sizes.   
+2: for $t = 1$ to $T$ do   
+3: 4: 5: for $\begin{array} { r l } & { \mathcal { \kappa } _ { t } ^ { = } \stackrel { \mathrm { ~ L ~ U ~ O ~ } \Lambda } { = } \mathbf { 0 } } \\ & { d _ { t } ^ { ( k ) } = \frac { 1 } { b } \sum _ { \xi _ { t } ^ { ( k ) } \in \mathcal { B } _ { t } ^ { ( k ) } } \nabla f ^ { ( k ) } ( x _ { t } ^ { ( k ) } ; \xi _ { t } ^ { ( k ) } ) \mathrm { ~ w i t h ~ } | \mathcal { B } _ { t } ^ { ( k ) } | = b } \\ & { x _ { t + 1 } ^ { ( k ) } = x _ { t } ^ { ( k ) } - \eta _ { t } d _ { t } ^ { ( k ) } } \\ & { \mathbf { i f } t \operatorname* { m o d } I = 0 \mathbf { \Lambda } \mathbf { t h e n } } \\ & { ~ x _ { t + 1 } ^ { ( k ) } = \bar { x } _ { t + 1 } = \frac { 1 } { K } \sum _ { k = 1 } ^ { K } x _ { t + 1 } ^ { ( k ) } } \\ & { \mathbf { e n d } \mathbf { \Phi } \mathbf { i f } } \end{array}$ $k = 1$ $K$   
+6:   
+7:   
+8:   
+9: end for   
+10: end for   
+11: Return: $\scriptstyle { \bar { x } } _ { a }$ where $a \sim \mathcal { U } \{ 1 , . . . , T \}$ .
+
+Remark 4 (The Sub-Optimal Batch Sizes and Local Updates Trade-off). From our proof (Theorem ${ \bf C . 1 0 }$ included in the supplemental material), we can see that STEM requires $\bar { \tilde { O } } ( \operatorname* { m a x } \big \{ ( b \cdot$ $I ) \epsilon ^ { - 1 } , K ^ { - 1 } \epsilon ^ { - 3 / 2 } \rbrace )$ samples and $\tilde { \mathcal { O } } \big ( \operatorname* { m a x } \big \{ \epsilon ^ { - 1 } , ( b \cdot I ) ^ { - 1 } K ^ { - 1 } \epsilon ^ { - 3 / 2 } \big \} \big )$  and communication rounds. According to the above expressions, if $b \cdot I$ increases beyond $\mathcal { O } ( K ^ { - 1 } \epsilon ^ { - 1 / 2 } )$ , then the sample complexity will increase from the optimal $\tilde { \mathcal { O } } ( \epsilon ^ { - 3 / 2 } )$ ; otherwise, the optimal sample complexity $\tilde { \mathcal O } ( \epsilon ^ { - 3 / 2 } )$ is maintained. On the other hand, if $b \cdot I$ decreases beyond $\mathcal { O } ( K ^ { - 1 } \epsilon ^ { - 1 / 2 } )$ , the communication complexity increases from $\tilde { \mathcal { O } } ( \epsilon ^ { - 1 } )$ . For instance, if we choose $b = \mathcal { O } ( 1 )$ and $I = { \mathcal { O } } ( 1 )$ the communication complexity becomes $\tilde { \mathcal { O } } ( \epsilon ^ { - 3 / 2 } )$ while the optimal sample complexity $\tilde { \mathcal { O } } ( \epsilon ^ { - 3 / 2 } )$ is maintained. This trade-off is illustrated in Figure $\boxed { 1 \mathrm { a } }$ where we maintain the optimal sample complexity, while changing $b$ and $I$ to generate the trade-off surface. □
+
+Remark 5 (Data Heterogeneity). The term $\begin{array} { r } { \tilde { \mathcal { O } } \biggl ( \frac { \zeta ^ { 2 } } { K ^ { 2 \nu / 3 } T ^ { 1 - \nu / 3 } } \biggr ) } \end{array}$ in the gradient bound $\textcircled{4}$ captures the effect of the heterogeneity of data across WNs, where $\zeta$ is the parameter characterizing the intra-node variance and has been defined in Assumption $\bigstar$ (ii). Highly heterogeneous data with large $\zeta ^ { 2 }$ can adversely impact the performance of STEM. Note that such a dependency on $\zeta$ also appears in other existing FL algorithms, such as $\boxed { 9 } \boxed { 1 4 } \boxed { 1 8 }$ . However, there is one special case of STEM that does not depend on the parameter $\zeta$ . This is the case where $I = 1$ , i.e., the minibatch SGD counterpart of STEM where only a single local iteration is performed between two communication rounds. We have the following corollary. □
+
+Corollary 1 (Minibatch STEM). Under Assumptions $\boldsymbol { I } a n d \boldsymbol { 2 }$ , and choose the algorithm parameters as in Theorem $\boxed { 3 . I }$ At each WN, choose $I = 1$ , $b = ( T / K ^ { 2 } ) ^ { 1 / 2 }$ , and the initial batch size $B = \boldsymbol { b } \cdot \boldsymbol { I }$ . Then STEM satisfies:
+
+(i) For $\bar { x } _ { a }$ chosen according to Algorithm $\perp$ we have
+
+$$
+\mathbb { E } \| \nabla f ( \bar { x } _ { a } ) \| ^ { 2 } = \mathcal { O } \Big ( \frac { f ( \bar { x } _ { 1 } ) - f ^ { * } } { T } \Big ) + \tilde { \mathcal { O } } \Big ( \frac { \sigma ^ { 2 } } { T } \Big ) .
+$$
+
+(ii) Minibatch STEM achieves $\tilde { \mathcal O } ( \epsilon ^ { - 3 / 2 } )$ sample and $\tilde { \mathcal { O } } ( \epsilon ^ { - 1 } )$ communication complexity.
+
+Next, we show that FedAvg also exhibits a trade-off similar to that of STEM but with worse sample and communication complexities.
+
+# 3.2 Special cases: The FedAvg algorithm
+
+We briefly discuss another interesting special case of STEM, where the local momentum update is replaced by the conventional SGD (i.e., $a _ { t } = 1 , ~ \forall ~ t )$ , while the server does not perform the momentum update (i.e., $\bar { d } _ { t } = 0 , \forall t )$ . This is essentially the classical FedAvg algorithm, just that it balances the number of local updates $I$ and the minibatch size $b$ . We show that this algorithm also exhibits a trade-off between $b$ and $I$ and on the trade-off curve it achieves $\mathcal { O } ( \epsilon ^ { - 2 } )$ sample complexity and $\mathcal { O } ( \epsilon ^ { - 3 / 2 } )$ communication complexity.
+
+<table><tr><td>Algorithm</td><td> Training Acc.</td><td>Testing Acc.</td></tr><tr><td>FedAvg</td><td>78.2</td><td>74.1</td></tr><tr><td>FedProx</td><td>79.2</td><td>74.8</td></tr><tr><td>FedDyn</td><td>68.9</td><td>66.0</td></tr><tr><td>SCAFFOLD</td><td>71.9</td><td>74.0</td></tr><tr><td>MIME</td><td>82.6</td><td>76.8</td></tr><tr><td>FedGLOMO</td><td>76.1</td><td>72.8</td></tr><tr><td> STEM</td><td>80.1</td><td>78.8</td></tr></table>
+
+(a) Mild heterogeneity, $b = 6 4$ , and $I = 7$ .
+
+<table><tr><td>Algorithm</td><td>Training Acc.</td><td>Testing Acc.</td></tr><tr><td>FedAvg</td><td>73.6</td><td>75.4</td></tr><tr><td>FedProx</td><td>80.0</td><td>75.2</td></tr><tr><td>FedDyn</td><td>76.1</td><td>71.3</td></tr><tr><td>SCAFFOLD</td><td>72.5</td><td>73.7</td></tr><tr><td>MIME</td><td>61.5</td><td>58.6</td></tr><tr><td>FedGLOMO</td><td>10.0</td><td>10.0</td></tr><tr><td>STEM</td><td>81.1</td><td>78.5</td></tr></table>
+
+(b) Moderate heterogeneity, $b = 8$ , and $I = 6 1$
+
+Table 2: Training and testing accuracy of different algorithms on CIFAR-10 dataset for different batch-sizes, number of local updates, and heteregeneity settings.
+
+Theorem 3.2 (The FedAvg Algorithm). Under Assumptions 1 and 2, suppose the stepsize is chosen as: $\begin{array} { r } { \eta = \sqrt { \frac { b K } { T } } } \end{array}$ ; Let us set:
+
+$$
+I = \mathcal { O } \big ( ( T / K ^ { 3 } ) ^ { \nu / 4 } \big ) , \quad b = \mathcal { O } \big ( ( T / K ^ { 3 } ) ^ { 1 / 3 - \nu / 3 } \big )
+$$
+
+where $\nu \in [ 0 , 1 ]$ is a constant. Then for FedAvg with $T \geq 8 1 L ^ { 2 } I ^ { 2 } b K$ , the following holds
+
+(i) For $\scriptstyle { \bar { x } } _ { a }$ chosen according to Algorithm $2 ,$ we have
+
+$$
+\mathbb { E } \Vert \nabla f ( \bar { x } _ { a } ) \Vert ^ { 2 } = \mathcal { O } \Bigg ( \frac { f ( \bar { x } _ { 1 } ) - f ^ { * } } { K ^ { \nu / 2 } T ^ { 2 / 3 - \nu / 6 } } \Bigg ) + \mathcal { O } \Bigg ( \frac { \sigma ^ { 2 } } { K ^ { \nu / 2 } T ^ { 2 / 3 - \nu / 6 } } \Bigg ) + \mathcal { O } \Bigg ( \frac { \zeta ^ { 2 } } { K ^ { \nu / 2 } T ^ { 2 / 3 - \nu / 6 } } \Bigg ) .
+$$
+
+(ii) For any choice of $\nu \in [ 0 , 1 ]$ we have:
+
+Sample Complexity: The sample complexity of FedAvg is $\mathcal { O } ( \epsilon ^ { - 2 } )$ . This implies that each WN requires at most $\tilde { \mathcal { O } } ( K ^ { - 1 } \epsilon ^ { - 2 } )$ gradient computations, thereby achieving linear speedup with the number of WNs in the network.
+
+Communication Complexity: The communication complexity of FedAvg is $\mathcal { O } ( \epsilon ^ { - 3 / 2 } )$ .
+
+Note that the requirement on $T$ being lower bounded is only relevant for theoretical purposes, a similar requirement was also imposed in $[ \mathbb { 1 4 } ]$ to prove convergence. Again, the parameter $\nu \in [ 0 , 1 ]$ in the statement of Theorem $\boxed { 3 . 2 }$ balances $I$ and $b$ at each WN while maintaining state-of-the-art sample and communication complexities; please see Table $\bigstar$ for a comparison of those bounds with existing FedAvg bounds. For $\nu = 1$ , FedAvg (cf. Theorem $3 . 2 )$ reduces to FedAvg proposed in [12, 14] and for $\nu = 0$ , the algorithm can be viewed as a large batch FedAvg with constant local updates [15, 16]. Note that similar to STEM, it is known that for $I = 1$ , the Minibatch SGD’s performance is independent of the heterogeneity parameter, $\zeta \equiv \mathbb { I I } 3 \mathbb { I }$ . We also point out that if Algorithm $\perp$ uses Nesterov’s or Polyak’s momentum $[ \textcircled { 1 4 } ]$ at local WNs instead of the recursive momentum estimator we get the same guarantees as in Theorem $\underline { { \boldsymbol { \vert 3 . 2 \vert } } }$
+
+In summary, this section established that once the WN’s and the SN’s update directions (SGD in FedAvg and momentum based directions in STEM) are fixed, there exists a sequence of optimal choices of the number of local updates $I$ , and the batch sizes $b$ , which guarantees the best possible sample and communication complexities for the particular algorithm. The trade-off analysis presented in this section provides some useful guidelines for how to best select $b$ and $I$ in practice. Our subsequent numerical results will also verify that if $b$ or $I$ are not chosen judiciously, then the practical performance of the algorithms can degrade significantly.
+
+# 4 Numerical results
+
+In this section, we validate the proposed STEM algorithm and compare its performance with the de facto standard FedAvg [11], and the algorithms stated in Table $^ { 1 . }$ Note that instead of FedPD we include the performance comparison with FedDyn $\left[ \left[ 3 6 \right] \right]$ since they are known to be very closely related. The goal of our experiments are three-fold: (1) To show that STEM performs on par, if not better, compared to other algorithms in different heterogeneity settings, (2) there are multiple ways to reach the desired solution accuracy, one can either choose a large batch size and perform only a few local updates or select a smaller batch size and perform multiple local updates, and finally, (3) if the local updates and the batch sizes are not chosen appropriately, the WNs might need to perform excessive computations to achieve the desired solution accuracy, thereby slowing down convergence.
+
+Table 3: Training and testing accuracy on CIFAR-10 dataset for high heterogeneity, $b =$ 128 and $I = 6$ .   
+
+<table><tr><td>Algorithm</td><td>Training Acc.</td><td>Testing Acc.</td></tr><tr><td>FedAvg</td><td>57.6</td><td>57.1</td></tr><tr><td>FedProx</td><td>59.1</td><td>58.5</td></tr><tr><td>FedDyn</td><td>51.2</td><td>51.3</td></tr><tr><td>SCAFFOLD</td><td>53.1</td><td>54.7</td></tr><tr><td>MIME</td><td>56.1</td><td>55.1</td></tr><tr><td>FedGLOMO</td><td>56.8</td><td>56.1</td></tr><tr><td> STEM</td><td>58.5</td><td>57.4</td></tr></table>
+
+Table 4: Training and testing accuracy on Shakespeare dataset.   
+
+<table><tr><td>Algorithm</td><td>Training Acc.</td><td>Testing Acc.</td></tr><tr><td>FedAvg</td><td>40.1</td><td>39.2</td></tr><tr><td>FedProx</td><td>43.5</td><td>43.2</td></tr><tr><td>FedDyn</td><td>43.7</td><td>43.2</td></tr><tr><td>SCAFFOLD</td><td>40.3</td><td>41.3</td></tr><tr><td>MIME</td><td>32.1</td><td>32.1</td></tr><tr><td>FedGLOMO</td><td>40.3</td><td>40.1</td></tr><tr><td> STEM</td><td>44.5</td><td>43.8</td></tr></table>
+
+![](images/1a3649642909a08bbdd852d92b8ec00817216ffd484e8ea8263d27aa9fb977f4.jpg)  
+Figure 2: Training loss and the testing accuracy for classification on MNIST data set against the number of samples accessed at each WN for moderate heterogeneity setting with $b = 8$ .
+
+Data and Parameter Settings: We compare the algorithms for image classification tasks on CIFAR10 and MNIST data sets with 100 WNs, and for next character prediction task on Shakespeare dataset $\pmb { \Vert 3 7 } \Vert$ with 143 WNs in the network. For both CIFAR-10 and MNIST, each WN implements a two-hidden-layer convolutional neural network (CNN) architecture followed by three linear layers for CIFAR-10 and two for MNIST. For CIFAR-10 (and MNIST) datset, we consider three settings with mild, moderate and high heterogeneity. For all the three settings, the data is partitioned into disjoint sets among the WNs. In the mild heterogeneity setting, the WNs have access to partitioned data from all the classes. In the moderate (resp. high) heterogeneity setting the data is partitioned such that each WN can access data from only 5 (resp. 2) out of 10 classes. For CIFAR-10 (resp. MNIST), each WN has access to 490 (resp. 540) samples for training and 90 (resp. 80) samples for testing purposes.
+
+We also compare the performance of algorithms on a popular FL benchmarking dataset, Shakespeare dataset $\mathbb { B } \mathbb { Z }$ . For this task, we adopt the settings from $\dot { \left[ \left| 1 0 \right| \right] }$ and utilize a 2-Layer LSTM network with 100 hidden units and an 8-D embedding layer at each WN. Each WN has access to 3616 samples on average, and the samples are randomly split into an $80 \%$ training set and a $20 \%$ testing set. We randomly sample 10 nodes out of 143 for the training purpose. All the experiments are implemented on a single NVIDIA Quadro RTX 5000 GPU. More details are provided in appendix.
+
+For the proposed STEM algorithm, recall that the step-size is $\eta _ { t } = \bar { \kappa } / ( w _ { t } + \sigma ^ { 2 } t ) ^ { 1 / 3 }$ with momentum parameter defined as $a _ { t } = { c } \eta _ { t } ^ { 2 }$ . The step-size is used to update the iterates while the momentum parameter is used to construct the stochastic gradient estimate (cf. Algorithm 1 and Theorem $\boxed { 3 . 1 }$ . For the experiments, we set $w _ { t } = \sigma ^ { 2 } = 1$ and $c \doteq \bar { c } / \bar { \kappa } ^ { 2 }$ and tune for $\bar { \kappa } \in [ 1 0 ^ { - 1 } , 1 0 ^ { - 2 } ]$ for the CIFAR-10 dataset and for ${ \bar { \kappa } } \in \{ 1 0 ^ { 1 } , 1 0 ^ { 0 } , 1 0 ^ { - 1 } , 1 0 ^ { - 2 } \}$ for the Shakespeare dataset. For both the datasets we tune for $\bar { c }$ in the range [1, 10]. For FedProx $\mathbb { m }$ and FedDyn $\lVert \dot { \boldsymbol { 3 6 } } \rVert$ we choose the regularization constant to be 0.1. The momentum parameters for FedGLOMO $\pm \textcircled { 1 8 } \textcircled { 1 }$ and MIME $\mathbb { \ m }$ are set based on the choices given in the respective papers. Specifically, for FedGLOMO we choose the parameter $\beta _ { k } = 0 . 2$ and design the momentum gradient using a damping factor given in Appendix A.4 of FedGLOMO $\mathbb { \left[ \left[ 8 \right] \right] }$ . Moreover, for MIME we choose the momentum parameter as 0.9. For the rest of the algorithms (including FedAvg and SCAFFOLD), the step-size is tuned from the set $\{ 1 0 ^ { 1 } , 1 0 ^ { 0 } , 1 0 ^ { - 1 } , \hat { 1 0 } ^ { - 2 } \}$ .
+
+Discussion: We evaluate the training and testing performance of STEM against multiple algorithms for different heterogeneity settings, minibatch sizes, and number of local updates. In Tables $\bigstar$ $\boxed { 2 \mathbf { b } }$ and $\bigstar ,$ we compare the training and testing accuracy of STEM to that of other algorithms on the CIFAR-10 dataset. Specific, heterogeneity settings, the choices of minibatches, and number of local updates are stated along with the tables. Note that STEM performs uniformly well under all the conditions. Moreover, note from Table $2  { \mathbf { b } }$ that FedGLOMO diverges once the number of local updates are high. Also, note from Table $\textcircled { 3 }$ that FedProx and STEM adapt well to high heterogeneity. Finally, with the next set of experiments we emphasize the importance of choosing $b$ and $I$ carefully. In Figure $\bigstar ,$ we compare the training and testing performance of STEM, FedAvg and SCAFFOLD, against the number of samples accessed at each WN for the classification task on MNIST dataset with moderate heterogeneity. We fix $b = 8$ and conduct experiments under two settings, one with $I = 6 7$ , and the other with $I = 5 3 6$ local updates at each WN. Note that although a large number of local updates might lead to fewer communication rounds but it can make the sample complexity extremely high as is demonstrated by Figure $2 .$ For example, Figure $\bigtriangledown$ shows that to reach testing accuracy of $9 6 - 9 7 \%$ with $I = 6 7$ , STEM requires approximately $\overline { { 5 0 } } 0 0 - 6 0 0 0$ samples, in contrast with $I = 5 3 6$ it requires more than 25000 samples at each WN. Similar behavior can be observed if we fix $I > 1$ and increase the local batch sizes. This implies not choosing the local updates and the batch sizes judiciously might lead to increased sample complexity. Additional experiments are included in the supplementary material to further evaluate the performance of the proposed algorithms.
+
+# Conclusion
+
+In this work, we proposed a novel algorithm STEM, for distributed stochastic non-convex optimization with applications to FL. We showed that STEM reaches an $\epsilon$ -stationary point with $\tilde { \mathcal O } ( \epsilon ^ { - 3 / 2 } )$ sample complexity while achieving linear speed-up with the number of WNs. Moreover, the algorithm achieves a communication complexity of $\tilde { \mathcal { O } } ( \epsilon ^ { - 1 } )$ . We established a (optimal) trade-off that allows interpolation between varying choices of local updates and the batch sizes at each WN while maintaining (near optimal) sample and communication complexities. We showed that FedAvg (a.k.a LocalSGD) also exhibits a similar trade-off while achieving worse complexities. Our results provide guidelines to carefully choose the number of local updates, update directions, and minibatch sizes to achieve the best performance. The future directions of this work include developing lower bounds on communication complexity that establishes the tightness of the analysis conducted in this work.
+
+# Acknowledgement
+
+We thank the anonymous reviewers for their valuable comments and suggestions. The work of Prashant Khanduri and Mingyi Hong was supported by NSF grant CMMI-1727757, AFOSR grant 19RT0424 and ARO grant W911NF-19-1-0247. The work of Mingyi Hong was also supported by an IBM Faculty Research award. The work of Jia Liu has been supported in part by NSF grants CAREER CNS-2110259, CNS-2112471, CNS-2102233, CCF-2110252, ECCS-2140277, and a Google Faculty Research Award.
+
+References   
+[1] J. Konecnˇ y, H. B. McMahan, D. Ramage, and P. Richtárik, “Federated optimization: Distributed \` machine learning for on-device intelligence,” arXiv preprint arXiv:1610.02527, 2016.   
+[2] M. Li, D. G. Andersen, A. J. Smola, and K. Yu, “Communication efficient distributed machine learning with the parameter server,” in Advances in Neural Information Processing Systems 27, Z. Ghahramani, M. Welling, C. Cortes, N. D. Lawrence, and K. Q. Weinberger, Eds. Curran Associates, Inc., 2014, pp. 19–27.   
+[3] J. Dean, G. Corrado, R. Monga, K. Chen, M. Devin, M. Mao, M. Ranzato, A. Senior, P. Tucker, K. Yang et al., “Large scale distributed deep networks,” in Advances in neural information processing systems, 2012, pp. 1223–1231.   
+[4] T. Léauté and B. Faltings, “Protecting privacy through distributed computation in multi-agent decision making,” Journal of Artificial Intelligence Research, vol. 47, pp. 649–695, 2013.   
+[5] C. Fang, C. J. Li, Z. Lin, and T. Zhang, “Spider: Near-optimal non-convex optimization via stochastic path-integrated differential estimator,” in Advances in Neural Information Processing Systems, 2018, pp. 689–699.   
+[6] D. Zhou, P. Xu, and Q. Gu, “Stochastic nested variance reduction for nonconvex optimization,” arXiv preprint arXiv:1806.07811, 2018.   
+[7] A. Cutkosky and F. Orabona, “Momentum-based variance reduction in non-convex SGD,” in Advances in Neural Information Processing Systems 32. Curran Associates, Inc., 2019, pp. 15 236–15 245.   
+[8] Q. Tran-Dinh, N. H. Pham, D. T. Phan, and L. M. Nguyen, “Hybrid stochastic gradient descent algorithms for stochastic nonconvex optimization,” arXiv preprint arXiv:1905.05920, 2019.   
+[9] X. Zhang, M. Hong, S. Dhople, W. Yin, and Y. Liu, “Fedpd: A federated learning framework with adaptivity to non-iid data,” IEEE Transactions on Signal Processing, pp. 1–1, 2021.   
+[10] T. Li, A. K. Sahu, M. Zaheer, M. Sanjabi, A. Talwalkar, and V. Smith, “Federated optimization in heterogeneous networks,” arXiv preprint arXiv:1812.06127, 2018.   
+[11] B. McMahan, E. Moore, D. Ramage, S. Hampson, and B. A. y Arcas, “Communication-efficient learning of deep networks from decentralized data,” in Artificial Intelligence and Statistics. PMLR, 2017, pp. 1273–1282.   
+[12] H. Yu, S. Yang, and S. Zhu, “Parallel restarted sgd with faster convergence and less communication: Demystifying why model averaging works for deep learning,” in Proceedings of the AAAI Conference on Artificial Intelligence, vol. 33, no. 01, 2019, pp. 5693–5700.   
+[13] B. Woodworth, K. K. Patel, and N. Srebro, “Minibatch vs local sgd for heterogeneous distributed learning,” arXiv preprint arXiv:2006.04735, 2020.   
+[14] H. Yu, R. Jin, and S. Yang, “On the linear speedup analysis of communication efficient momentum sgd for distributed non-convex optimization,” in International Conference on Machine Learning. PMLR, 2019, pp. 7184–7193.   
+[15] S. P. Karimireddy, S. Kale, M. Mohri, S. Reddi, S. Stich, and A. T. Suresh, “Scaffold: Stochastic controlled averaging for federated learning,” in International Conference on Machine Learning. PMLR, 2020, pp. 5132–5143.   
+[16] H. Yang, M. Fang, and J. Liu, “Achieving linear speedup with partial worker participation in non-iid federated learning,” arXiv preprint arXiv:2101.11203, 2021.   
+[17] S. P. Karimireddy, M. Jaggi, S. Kale, M. Mohri, S. J. Reddi, S. U. Stich, and A. T. Suresh, “Mime: Mimicking centralized stochastic algorithms in federated learning,” arXiv preprint arXiv:2008.03606, 2020.   
+[18] R. Das, A. Hashemi, S. Sanghavi, and I. S. Dhillon, “Improved convergence rates for non-convex federated learning with compression,” arXiv preprint arXiv:2012.04061, 2020.   
+[19] B. Woodworth, K. K. Patel, S. U. Stich, Z. Dai, B. Bullins, H. B. McMahan, O. Shamir, and N. Srebro, “Is local sgd better than minibatch sgd?” arXiv preprint arXiv:2002.07839, 2020.   
+[20] H. Yu and R. Jin, “On the computation and communication complexity of parallel sgd with dynamic batch sizes for stochastic non-convex optimization,” in International Conference on Machine Learning. PMLR, 2019, pp. 7174–7183.   
+[21] J. Wang and G. Joshi, “Cooperative sgd: A unified framework for the design and analysis of local-update sgd algorithms,” Journal of Machine Learning Research, vol. 22, no. 213, pp. 1–50, 2021.   
+[22] A. Khaled, K. Mishchenko, and P. Richtárik, “Better communication complexity for local sgd,” arXiv, 2019.   
+[23] S. U. Stich, “Local sgd converges fast and communicates little,” arXiv preprint arXiv:1805.09767, 2018.   
+[24] T. Lin, S. U. Stich, K. K. Patel, and M. Jaggi, “Don’t use large mini-batches, use local sgd,” in International Conference on Learning Representations, 2020.   
+[25] F. Zhou and G. Cong, “On the convergence properties of a k-step averaging stochastic gradient descent algorithm for nonconvex optimization,” in Proceedings of the Twenty-Seventh International Joint Conference on Artificial Intelligence, IJCAI-18, 7 2018, pp. 3219–3227.   
+[26] F. Sattler, S. Wiedemann, K.-R. Müller, and W. Samek, “Robust and communication-efficient federated learning from non-iid data,” IEEE transactions on neural networks and learning systems, vol. 31, no. 9, pp. 3400–3413, 2019.   
+[27] Y. Zhao, M. Li, L. Lai, N. Suda, D. Civin, and V. Chandra, “Federated learning with non-iid data,” arXiv preprint arXiv:1806.00582, 2018.   
+[28] J. Wang, V. Tantia, N. Ballas, and M. Rabbat, “Slowmo: Improving communication-efficient distributed sgd with slow momentum,” arXiv preprint arXiv:1910.00643, 2019.   
+[29] X. Liang, S. Shen, J. Liu, Z. Pan, E. Chen, and Y. Cheng, “Variance reduced local sgd with lower communication complexity,” arXiv preprint arXiv:1912.12844, 2019.   
+[30] P. Sharma, P. Khanduri, S. Bulusu, K. Rajawat, and P. K. Varshney, “Parallel restarted SPIDER – communication efficient distributed nonconvex optimization with optimal computation complexity,” arXiv preprint arXiv:1912.06036, 2019.   
+[31] S. J. Reddi, S. Kale, and S. Kumar, “On the convergence of adam and beyond,” arXiv preprint arXiv:1904.09237, 2019.   
+[32] A. Koloskova, N. Loizou, S. Boreiri, M. Jaggi, and S. Stich, “A unified theory of decentralized sgd with changing topology and local updates,” in International Conference on Machine Learning. PMLR, 2020, pp. 5381–5393.   
+[33] R. Johnson and T. Zhang, “Accelerating stochastic gradient descent using predictive variance reduction,” in Advances in Neural Information Processing Systems 26. Curran Associates, Inc., 2013, pp. 315–323.   
+[34] L. Bottou, F. E. Curtis, and J. Nocedal, “Optimization methods for large-scale machine learning,” SIAM Review, vol. 60, no. 2, pp. 223–311, 2018.   
+[35] Y. Drori and O. Shamir, “The complexity of finding stationary points with stochastic gradient descent,” in International Conference on Machine Learning. PMLR, 2020, pp. 2658–2667.   
+[36] D. A. E. Acar, Y. Zhao, R. Matas, M. Mattina, P. Whatmough, and V. Saligrama, “Federated learning based on dynamic regularization,” in International Conference on Learning Representations, 2020.   
+[37] S. Caldas, S. M. K. Duddu, P. Wu, T. Li, J. Konecnˇ ý, H. B. McMahan, V. Smith, and A. Talwalkar, “Leaf: A benchmark for federated settings,” 2019.

parse/train/gEzN9bBbLt8/gEzN9bBbLt8_content_list.json

@@ -0,0 +1,1234 @@
+[
+    {
+        "type": "text",
+        "text": "STEM: A Stochastic Two-Sided Momentum Algorithm Achieving Near-Optimal Sample and Communication Complexities for Federated Learning ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            122,
+            823,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Prashant Khanduri University of Minnesota khand095@umn.edu ",
+        "bbox": [
+            269,
+            251,
+            429,
+            292
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Pranay Sharma Carnegie Mellon University pranaysh@andrew.cmu.edu ",
+        "bbox": [
+            529,
+            251,
+            730,
+            292
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Haibo Yang The Ohio State University yang.5952@buckeyemail.osu.edu ",
+        "bbox": [
+            186,
+            314,
+            436,
+            356
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Mingyi Hong⇤ University of Minnesota mhong@umn.edu ",
+        "bbox": [
+            455,
+            314,
+            617,
+            356
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Jia Liu The Ohio State University liu@ece.osu.edu ",
+        "bbox": [
+            637,
+            314,
+            812,
+            356
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Ketan Rajawat Indian Institute of Technology Kanpur ketan@iitk.ac.in ",
+        "bbox": [
+            253,
+            377,
+            508,
+            419
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Pramod K. Varshney Syracuse University varshney@syr.edu ",
+        "bbox": [
+            593,
+            377,
+            743,
+            420
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            455,
+            535,
+            472
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Federated Learning (FL) refers to the paradigm where multiple worker nodes (WNs) build a joint model by using local data. Despite extensive research, for a generic non-convex FL problem, it is not clear, how to choose the WNs’ and the server’s update directions, the minibatch sizes, and the number of local updates, so that the WNs use the minimum number of samples and communication rounds to achieve the desired solution. This work addresses the above question and considers a class of stochastic algorithms where the WNs perform a few local updates before communication. We show that when both the WN’s and the server’s directions are chosen based on certain stochastic momentum estimator, the algorithm requires $\\tilde { \\mathcal O } ( \\epsilon ^ { - 3 / 2 } )$ samples and $\\tilde { \\mathcal { O } } ( \\epsilon ^ { - 1 } )$ communication rounds to compute an $\\epsilon$ -stationary solution. To the best of our knowledge, this is the first FL algorithm that achieves such near-optimal sample and communication complexities simultaneously. Further, we show that there is a trade-off curve between the number of local updates and the minibatch sizes, on which the above sample and communication complexities can be maintained. Finally, we show that for the classical FedAvg (a.k.a. Local SGD, which is a momentum-less special case of the STEM), a similar trade-off curve exists, albeit with worse sample and communication complexities. Our insights on this trade-off provides guidelines for choosing the four important design elements for FL algorithms, the number of local updates, WNs’ and server’s update directions, and minibatch sizes to achieve the best performance. ",
+        "bbox": [
+            232,
+            486,
+            766,
+            765
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            790,
+            310,
+            808
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In Federated Learning (FL), multiple worker nodes (WNs) collaborate with the goal of learning a joint model, by only using local data. Therefore it has become popular for machine learning problems where datasets are massively distributed [1]. In FL, the data is often collected at or off-loaded to multiple WNs which in collaboration with a server node (SN) jointly aim to learn a centralized model [2, 3]. The local WNs share the computational load and since the data is local to each WN, FL also provides some level of data privacy $\\mathbb { H }$ . A classical distributed optimization problem that $K$ WNs aim to solve: ",
+        "bbox": [
+            174,
+            821,
+            823,
+            877
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/8b109c70673d05d4fb4863253d56729a5c2b37b6a73924b30a5e660d7b6d1078.jpg",
+        "image_caption": [
+            "Figure 1: The 3D surface in (a) plots the communication complexity of the proposed STEM for different minibatch sizes and number of local updates. The surface is generated such that each point represents STEM with a particular choice of $( b , I )$ , so that it requires $\\tilde { \\mathcal { O } } ( \\epsilon ^ { - 3 / 2 } )$ samples to achieve $\\epsilon$ -stationarity. Plot (b) shows the optimal trade off between the minibatch sizes and the number of local updates at each WN (i.e., achieving the lowest communication and sample complexities). Both plots are generated for an accuracy of $\\epsilon = 1 0 ^ { - 3 }$ and all the constants dependent on system parameters (variance of stochastic gradients, heterogeneity parameter, optimality gap, Lipschitz constants, etc.) are assumed to be 1. Fed STEM is a special case of STEM where $\\mathcal { O } ( 1 )$ minibatch is used; Minibatch STEM is a special case of STEM where $\\mathcal { O } ( 1 )$ local updates are used. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            92,
+            772,
+            261
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            398,
+            826,
+            440
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2805a58b3a852bb789307ddca3e7e2aea04c24beb34df4fd0d38807ed0628944.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { x \\in \\mathbb { R } ^ { d } } \\bigg \\{ f ( x ) : = \\frac { 1 } { K } \\sum _ { k = 1 } ^ { K } f ^ { ( k ) } ( x ) : = \\frac { 1 } { K } \\sum _ { k = 1 } ^ { K } \\mathbb { E } _ { \\xi ^ { ( k ) } \\sim \\mathcal { D } ^ { ( k ) } } \\big [ f ^ { ( k ) } ( x ; \\xi ^ { ( k ) } ) \\big ] \\bigg \\} .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            266,
+            444,
+            730,
+            488
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $f ^ { ( k ) } : \\mathbb { R } ^ { d }  \\mathbb { R }$ denotes the smooth (possibly non-convex) objective function and $\\xi ^ { ( k ) } \\sim \\mathcal { D } ^ { ( k ) }$ represents the sample/s drawn from distribution $\\mathcal { D } ^ { ( k ) }$ at the $k ^ { \\mathrm { { t h } } }$ WN with $k \\in [ K ]$ . When the distributions $\\mathcal { D } ^ { ( k ) }$ are different across the WNs, it is referred to as the heterogeneous data setting. ",
+        "bbox": [
+            174,
+            493,
+            825,
+            539
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The optimization performance of non-convex FL algorithms is typically measured by the total number of samples accessed (cf. Definition $\\boxed { 2 . 2 }$ and the total rounds of communication (cf. Definition $2 . 3 )$ required by each WN to achieve an $\\epsilon$ -stationary solution (cf. Definition $\\boxed { 2 . 1 }$ . To minimize the sample and the communication complexities, FL algorithms rely on the following four key design elements: (i) the WNs’ local model update directions, (ii) Minibatch size to compute each local direction, (iii) the number of local updates before WNs share their parameters, and (iv) the SN’s update direction. How to find effective FL algorithms by (optimally) designing these parameters has received significant research interest recently. ",
+        "bbox": [
+            173,
+            545,
+            825,
+            657
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Contributions. The main contributions of this work are listed below: ",
+        "bbox": [
+            174,
+            662,
+            629,
+            676
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1) We propose the Stochastic Two-Sided Momentum (STEM) algorithm, that utilizes certain momentum-assisted stochastic gradient directions for both the WNs and SN updates. We show that there exists an optimal trade off between the minibatch sizes and number of local updates, such that on the trade-off curve STEM requires $\\tilde { \\mathcal { O } } ( \\epsilon ^ { - 3 / 2 } ) ^ { 2 }$ samples and $\\tilde { \\mathcal { O } } ( \\epsilon ^ { - 1 } )$ communication rounds to reach an $\\epsilon$ -stationary solution; see Figure $\\bigstar$ for an illustration. These complexity results are the best achievable for first-order stochastic FL algorithms (under certain assumptions, cf. Assumption $\\bigstar \\bigstar$ ; see $\\pm \\boxed { 5 } \\boxed { 8 } \\parallel$ and $\\mathbb { B } \\mathbb { n o }$ , as well as Remark $\\checkmark$ of this paper for discussions regarding optimality. To the best of our knowledge, STEM is the first algorithm which – (i) simultaneously achieves the optimal sample and communication complexities for FL and (ii) can optimally trade off the minibatch sizes and the number of local updates. ",
+        "bbox": [
+            173,
+            683,
+            825,
+            824
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2) A momentum-less special case of our STEM result further reveals some interesting insights of the classical FedAvg algorithm (a.k.a. the Local SGD) [11–13]. Specifically, we show that for FedAvg, there also exists a trade-off between the minibatch sizes and the number of local updates, such that it requires $\\mathcal { O } ( \\epsilon ^ { - 2 } )$ samples and $\\mathcal { O } ( \\epsilon ^ { - 3 / 2 } )$ communication rounds to achieve an $\\epsilon$ -stationary solution. ",
+        "bbox": [
+            174,
+            830,
+            825,
+            887
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "table",
+        "img_path": "images/c128a8f8c828914de2ebd0394fe1679cfb1eb64efae4ae9cdf73ecbb43acff9d.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 1: Comparison of FedAvg and STEM with different FL algorithms for various choices of the minibatch sizes $( b )$ and the number of per node local updates between two rounds of communication $( I )$ . $^ \\circ \\nu \\in [ 0 , 1 ]$ trades off $^ { b }$ and $I$ ; $\\nu = 1$ (resp. $\\nu = 0$ ) uses multiple (resp. $\\mathcal { O } ( 1 ) .$ ) local updates and $\\mathcal { O } ( 1 )$ (resp. multiple) samples. Fed STEM and Minibatch STEM are two variants of the proposed STEM. ‡The data heterogeneity assumption is weaker than Assumption $2$ (please see $\\bigstar \\bigstar$ for details). †Requires bounded Hessian dissimilarity to model data heterogeneity across WNs. ⇤Guarantees for Minibatch STEM with $I = 1$ and SCAFFOLD are independent of the data heterogeneity. "
+        ],
+        "table_body": "<table><tr><td>Algorithm</td><td>Work</td><td>Sample</td><td>Comm.</td><td>Minibatch (b)</td><td>Local Updates (I) /round</td></tr><tr><td>FedAvg</td><td>国园 国国</td><td>0(€-2)</td><td>0(c-3/2) 0(c-2)</td><td>0(1) 0(1) 2(1-v)</td><td>0(c-1/2) 0(1) 3v</td></tr><tr><td>SCAFFOLD*</td><td>this work 国</td><td>0(c-2）</td><td>O(e-3/2) 0（c-2）</td><td>O(c 4-v) 0(1)</td><td>O(c−2（4-D)） 0(1)</td></tr><tr><td>FedPD/FedProx*</td><td>四/□</td><td>O(c-2）</td><td>0(e-1)</td><td>0(1)</td><td>0(e-1）</td></tr><tr><td>MIME†/FedGLOMO</td><td>/8</td><td>0(c-3/2)</td><td>O(€-3/2)</td><td>0(1)</td><td>0(1)</td></tr><tr><td>STEM Fed STEM Minibatch STEM*</td><td> this work</td><td>O(€-3/2)</td><td>O(e-1)</td><td>( 0(1) O(e-1/2)</td><td>O(∈−(3)) O(∈-1/2) 0(1)</td></tr></table>",
+        "bbox": [
+            173,
+            88,
+            830,
+            266
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Collectively, our insights on the trade-offs provide practical guidelines for choosing different design elements for FL algorithms. ",
+        "bbox": [
+            176,
+            405,
+            823,
+            433
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Related Works. FL algorithms were first proposed in the form of FedAvg [11], where the local update directions at each WN were chosen to be the SGD updates. Earlier works analyzed these algorithms in the homogeneous data setting [19–25], while many recent studies have focused on designing new algorithms to deal with heterogeneous data settings, as well as problems where the local loss functions are non-convex [9, 10, 12–16, 18, 26–32]. In $\\bar { \\mathbb { E } 2 } \\mathbb { I }$ , the authors showed that Parallel Restarted SGD (Local SGD or FedAvg [11]) achieves linear speed up while requiring $\\mathcal { O } ( \\epsilon ^ { - 2 } )$ samples and $\\mathcal { O } ( \\epsilon ^ { - 3 / 2 } )$ rounds of communication to reach an $\\epsilon$ -stationary solution. In $\\bar { \\textregistered }$ , a Momentum SGD was proposed, which achieved the same sample and communication complexities as Parallel Restarted SGD $\\mathbb { \\lVert 1 2 \\rVert }$ , without requiring that the second moments of the gradients be bounded. Further, it was shown that under the homogeneous data setting, the communication complexity can be improved to $\\mathcal { O } ( \\epsilon ^ { - 1 } )$ while maintaining the same sample complexity. The works in $\\boxed { 1 5 } \\boxed { 1 6 }$ conducted tighter analysis for FedAvg with partial WN participation with $\\mathcal { O } ( 1 )$ local updates and batch sizes. Their analysis showed that FedAvg’s sample and communication complexities are both $\\mathcal { O } ( \\epsilon ^ { - 2 } )$ . Additionally, SCAFFOLD was proposed in $\\bar { \\| 1 5 \\| }$ , which utilized variance reduction based local update directions $\\mathbb { \\lVert 3 3 \\rVert }$ to achieve the same sample and communication complexities as FedAvg. Similarly, VRL-SGD proposed in $\\left[ \\left[ 2 9 \\right] \\right]$ also utilized variance reduction and showed improved communication complexity of $\\mathcal { O } ( \\epsilon ^ { - 1 } )$ , while requiring the same computations as FedAvg. Importantly, both SCAFFOLD and VRL-SGD’s guarantees were independent of the data heterogeneity. The FedProx proposed in $\\mathbb { I O } ]$ used a penalty based method to improve the communication complexity of FedAvg (i.e., the Parallel Restarted and Momentum SGD [14, $\\mathbb { L } 2 \\mathbb { I }$ ) to $\\mathcal { O } ( \\epsilon ^ { - 1 } )$ . FedProx used a gradient similarity assumption to model data heterogeneity which can be stringent for many practical applications. This assumption was relaxed by FedPD proposed in $\\mathbb { \\left[ 9 \\right] }$ . ",
+        "bbox": [
+            173,
+            439,
+            825,
+            743
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Recently, the works [17, 18] proposed to utilize hybrid momentum gradient estimators [7, 8]. The MIME algorithm $\\mathbb { \\ m }$ matched the optimal sample complexity (under certain smoothness assumptions) of $\\mathcal { O } ( \\epsilon ^ { - 3 / 2 } )$ of the centralized non-convex stochastic optimization algorithms [5–8]. Similarly, Fed-GLOMO $[ \\overline { { 1 8 } } ]$ achieved the same sample complexity while employing compression to further reduce communication. Both MIME and Fed-GLOMO required $\\mathcal { O } ( \\epsilon ^ { - 3 / 2 } )$ communication rounds to achieve an $\\epsilon$ -stationary solution. Please see Table $\\bigtriangledown$ for a summary of the above discussion. ",
+        "bbox": [
+            174,
+            748,
+            825,
+            837
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The comparison of Local SGD (FedAvg) to Minibatch SGD for convex and strongly convex problems with homogeneous data setting was first conducted in $\\mathbb { \\underline { { \\ m } } }$ and later extended to heterogeneous setting in $\\mathbb { \\lVert \\rVert 3 \\rVert }$ . It was shown that Minibatch SGD almost always dominates the Local SGD. In contrast, it was shown in $\\pmb { \\Vert 2 4 \\Vert }$ that Local SGD dominates Minibatch SGD in terms of generalization performance. Although existing FL results are rich, but they are somehow ad hoc and there is a lack of principled understanding of the algorithms. We note that the proposed STEM algorithmic framework provides a theoretical framework that unifies all existing $\\mathrm { F L }$ results on sample and communication complexities. ",
+        "bbox": [
+            174,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            90,
+            825,
+            119
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Notations. The expected value of a random variable $X$ is denoted by $\\mathbb { E } [ X ]$ and its expectation conditioned on an Event $A$ is denoted as $\\mathbb { E } [ X | \\mathrm { E v e n t ~ } A ]$ . We denote by $\\mathbb { R }$ (and $\\mathbb { R } ^ { d }$ ) the real line (and the $d$ -dimensional Euclidean space). The set of natural numbers is denoted by $\\mathbb { N }$ . Given a positive integer $K \\in \\mathbb N$ , we denote $[ K ] \\triangleq \\{ 1 , 2 , \\dots , K \\}$ . Notation $\\| \\cdot \\|$ denotes the $\\ell _ { 2 }$ -norm and $\\langle \\cdot , \\cdot \\rangle$ the Euclidean inner product. For a discrete set $\\boldsymbol { B }$ , $| B |$ denotes the cardinality of the set. Uniform distribution over a discrete set $\\{ 1 , \\ldots , T \\}$ is denoted as ${ \\dot { \\mathcal { U } } } \\{ 1 , \\dots , T \\}$ . ",
+        "bbox": [
+            173,
+            126,
+            825,
+            213
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2 Preliminaries ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            231,
+            318,
+            248
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Before we proceed to the algorithms, we make the following assumptions about problem $( 1 )$ . ",
+        "bbox": [
+            171,
+            262,
+            782,
+            277
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Assumption 1 (Sample Gradient Lipschitz Smoothness). The stochastic functions $f ^ { ( k ) } ( \\cdot , \\xi ^ { ( k ) } )$ with $\\xi ^ { ( k ) } \\sim \\mathcal { D } ^ { ( k ) }$ for all $k \\in [ K ]$ , satisfy the mean squared smoothness property, i.e, we have ",
+        "bbox": [
+            171,
+            281,
+            823,
+            313
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a3cfe57005b8e58ae1bfc3b55d7cca26c0bbb487296b4468bd38bfdc42e09c0e.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathbb { E } \\| \\nabla f ^ { ( k ) } ( x ; \\xi ^ { ( k ) } ) - \\nabla f ^ { ( k ) } ( y ; \\xi ^ { ( k ) } ) \\| ^ { 2 } \\leq L ^ { 2 } \\| x - y \\| ^ { 2 } \\mathrm { ~ f o r ~ a l l ~ } x , y \\in \\mathbb { R } ^ { d } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            259,
+            318,
+            736,
+            338
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Assumption 2 (Unbiased gradient and Variance Bounds). (i) Unbiased Gradient. The stochastic gradients computed at each WN are unbiased ",
+        "bbox": [
+            176,
+            343,
+            823,
+            372
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f06c119c8d26c099d56bae28e2fa443fdee4af7121660da108f532b9c8355105.jpg",
+        "text": "$$\n\\mathbb { E } [ \\nabla f ^ { ( k ) } ( x ; \\xi ^ { ( k ) } ) ] = \\nabla f ^ { ( k ) } ( x ) , \\forall \\xi ^ { ( k ) } \\sim \\mathcal { D } ^ { ( k ) } , \\forall k \\in [ K ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            302,
+            377,
+            696,
+            396
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "(ii) Intra- and inter- node Variance Bound. The following bounds hold: ",
+        "bbox": [
+            171,
+            400,
+            638,
+            415
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b27d78c5e7a746fe9622599d0a5137acd7faea00d13d76004e33686cafb79bc5.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathbb { \\tilde { z } } \\| \\nabla f ^ { ( k ) } ( x ; \\xi ^ { ( k ) } ) - \\nabla f ^ { ( k ) } ( x ) \\| ^ { 2 } \\leq \\sigma ^ { 2 } , \\| \\nabla f ^ { ( k ) } ( x ) - \\nabla f ^ { ( \\ell ) } ( x ) \\| ^ { 2 } \\leq \\zeta ^ { 2 } , \\forall \\xi ^ { ( k ) } \\sim \\mathcal { D } ^ { ( k ) } , \\forall k , \\ell \\in [ K ] . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            420,
+            834,
+            441
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note that Assumption $^ 1$ is stronger than directly assuming $f ^ { ( k ) }$ ’s are Lipschitz smooth (which we will refer to as the averaged gradient Lipschitz smooth condition), but it is still a rather standard assumption in SGD analysis. For example it has been used in analyzing centralized SGD algorithms such as SPIDER $ { \\mathbb { I } }$ , SNVRG $\\pmb { \\Vert 6 \\Vert }$ , STORM $\\mathbb { [ [ \\big ] ] }$ (and many others) as well as in FL algorithms such as MIME $ { \\mathbb { I } } ^ { [ 1 2 ] }$ and Fed-GLOMO $\\pm \\textcircled { 1 8 } \\textcircled { 1 }$ . The second relation in Assumption $2 \\cdot$ (ii) quantifies the data heterogeneity, and we call $\\zeta > 0$ as the heterogeneity parameter. This is a typical assumption required to evaluate the performance of FL algorithms. If data distributions across individual WNs are identical, i.e., $\\mathcal { D } ^ { ( k ) } \\stackrel { = } { = } \\mathcal { D } ^ { ( \\ell ) }$ for all $k , \\ell \\in [ K ]$ then we have $\\zeta = 0$ . ",
+        "bbox": [
+            173,
+            453,
+            826,
+            569
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Next, we define the $\\epsilon$ -stationary solution for non-convex optimization problems, as well as quantify the computation and communication complexities to achieve an $\\epsilon$ -stationary point. ",
+        "bbox": [
+            174,
+            574,
+            821,
+            603
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Definition 2.1 $\\epsilon$ -Stationary Point). A point $x$ is called $\\epsilon$ -stationary if $\\| \\nabla f ( x ) \\| ^ { 2 } \\leq \\epsilon$ . Moreover, a stochastic algorithm is said to achieve an $\\epsilon$ -stationary point in $t$ iterations if $\\begin{array} { r } { \\ddot { \\mathbb { E } } [ \\| \\nabla f ( x _ { t } ) \\| ^ { 2 } ] \\le \\epsilon . } \\end{array}$ where the expectation is over the stochasticity of the algorithm until time instant $t$ . ",
+        "bbox": [
+            173,
+            606,
+            826,
+            648
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Definition 2.2 (Sample complexity). We assume an Incremental First-order Oracle (IFO) framework $\\pmb { \\Vert 3 4 \\Vert }$ where, given a sample $\\xi ^ { ( k ) } \\sim \\mathcal { D } ^ { ( k ) }$ at the $k ^ { \\mathrm { { t h } } }$ node and iterate $x$ , the oracle returns $( f ^ { ( k ) } ( x ; \\xi ^ { ( k ) } ) , \\nabla f ^ { ( k ) } ( x ; \\xi ^ { ( k ) } ) )$ . Each access to the oracle is counted as a single IFO operation. We measure the sample (and computational) complexity in terms of the total number of calls to the IFO by all WNs to achieve an $\\epsilon$ -stationary point given in Definition 2.1. ",
+        "bbox": [
+            173,
+            652,
+            825,
+            727
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Definition 2.3 (Communication complexity). We define a communication round as a one back-andforth sharing of parameters between the WNs and the SN. Then the communication complexity is defined to be the total number of communication rounds between any WN and the SN required to achieve an $\\epsilon$ -stationary point given in Definition 2.1. ",
+        "bbox": [
+            173,
+            728,
+            825,
+            786
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 The STEM algorithm and the trade-off analysis ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            803,
+            602,
+            821
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this section, we discuss the proposed algorithm and present the main results. The key in the algorithm design is to carefully balance all the four design elements mentioned in Sec. $^ { 1 , }$ so that sufficient and useful progress can be made between two rounds of communication. ",
+        "bbox": [
+            174,
+            835,
+            825,
+            877
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Let us discuss the key steps of STEM, listed in Algorithm $\\nsupseteq$ In Step 10, each node locally updates its model parameters using the local direction $d _ { t } ^ { k }$ , computed by using $b$ stochastic gradients at two ",
+        "bbox": [
+            173,
+            882,
+            821,
+            912
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "1: Input: Parameters: $c > 0$ , the number of local updates $I$ , batch size $b$ , stepsizes $\\{ \\eta _ { t } \\}$ .   \n2: Initialize: Iterate $\\begin{array} { r } { x _ { 1 } ^ { ( k ) } = \\bar { x } _ { 1 } = \\frac { 1 } { K } \\sum _ { k = 1 } ^ { K } x _ { 1 } ^ { ( k ) } } \\end{array}$ , descent direction $\\begin{array} { r } { d _ { 1 } ^ { ( k ) } = \\bar { d } _ { 1 } = \\frac { 1 } { K } \\sum _ { k = 1 } ^ { K } d _ { 1 } ^ { ( k ) } } \\end{array}$   \nwith $\\begin{array} { r } { d _ { 1 } ^ { ( k ) } = \\frac { 1 } { B } \\sum _ { \\xi _ { 1 } ^ { ( k ) } \\in \\mathcal { B } _ { 1 } ^ { ( k ) } } \\nabla f ^ { ( k ) } ( x _ { 1 } ^ { ( k ) } ; \\xi _ { 1 } ^ { ( k ) } ) } \\end{array}$ and $| B _ { 1 } ^ { ( k ) } | = B$ for $k \\in [ K ]$ .   \n3: Perform: $x _ { 2 } ^ { ( k ) } = x _ { 1 } ^ { k } - \\eta _ { 1 } d _ { 1 } ^ { ( k ) }$ , $\\forall k \\in [ K ]$   \n4: for $t = 1$ to $T$ do   \n5: for $k = 1$ to $K$ do #at the WN   \n6: $\\mathcal { d } _ { t + 1 } ^ { ( k ) } = \\frac { 1 } { b } \\sum _ { \\xi _ { t + 1 } ^ { ( k ) } \\in \\mathcal { B } _ { t + 1 } ^ { ( k ) } } ^ { \\pi \\Delta } \\nabla f ^ { ( k ) } ( x _ { t + 1 } ^ { ( k ) } ; \\xi _ { t + 1 } ^ { ( k ) } ) + \\left( 1 - a _ { t + 1 } \\right) \\bigg ( d _ { t } ^ { ( k ) } - \\frac { 1 } { b } \\sum _ { \\xi _ { t + 1 } ^ { ( k ) } \\in \\mathcal { B } _ { t + 1 } ^ { ( k ) } } \\nabla f ^ { ( k ) } ( x _ { t } ^ { ( k ) } ; \\xi _ { t + 1 } ^ { ( k ) } ) \\bigg )$   \nwhere we choose $| B _ { t + 1 } ^ { ( k ) } | = b$ , and $a _ { t + 1 } = c \\cdot \\eta _ { t } ^ { 2 }$ ;   \n7: 8: if $t$ $I = 0$ #at the SN   \n$\\begin{array} { r } { d _ { t + 1 } ^ { ( k ) } = \\bar { d } _ { t + 1 } : = \\frac { 1 } { K } \\sum _ { k = 1 } ^ { K } d _ { t + 1 } ^ { ( k ) } } \\end{array}$   \n9: 10: e $\\begin{array} { r l } & { x _ { t + 2 } ^ { ( k ) ^ { \\bot } } : = \\bar { x } _ { t + 1 } - \\eta _ { t + 1 } \\bar { d } _ { t + 1 } = \\frac { 1 } { K } \\sum _ { k = 1 } ^ { K } x _ { t + 1 } ^ { ( k ) } - \\eta _ { t + 1 } \\bar { d } _ { t + 1 } } \\end{array}$ $x _ { t + 2 } ^ { ( k ) } = x _ { t + 1 } ^ { ( k ) } - \\eta _ { t + 1 } d _ { t + 1 } ^ { ( k ) }$ #server-side momentum   \n11: end if   \n12: end for   \n13: end for   \n14: Return: $\\scriptstyle { \\bar { x } } _ { a }$ where $a \\sim \\mathcal { U } \\{ 1 , . . . , T \\}$ . ",
+        "bbox": [
+            178,
+            108,
+            826,
+            393
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "consecutive iterates $x _ { t + 1 } ^ { ( k ) }$ and $x _ { t } ^ { ( k ) }$ . After every $I$ local steps, the WNs share their current local models $\\{ x _ { t + 1 } ^ { ( k ) } \\} _ { k = 1 } ^ { K }$ and directions $\\{ d _ { t + 1 } ^ { ( k ) } \\} _ { k = 1 } ^ { K }$ with the SN. The SN aggregates these quantities, and performs a server-side momentum step, before returning $\\bar { x } _ { t + 1 }$ and $\\bar { d } _ { t + 1 }$ to all the WNs. Because both the WNs and the SN perform momentum based updates, we call the algorithm a stochastic two-sided momentum algorithm. The key parameters are: $b$ the minibatch size, $I$ the local update steps between two communication rounds, $\\eta _ { t }$ the stepsizes, and $a _ { t }$ the momentum parameters. ",
+        "bbox": [
+            173,
+            420,
+            825,
+            515
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "One key technical innovation of our algorithm design is to identify the most suitable way to incorporate momentum based directions in FL algorithms. Although the momentum-based gradient estimator itself is not new and has been used in the literature before (see e.g., in $\\mathbb { \\left[ \\bigstar \\bigstar \\right] }$ and $\\lVert \\overline { { 1 7 } } \\rVert \\overline { { 1 8 } } \\rVert$ to improve the sample complexities of centralized and decentralized stochastic optimization problems, respectively), it is by no means clear if and how it can contribute to improve the communication complexity of FL algorithms. We show that in the FL setting, the local directions together with the local models have to be aggregated by the SN so to avoid being influenced too much by the local data. More importantly, besides the WNs, the SN also needs to perform updates using the (aggregated) momentum directions. Finally, such two-sided momentum updates have to be done carefully with the correct choice of minibatch size $b$ , and the number of local updates $I$ . Overall, it is the judicious choice of all these design elements that results in the optimal sample and communication complexities. ",
+        "bbox": [
+            173,
+            520,
+            826,
+            672
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Next, we present the convergence guarantees of the STEM algorithm. ",
+        "bbox": [
+            174,
+            678,
+            630,
+            693
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1 Main results: convergence guarantees for STEM ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            712,
+            549,
+            727
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section, we analyze the performance of STEM. We first present our main result, and then provide discussions about a few parameter choices. In the next subsection, we discuss a special case of STEM related to the classical FedAvg and minibatch SGD algorithms. ",
+        "bbox": [
+            174,
+            738,
+            825,
+            781
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Theorem 3.1. Under the Assumptions 1 and 2, suppose the stepsize sequence is chosen as: ",
+        "bbox": [
+            168,
+            785,
+            769,
+            801
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c7b9d663b7230014554f849f65c327948834a1aadf2fddbf4fd4727068678b71.jpg",
+        "text": "$$\n\\eta _ { t } = \\frac { \\bar { \\kappa } } { ( w _ { t } + \\sigma ^ { 2 } t ) ^ { 1 / 3 } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            428,
+            809,
+            568,
+            842
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where we define : ",
+        "bbox": [
+            173,
+            851,
+            289,
+            864
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1ab3f1b7115347d40a7bc1f3343dd7707b65537827e4b8370ab97442863fcfd1.jpg",
+        "text": "$$\n\\bar { \\kappa } = \\frac { ( b K ) ^ { 2 / 3 } \\sigma ^ { 2 / 3 } } { L } , \\quad w _ { t } = \\operatorname * { m a x } \\bigg \\{ 2 \\sigma ^ { 2 } , 4 0 9 6 L ^ { 3 } I ^ { 3 } \\bar { \\kappa } ^ { 3 } - \\sigma ^ { 2 } t , \\frac { c ^ { 3 } \\bar { \\kappa } ^ { 3 } } { 4 0 9 6 L ^ { 3 } I ^ { 3 } } \\bigg \\} .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            253,
+            873,
+            738,
+            910
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Further, let us set $\\begin{array} { r } { c = \\frac { 6 4 L ^ { 2 } } { b K } + \\frac { \\sigma ^ { 2 } } { 2 4 \\bar { \\kappa } ^ { 3 } L I } = L ^ { 2 } \\bigg ( \\frac { 6 4 } { b K } + \\frac { 1 } { 2 4 ( b K ) ^ { 2 } I } \\bigg ) } \\end{array}$ and set the initial batch size as $B = b I$ ; set the local updates $I$ and minibatch size b as follows: ",
+        "bbox": [
+            173,
+            88,
+            825,
+            133
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/571cd8b7f6de9fecec247a32a77a5fc7ff44b9b1a1446281dd4865af343e8ec8.jpg",
+        "text": "$$\nI = \\mathcal { O } \\big ( ( T / K ^ { 2 } ) ^ { \\nu / 3 } \\big ) , \\quad b = \\mathcal { O } \\big ( ( T / K ^ { 2 } ) ^ { 1 / 2 - \\nu / 2 } \\big )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            336,
+            141,
+            660,
+            161
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\nu$ satisfies $\\nu \\in [ 0 , 1 ]$ . Then for STEM the following holds: ",
+        "bbox": [
+            173,
+            167,
+            607,
+            185
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "(i) For $\\scriptstyle { \\bar { x } } _ { a }$ chosen according to Algorithm $\\perp$ we have: ",
+        "bbox": [
+            176,
+            195,
+            532,
+            212
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e2c146df205c691e32ce24c2ee693fb97ea38edc895ba31bbeb511db58c5a452.jpg",
+        "text": "$$\n\\mathbb { E } \\Vert \\nabla f ( \\bar { x } _ { a } ) \\Vert ^ { 2 } = \\mathcal { O } \\Bigg ( \\frac { f ( \\bar { x } _ { 1 } ) - f ^ { * } } { K ^ { 2 \\nu / 3 } T ^ { 1 - \\nu / 3 } } \\Bigg ) + \\tilde { \\mathcal { O } } \\Bigg ( \\frac { \\sigma ^ { 2 } } { K ^ { 2 \\nu / 3 } T ^ { 1 - \\nu / 3 } } \\Bigg ) + \\tilde { \\mathcal { O } } \\Bigg ( \\frac { \\zeta ^ { 2 } } { K ^ { 2 \\nu / 3 } T ^ { 1 - \\nu / 3 } } \\Bigg ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            223,
+            218,
+            782,
+            253
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "(ii) For any $\\nu \\in [ 0 , 1 ]$ , we have ",
+        "bbox": [
+            173,
+            267,
+            382,
+            284
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Sample Complexity: The sample complexity of STEM is $\\tilde { \\mathcal { O } } ( \\epsilon ^ { - 3 / 2 } )$ . This implies that each WN requires at most $\\tilde { \\mathcal { O } } ( K ^ { - 1 } \\epsilon ^ { - 3 / 2 } )$ gradient computations, thereby achieving linear speedup with the number of WNs present in the network. ",
+        "bbox": [
+            176,
+            284,
+            825,
+            329
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Communication Complexity: The communication complexity of STEM is $\\tilde { \\mathcal { O } } ( \\epsilon ^ { - 1 } )$ . ",
+        "bbox": [
+            202,
+            329,
+            745,
+            344
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The proof of this result is relegated to the Supplemental Material. A few remarks are in order. ",
+        "bbox": [
+            174,
+            356,
+            785,
+            371
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Remark 1 (Near-Optimal sample and communication complexities). Theorem $3 . 1$ suggests that when $I$ and $b$ are selected appropriately, then STEM achieves $\\tilde { \\mathcal { O } } ( \\epsilon ^ { - 3 / 2 } )$ and $\\tilde { \\mathcal { O } } ( \\overline { { \\epsilon ^ { - 1 } } } )$ sample and communication complexities. Taking them separately, these complexity bounds are the best achievable by the existing FL algorithms (upto logarithmic factors regardless of sample or batch Lipschitz smooth assumption) $[ [ 3 5 ] ]$ ; see Table $\\bigstar \\bigstar$ We note that the $\\mathcal { O } ( \\epsilon ^ { - 3 / 2 } )$ complexity is the best possible that can be achieved by centralized SGD with the sample Lipschitz gradient assumption; see $\\pmb { \\Vert 5 \\Vert }$ . On the other hand, the $\\bar { \\mathcal { O } } ( \\epsilon ^ { - 1 } )$ complexity bound is also likely to be the optimal, since in $\\mathbb { P }$ the authors showed that even when the local steps use a class of (deterministic) first-order algorithms, $\\mathcal { O } ( \\epsilon ^ { - 1 } )$ is the best achievable communication complexity. The only difference is that $\\pmb { \\mathbb { Q } } \\|$ does not explicitly assume the inter-node variance bound (i.e., the second relation in Assumption $2 \\cdot$ -(ii)). We leave the precise characterization of the communication lower bound with inter-node variance as future work. □ ",
+        "bbox": [
+            173,
+            372,
+            825,
+            527
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Remark 2 (Large Batch Sizes and/or Local Updates). At first glance, it may seem that the requirement of STEM to compute large mini-batches and/or local updates (cf. Table $^ { 1 ) }$ to achieve this (near) optimal performance is a drawback, however, we note that it is in fact an advantage of STEM that it allows the WNs to perform larger number of local updates (or compute large minibatches) without communicating often. This follows from the fact that irrespective of the number of local updates (or batch sizes) STEM achieves near-optimal communication complexity while attaining optimal overall sample complexity. Moreover, note that even with $b = I = \\mathcal { O } ( 1 )$ (i.e., $b$ and $I$ are chosen as constants), STEM achieves the same (optimal) sample and communication complexities as achieved by FedGLOMO [18] and MIME [17]. We further note that to the best of our knowledge the algorithms that achieve the communication complexity of $\\mathcal { O } ( \\epsilon ^ { - 1 } )$ either require the number of local updates or the batch-sizes that depend on the solution accuracy $\\epsilon$ . For example, FedProx $\\mathbb { \\ m }$ , FedPD $\\pmb { \\mathbb { Q } } \\mathbf { \\| }$ , and FedDyn $\\textcircled { \\lvert 3 6 \\rvert }$ rely on solving the “local problems\" to achieve an $\\epsilon$ -accuracy, which implies that the number of local updates (or the batch sizes) implicitly depends on the desired solution accuracy $\\epsilon$ , as is the case for STEM. Similarly, as shown in $\\bar { \\lVert 1 2 \\rVert }$ and $\\bar { \\lVert 1 4 \\rVert }$ the communication complexity of FedAvg and its momentum version can be improved from $\\mathcal { O } ( \\epsilon ^ { - 2 } )$ to $\\mathcal { O } ( \\epsilon ^ { - 3 / 2 } )$ when the number of local updates (or batch size) is chosen as $\\mathcal { O } ( \\epsilon ^ { - 1 / 2 } )$ (cf. Section $\\boxed { 3 . 2 }$ for a more detailed discussion). ",
+        "bbox": [
+            173,
+            531,
+            825,
+            753
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Remark 3 (The Optimal Batch Sizes and Local Updates Trade-off). The parameter $\\nu \\in [ 0 , 1 ]$ is used to balance the local minibatch sizes $b$ , and the number of local updates $I$ . Eqs. in $( 3 )$ suggest that when $\\nu$ increases from 0 to 1, $b$ decreases and $I$ increases. Specifically, if $\\nu = 1$ , then $b$ is a constant but $I = \\mathcal { O } ( T ^ { 1 / 3 } / K ^ { 2 / 3 } )$ . In this case, each WN chooses a small minibatch while executing multiple local updates, and STEM resembles a FedAvg (a.k.a. Local SGD) algorithm but with double-sided momentum update directions, and is referred to as Fed STEM. In contrast, if $\\nu = 0$ , then $b = \\mathcal { O } ( T ^ { 1 / 2 } / K )$ but $I$ is a constant. In this case, each WN chooses a large batch size while executing only a few, or even one, local updates, and STEM resembles the Minibatch SGD, but again with different update directions, and is referred to as Minibatch STEM. Such a trade-off can be seen in Fig. 1b. Due to space limitation, these two special cases will be precisely stated in the supplementary materials as corollaries of Theorem 3.1. □ ",
+        "bbox": [
+            173,
+            756,
+            825,
+            912
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 2 The FedAvg Algorithm ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            90,
+            416,
+            106
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "1: Input: $\\{ \\eta _ { t } \\} _ { t = 0 } ^ { T } ; I$ , the # of local updates per communication round; $b$ , the minibatch sizes.   \n2: for $t = 1$ to $T$ do   \n3: 4: 5: for $\\begin{array} { r l } & { \\mathcal { \\kappa } _ { t } ^ { = } \\stackrel { \\mathrm { ~ L ~ U ~ O ~ } \\Lambda } { = } \\mathbf { 0 } } \\\\ & { d _ { t } ^ { ( k ) } = \\frac { 1 } { b } \\sum _ { \\xi _ { t } ^ { ( k ) } \\in \\mathcal { B } _ { t } ^ { ( k ) } } \\nabla f ^ { ( k ) } ( x _ { t } ^ { ( k ) } ; \\xi _ { t } ^ { ( k ) } ) \\mathrm { ~ w i t h ~ } | \\mathcal { B } _ { t } ^ { ( k ) } | = b } \\\\ & { x _ { t + 1 } ^ { ( k ) } = x _ { t } ^ { ( k ) } - \\eta _ { t } d _ { t } ^ { ( k ) } } \\\\ & { \\mathbf { i f } t \\operatorname* { m o d } I = 0 \\mathbf { \\Lambda } \\mathbf { t h e n } } \\\\ & { ~ x _ { t + 1 } ^ { ( k ) } = \\bar { x } _ { t + 1 } = \\frac { 1 } { K } \\sum _ { k = 1 } ^ { K } x _ { t + 1 } ^ { ( k ) } } \\\\ & { \\mathbf { e n d } \\mathbf { \\Phi } \\mathbf { i f } } \\end{array}$ $k = 1$ $K$   \n6:   \n7:   \n8:   \n9: end for   \n10: end for   \n11: Return: $\\scriptstyle { \\bar { x } } _ { a }$ where $a \\sim \\mathcal { U } \\{ 1 , . . . , T \\}$ . ",
+        "bbox": [
+            178,
+            111,
+            795,
+            276
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Remark 4 (The Sub-Optimal Batch Sizes and Local Updates Trade-off). From our proof (Theorem ${ \\bf C . 1 0 }$ included in the supplemental material), we can see that STEM requires $\\bar { \\tilde { O } } ( \\operatorname* { m a x } \\big \\{ ( b \\cdot$ $I ) \\epsilon ^ { - 1 } , K ^ { - 1 } \\epsilon ^ { - 3 / 2 } \\rbrace )$ samples and $\\tilde { \\mathcal { O } } \\big ( \\operatorname* { m a x } \\big \\{ \\epsilon ^ { - 1 } , ( b \\cdot I ) ^ { - 1 } K ^ { - 1 } \\epsilon ^ { - 3 / 2 } \\big \\} \\big )$ \u0000 and communication rounds. According to the above expressions, if $b \\cdot I$ increases beyond $\\mathcal { O } ( K ^ { - 1 } \\epsilon ^ { - 1 / 2 } )$ , then the sample complexity will increase from the optimal $\\tilde { \\mathcal { O } } ( \\epsilon ^ { - 3 / 2 } )$ ; otherwise, the optimal sample complexity $\\tilde { \\mathcal O } ( \\epsilon ^ { - 3 / 2 } )$ is maintained. On the other hand, if $b \\cdot I$ decreases beyond $\\mathcal { O } ( K ^ { - 1 } \\epsilon ^ { - 1 / 2 } )$ , the communication complexity increases from $\\tilde { \\mathcal { O } } ( \\epsilon ^ { - 1 } )$ . For instance, if we choose $b = \\mathcal { O } ( 1 )$ and $I = { \\mathcal { O } } ( 1 )$ the communication complexity becomes $\\tilde { \\mathcal { O } } ( \\epsilon ^ { - 3 / 2 } )$ while the optimal sample complexity $\\tilde { \\mathcal { O } } ( \\epsilon ^ { - 3 / 2 } )$ is maintained. This trade-off is illustrated in Figure $\\boxed { 1 \\mathrm { a } }$ where we maintain the optimal sample complexity, while changing $b$ and $I$ to generate the trade-off surface. □ ",
+        "bbox": [
+            173,
+            306,
+            826,
+            463
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Remark 5 (Data Heterogeneity). The term $\\begin{array} { r } { \\tilde { \\mathcal { O } } \\biggl ( \\frac { \\zeta ^ { 2 } } { K ^ { 2 \\nu / 3 } T ^ { 1 - \\nu / 3 } } \\biggr ) } \\end{array}$ in the gradient bound $\\textcircled{4}$ captures the effect of the heterogeneity of data across WNs, where $\\zeta$ is the parameter characterizing the intra-node variance and has been defined in Assumption $\\bigstar$ (ii). Highly heterogeneous data with large $\\zeta ^ { 2 }$ can adversely impact the performance of STEM. Note that such a dependency on $\\zeta$ also appears in other existing FL algorithms, such as $\\boxed { 9 } \\boxed { 1 4 } \\boxed { 1 8 }$ . However, there is one special case of STEM that does not depend on the parameter $\\zeta$ . This is the case where $I = 1$ , i.e., the minibatch SGD counterpart of STEM where only a single local iteration is performed between two communication rounds. We have the following corollary. □ ",
+        "bbox": [
+            173,
+            465,
+            826,
+            585
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Corollary 1 (Minibatch STEM). Under Assumptions $\\boldsymbol { I } a n d \\boldsymbol { 2 }$ , and choose the algorithm parameters as in Theorem $\\boxed { 3 . I }$ At each WN, choose $I = 1$ , $b = ( T / K ^ { 2 } ) ^ { 1 / 2 }$ , and the initial batch size $B = \\boldsymbol { b } \\cdot \\boldsymbol { I }$ . Then STEM satisfies: ",
+        "bbox": [
+            174,
+            589,
+            826,
+            636
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "(i) For $\\bar { x } _ { a }$ chosen according to Algorithm $\\perp$ we have ",
+        "bbox": [
+            176,
+            646,
+            529,
+            662
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fe27c5ca3c886c333d5add660b12f630bb6023b83b7450c21e97035dfce670f9.jpg",
+        "text": "$$\n\\mathbb { E } \\| \\nabla f ( \\bar { x } _ { a } ) \\| ^ { 2 } = \\mathcal { O } \\Big ( \\frac { f ( \\bar { x } _ { 1 } ) - f ^ { * } } { T } \\Big ) + \\tilde { \\mathcal { O } } \\Big ( \\frac { \\sigma ^ { 2 } } { T } \\Big ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            359,
+            671,
+            665,
+            704
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "(ii) Minibatch STEM achieves $\\tilde { \\mathcal O } ( \\epsilon ^ { - 3 / 2 } )$ sample and $\\tilde { \\mathcal { O } } ( \\epsilon ^ { - 1 } )$ communication complexity. ",
+        "bbox": [
+            168,
+            719,
+            761,
+            738
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Next, we show that FedAvg also exhibits a trade-off similar to that of STEM but with worse sample and communication complexities. ",
+        "bbox": [
+            173,
+            748,
+            826,
+            777
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.2 Special cases: The FedAvg algorithm ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            796,
+            470,
+            813
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We briefly discuss another interesting special case of STEM, where the local momentum update is replaced by the conventional SGD (i.e., $a _ { t } = 1 , ~ \\forall ~ t )$ , while the server does not perform the momentum update (i.e., $\\bar { d } _ { t } = 0 , \\forall t )$ . This is essentially the classical FedAvg algorithm, just that it balances the number of local updates $I$ and the minibatch size $b$ . We show that this algorithm also exhibits a trade-off between $b$ and $I$ and on the trade-off curve it achieves $\\mathcal { O } ( \\epsilon ^ { - 2 } )$ sample complexity and $\\mathcal { O } ( \\epsilon ^ { - 3 / 2 } )$ communication complexity. ",
+        "bbox": [
+            174,
+            823,
+            825,
+            910
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/6bf0f1ad1737bddbd1a909e1c507f78edccdbe2e2cf8c63393f03d6b14335b18.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "(a) Mild heterogeneity, $b = 6 4$ , and $I = 7$ . "
+        ],
+        "table_body": "<table><tr><td>Algorithm</td><td> Training Acc.</td><td>Testing Acc.</td></tr><tr><td>FedAvg</td><td>78.2</td><td>74.1</td></tr><tr><td>FedProx</td><td>79.2</td><td>74.8</td></tr><tr><td>FedDyn</td><td>68.9</td><td>66.0</td></tr><tr><td>SCAFFOLD</td><td>71.9</td><td>74.0</td></tr><tr><td>MIME</td><td>82.6</td><td>76.8</td></tr><tr><td>FedGLOMO</td><td>76.1</td><td>72.8</td></tr><tr><td> STEM</td><td>80.1</td><td>78.8</td></tr></table>",
+        "bbox": [
+            173,
+            88,
+            500,
+            233
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/b0513e337be144b5f857c24b8a10281f3fd33f9a14e65f9ee342f421e0353331.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "(b) Moderate heterogeneity, $b = 8$ , and $I = 6 1$ "
+        ],
+        "table_body": "<table><tr><td>Algorithm</td><td>Training Acc.</td><td>Testing Acc.</td></tr><tr><td>FedAvg</td><td>73.6</td><td>75.4</td></tr><tr><td>FedProx</td><td>80.0</td><td>75.2</td></tr><tr><td>FedDyn</td><td>76.1</td><td>71.3</td></tr><tr><td>SCAFFOLD</td><td>72.5</td><td>73.7</td></tr><tr><td>MIME</td><td>61.5</td><td>58.6</td></tr><tr><td>FedGLOMO</td><td>10.0</td><td>10.0</td></tr><tr><td>STEM</td><td>81.1</td><td>78.5</td></tr></table>",
+        "bbox": [
+            524,
+            88,
+            849,
+            233
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 2: Training and testing accuracy of different algorithms on CIFAR-10 dataset for different batch-sizes, number of local updates, and heteregeneity settings. ",
+        "bbox": [
+            173,
+            261,
+            823,
+            290
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Theorem 3.2 (The FedAvg Algorithm). Under Assumptions 1 and 2, suppose the stepsize is chosen as: $\\begin{array} { r } { \\eta = \\sqrt { \\frac { b K } { T } } } \\end{array}$ ; Let us set: ",
+        "bbox": [
+            173,
+            324,
+            825,
+            362
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/614827bc2783d2a130099b5dcc25a039f7d6ca4f991f27f94b6b9f6e8cc8d82c.jpg",
+        "text": "$$\nI = \\mathcal { O } \\big ( ( T / K ^ { 3 } ) ^ { \\nu / 4 } \\big ) , \\quad b = \\mathcal { O } \\big ( ( T / K ^ { 3 } ) ^ { 1 / 3 - \\nu / 3 } \\big )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            336,
+            369,
+            660,
+            391
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "where $\\nu \\in [ 0 , 1 ]$ is a constant. Then for FedAvg with $T \\geq 8 1 L ^ { 2 } I ^ { 2 } b K$ , the following holds ",
+        "bbox": [
+            171,
+            397,
+            759,
+            414
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "(i) For $\\scriptstyle { \\bar { x } } _ { a }$ chosen according to Algorithm $2 ,$ we have ",
+        "bbox": [
+            176,
+            424,
+            527,
+            440
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fcbbd1eccd40989ffc376397736fd5950f8008a4dccca06a87727fb72022e909.jpg",
+        "text": "$$\n\\mathbb { E } \\Vert \\nabla f ( \\bar { x } _ { a } ) \\Vert ^ { 2 } = \\mathcal { O } \\Bigg ( \\frac { f ( \\bar { x } _ { 1 } ) - f ^ { * } } { K ^ { \\nu / 2 } T ^ { 2 / 3 - \\nu / 6 } } \\Bigg ) + \\mathcal { O } \\Bigg ( \\frac { \\sigma ^ { 2 } } { K ^ { \\nu / 2 } T ^ { 2 / 3 - \\nu / 6 } } \\Bigg ) + \\mathcal { O } \\Bigg ( \\frac { \\zeta ^ { 2 } } { K ^ { \\nu / 2 } T ^ { 2 / 3 - \\nu / 6 } } \\Bigg ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            223,
+            446,
+            802,
+            482
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "(ii) For any choice of $\\nu \\in [ 0 , 1 ]$ we have: ",
+        "bbox": [
+            173,
+            494,
+            446,
+            510
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Sample Complexity: The sample complexity of FedAvg is $\\mathcal { O } ( \\epsilon ^ { - 2 } )$ . This implies that each WN requires at most $\\tilde { \\mathcal { O } } ( K ^ { - 1 } \\epsilon ^ { - 2 } )$ gradient computations, thereby achieving linear speedup with the number of WNs in the network. ",
+        "bbox": [
+            196,
+            508,
+            825,
+            549
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Communication Complexity: The communication complexity of FedAvg is $\\mathcal { O } ( \\epsilon ^ { - 3 / 2 } )$ . ",
+        "bbox": [
+            202,
+            550,
+            761,
+            565
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Note that the requirement on $T$ being lower bounded is only relevant for theoretical purposes, a similar requirement was also imposed in $[ \\mathbb { 1 4 } ]$ to prove convergence. Again, the parameter $\\nu \\in [ 0 , 1 ]$ in the statement of Theorem $\\boxed { 3 . 2 }$ balances $I$ and $b$ at each WN while maintaining state-of-the-art sample and communication complexities; please see Table $\\bigstar$ for a comparison of those bounds with existing FedAvg bounds. For $\\nu = 1$ , FedAvg (cf. Theorem $3 . 2 )$ reduces to FedAvg proposed in [12, 14] and for $\\nu = 0$ , the algorithm can be viewed as a large batch FedAvg with constant local updates [15, 16]. Note that similar to STEM, it is known that for $I = 1$ , the Minibatch SGD’s performance is independent of the heterogeneity parameter, $\\zeta \\equiv \\mathbb { I I } 3 \\mathbb { I }$ . We also point out that if Algorithm $\\perp$ uses Nesterov’s or Polyak’s momentum $[ \\textcircled { 1 4 } ]$ at local WNs instead of the recursive momentum estimator we get the same guarantees as in Theorem $\\underline { { \\boldsymbol { \\vert 3 . 2 \\vert } } }$ ",
+        "bbox": [
+            173,
+            577,
+            825,
+            717
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In summary, this section established that once the WN’s and the SN’s update directions (SGD in FedAvg and momentum based directions in STEM) are fixed, there exists a sequence of optimal choices of the number of local updates $I$ , and the batch sizes $b$ , which guarantees the best possible sample and communication complexities for the particular algorithm. The trade-off analysis presented in this section provides some useful guidelines for how to best select $b$ and $I$ in practice. Our subsequent numerical results will also verify that if $b$ or $I$ are not chosen judiciously, then the practical performance of the algorithms can degrade significantly. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            819
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4 Numerical results ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            838,
+            352,
+            854
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this section, we validate the proposed STEM algorithm and compare its performance with the de facto standard FedAvg [11], and the algorithms stated in Table $^ { 1 . }$ Note that instead of FedPD we include the performance comparison with FedDyn $\\left[ \\left[ 3 6 \\right] \\right]$ since they are known to be very closely related. The goal of our experiments are three-fold: (1) To show that STEM performs on par, if not better, compared to other algorithms in different heterogeneity settings, (2) there are multiple ways to reach the desired solution accuracy, one can either choose a large batch size and perform only a few local updates or select a smaller batch size and perform multiple local updates, and finally, (3) if the local updates and the batch sizes are not chosen appropriately, the WNs might need to perform excessive computations to achieve the desired solution accuracy, thereby slowing down convergence. ",
+        "bbox": [
+            174,
+            868,
+            823,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/dcdc37cb3965642ea8fadecde08dc3a78e268deb8860ba74a94a052f25763bcd.jpg",
+        "table_caption": [
+            "Table 3: Training and testing accuracy on CIFAR-10 dataset for high heterogeneity, $b =$ 128 and $I = 6$ . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Algorithm</td><td>Training Acc.</td><td>Testing Acc.</td></tr><tr><td>FedAvg</td><td>57.6</td><td>57.1</td></tr><tr><td>FedProx</td><td>59.1</td><td>58.5</td></tr><tr><td>FedDyn</td><td>51.2</td><td>51.3</td></tr><tr><td>SCAFFOLD</td><td>53.1</td><td>54.7</td></tr><tr><td>MIME</td><td>56.1</td><td>55.1</td></tr><tr><td>FedGLOMO</td><td>56.8</td><td>56.1</td></tr><tr><td> STEM</td><td>58.5</td><td>57.4</td></tr></table>",
+        "bbox": [
+            173,
+            88,
+            500,
+            233
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/a8ee7b8ff04d3f8e652b073870044e3954f021e10e2ae94f2132f7ce72b56ed4.jpg",
+        "table_caption": [
+            "Table 4: Training and testing accuracy on Shakespeare dataset. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Algorithm</td><td>Training Acc.</td><td>Testing Acc.</td></tr><tr><td>FedAvg</td><td>40.1</td><td>39.2</td></tr><tr><td>FedProx</td><td>43.5</td><td>43.2</td></tr><tr><td>FedDyn</td><td>43.7</td><td>43.2</td></tr><tr><td>SCAFFOLD</td><td>40.3</td><td>41.3</td></tr><tr><td>MIME</td><td>32.1</td><td>32.1</td></tr><tr><td>FedGLOMO</td><td>40.3</td><td>40.1</td></tr><tr><td> STEM</td><td>44.5</td><td>43.8</td></tr></table>",
+        "bbox": [
+            527,
+            88,
+            854,
+            233
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/1a3649642909a08bbdd852d92b8ec00817216ffd484e8ea8263d27aa9fb977f4.jpg",
+        "image_caption": [
+            "Figure 2: Training loss and the testing accuracy for classification on MNIST data set against the number of samples accessed at each WN for moderate heterogeneity setting with $b = 8$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            320,
+            790,
+            491
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            558,
+            825,
+            641
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Data and Parameter Settings: We compare the algorithms for image classification tasks on CIFAR10 and MNIST data sets with 100 WNs, and for next character prediction task on Shakespeare dataset $\\pmb { \\Vert 3 7 } \\Vert$ with 143 WNs in the network. For both CIFAR-10 and MNIST, each WN implements a two-hidden-layer convolutional neural network (CNN) architecture followed by three linear layers for CIFAR-10 and two for MNIST. For CIFAR-10 (and MNIST) datset, we consider three settings with mild, moderate and high heterogeneity. For all the three settings, the data is partitioned into disjoint sets among the WNs. In the mild heterogeneity setting, the WNs have access to partitioned data from all the classes. In the moderate (resp. high) heterogeneity setting the data is partitioned such that each WN can access data from only 5 (resp. 2) out of 10 classes. For CIFAR-10 (resp. MNIST), each WN has access to 490 (resp. 540) samples for training and 90 (resp. 80) samples for testing purposes. ",
+        "bbox": [
+            173,
+            647,
+            825,
+            786
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We also compare the performance of algorithms on a popular FL benchmarking dataset, Shakespeare dataset $\\mathbb { B } \\mathbb { Z }$ . For this task, we adopt the settings from $\\dot { \\left[ \\left| 1 0 \\right| \\right] }$ and utilize a 2-Layer LSTM network with 100 hidden units and an 8-D embedding layer at each WN. Each WN has access to 3616 samples on average, and the samples are randomly split into an $80 \\%$ training set and a $20 \\%$ testing set. We randomly sample 10 nodes out of 143 for the training purpose. All the experiments are implemented on a single NVIDIA Quadro RTX 5000 GPU. More details are provided in appendix. ",
+        "bbox": [
+            174,
+            792,
+            825,
+            876
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "For the proposed STEM algorithm, recall that the step-size is $\\eta _ { t } = \\bar { \\kappa } / ( w _ { t } + \\sigma ^ { 2 } t ) ^ { 1 / 3 }$ with momentum parameter defined as $a _ { t } = { c } \\eta _ { t } ^ { 2 }$ . The step-size is used to update the iterates while the momentum parameter is used to construct the stochastic gradient estimate (cf. Algorithm 1 and Theorem $\\boxed { 3 . 1 }$ . For the experiments, we set $w _ { t } = \\sigma ^ { 2 } = 1$ and $c \\doteq \\bar { c } / \\bar { \\kappa } ^ { 2 }$ and tune for $\\bar { \\kappa } \\in [ 1 0 ^ { - 1 } , 1 0 ^ { - 2 } ]$ for the CIFAR-10 dataset and for ${ \\bar { \\kappa } } \\in \\{ 1 0 ^ { 1 } , 1 0 ^ { 0 } , 1 0 ^ { - 1 } , 1 0 ^ { - 2 } \\}$ for the Shakespeare dataset. For both the datasets we tune for $\\bar { c }$ in the range [1, 10]. For FedProx $\\mathbb { m }$ and FedDyn $\\lVert \\dot { \\boldsymbol { 3 6 } } \\rVert$ we choose the regularization constant to be 0.1. The momentum parameters for FedGLOMO $\\pm \\textcircled { 1 8 } \\textcircled { 1 }$ and MIME $\\mathbb { \\ m }$ are set based on the choices given in the respective papers. Specifically, for FedGLOMO we choose the parameter $\\beta _ { k } = 0 . 2$ and design the momentum gradient using a damping factor given in Appendix A.4 of FedGLOMO $\\mathbb { \\left[ \\left[ 8 \\right] \\right] }$ . Moreover, for MIME we choose the momentum parameter as 0.9. For the rest of the algorithms (including FedAvg and SCAFFOLD), the step-size is tuned from the set $\\{ 1 0 ^ { 1 } , 1 0 ^ { 0 } , 1 0 ^ { - 1 } , \\hat { 1 0 } ^ { - 2 } \\}$ . ",
+        "bbox": [
+            174,
+            882,
+            821,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            217
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Discussion: We evaluate the training and testing performance of STEM against multiple algorithms for different heterogeneity settings, minibatch sizes, and number of local updates. In Tables $\\bigstar$ $\\boxed { 2 \\mathbf { b } }$ and $\\bigstar ,$ we compare the training and testing accuracy of STEM to that of other algorithms on the CIFAR-10 dataset. Specific, heterogeneity settings, the choices of minibatches, and number of local updates are stated along with the tables. Note that STEM performs uniformly well under all the conditions. Moreover, note from Table $2  { \\mathbf { b } }$ that FedGLOMO diverges once the number of local updates are high. Also, note from Table $\\textcircled { 3 }$ that FedProx and STEM adapt well to high heterogeneity. Finally, with the next set of experiments we emphasize the importance of choosing $b$ and $I$ carefully. In Figure $\\bigstar ,$ we compare the training and testing performance of STEM, FedAvg and SCAFFOLD, against the number of samples accessed at each WN for the classification task on MNIST dataset with moderate heterogeneity. We fix $b = 8$ and conduct experiments under two settings, one with $I = 6 7$ , and the other with $I = 5 3 6$ local updates at each WN. Note that although a large number of local updates might lead to fewer communication rounds but it can make the sample complexity extremely high as is demonstrated by Figure $2 .$ For example, Figure $\\bigtriangledown$ shows that to reach testing accuracy of $9 6 - 9 7 \\%$ with $I = 6 7$ , STEM requires approximately $\\overline { { 5 0 } } 0 0 - 6 0 0 0$ samples, in contrast with $I = 5 3 6$ it requires more than 25000 samples at each WN. Similar behavior can be observed if we fix $I > 1$ and increase the local batch sizes. This implies not choosing the local updates and the batch sizes judiciously might lead to increased sample complexity. Additional experiments are included in the supplementary material to further evaluate the performance of the proposed algorithms. ",
+        "bbox": [
+            173,
+            229,
+            826,
+            492
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            512,
+            269,
+            529
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this work, we proposed a novel algorithm STEM, for distributed stochastic non-convex optimization with applications to FL. We showed that STEM reaches an $\\epsilon$ -stationary point with $\\tilde { \\mathcal O } ( \\epsilon ^ { - 3 / 2 } )$ sample complexity while achieving linear speed-up with the number of WNs. Moreover, the algorithm achieves a communication complexity of $\\tilde { \\mathcal { O } } ( \\epsilon ^ { - 1 } )$ . We established a (optimal) trade-off that allows interpolation between varying choices of local updates and the batch sizes at each WN while maintaining (near optimal) sample and communication complexities. We showed that FedAvg (a.k.a LocalSGD) also exhibits a similar trade-off while achieving worse complexities. Our results provide guidelines to carefully choose the number of local updates, update directions, and minibatch sizes to achieve the best performance. The future directions of this work include developing lower bounds on communication complexity that establishes the tightness of the analysis conducted in this work. ",
+        "bbox": [
+            173,
+            542,
+            826,
+            685
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgement ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            704,
+            330,
+            722
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We thank the anonymous reviewers for their valuable comments and suggestions. The work of Prashant Khanduri and Mingyi Hong was supported by NSF grant CMMI-1727757, AFOSR grant 19RT0424 and ARO grant W911NF-19-1-0247. The work of Mingyi Hong was also supported by an IBM Faculty Research award. The work of Jia Liu has been supported in part by NSF grants CAREER CNS-2110259, CNS-2112471, CNS-2102233, CCF-2110252, ECCS-2140277, and a Google Faculty Research Award. ",
+        "bbox": [
+            174,
+            736,
+            825,
+            819
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References   \n[1] J. Konecnˇ y, H. B. McMahan, D. Ramage, and P. Richtárik, “Federated optimization: Distributed \\` machine learning for on-device intelligence,” arXiv preprint arXiv:1610.02527, 2016.   \n[2] M. Li, D. G. Andersen, A. J. Smola, and K. Yu, “Communication efficient distributed machine learning with the parameter server,” in Advances in Neural Information Processing Systems 27, Z. Ghahramani, M. Welling, C. Cortes, N. D. Lawrence, and K. Q. Weinberger, Eds. Curran Associates, Inc., 2014, pp. 19–27.   \n[3] J. Dean, G. Corrado, R. Monga, K. Chen, M. Devin, M. Mao, M. Ranzato, A. Senior, P. Tucker, K. Yang et al., “Large scale distributed deep networks,” in Advances in neural information processing systems, 2012, pp. 1223–1231.   \n[4] T. Léauté and B. Faltings, “Protecting privacy through distributed computation in multi-agent decision making,” Journal of Artificial Intelligence Research, vol. 47, pp. 649–695, 2013.   \n[5] C. Fang, C. J. Li, Z. Lin, and T. Zhang, “Spider: Near-optimal non-convex optimization via stochastic path-integrated differential estimator,” in Advances in Neural Information Processing Systems, 2018, pp. 689–699.   \n[6] D. Zhou, P. Xu, and Q. Gu, “Stochastic nested variance reduction for nonconvex optimization,” arXiv preprint arXiv:1806.07811, 2018.   \n[7] A. Cutkosky and F. Orabona, “Momentum-based variance reduction in non-convex SGD,” in Advances in Neural Information Processing Systems 32. Curran Associates, Inc., 2019, pp. 15 236–15 245.   \n[8] Q. Tran-Dinh, N. H. Pham, D. T. Phan, and L. M. Nguyen, “Hybrid stochastic gradient descent algorithms for stochastic nonconvex optimization,” arXiv preprint arXiv:1905.05920, 2019.   \n[9] X. Zhang, M. Hong, S. Dhople, W. Yin, and Y. Liu, “Fedpd: A federated learning framework with adaptivity to non-iid data,” IEEE Transactions on Signal Processing, pp. 1–1, 2021.   \n[10] T. Li, A. K. Sahu, M. Zaheer, M. Sanjabi, A. Talwalkar, and V. Smith, “Federated optimization in heterogeneous networks,” arXiv preprint arXiv:1812.06127, 2018.   \n[11] B. McMahan, E. Moore, D. Ramage, S. Hampson, and B. A. y Arcas, “Communication-efficient learning of deep networks from decentralized data,” in Artificial Intelligence and Statistics. PMLR, 2017, pp. 1273–1282.   \n[12] H. Yu, S. Yang, and S. Zhu, “Parallel restarted sgd with faster convergence and less communication: Demystifying why model averaging works for deep learning,” in Proceedings of the AAAI Conference on Artificial Intelligence, vol. 33, no. 01, 2019, pp. 5693–5700.   \n[13] B. Woodworth, K. K. Patel, and N. Srebro, “Minibatch vs local sgd for heterogeneous distributed learning,” arXiv preprint arXiv:2006.04735, 2020.   \n[14] H. Yu, R. Jin, and S. Yang, “On the linear speedup analysis of communication efficient momentum sgd for distributed non-convex optimization,” in International Conference on Machine Learning. PMLR, 2019, pp. 7184–7193.   \n[15] S. P. Karimireddy, S. Kale, M. Mohri, S. Reddi, S. Stich, and A. T. Suresh, “Scaffold: Stochastic controlled averaging for federated learning,” in International Conference on Machine Learning. PMLR, 2020, pp. 5132–5143.   \n[16] H. Yang, M. Fang, and J. Liu, “Achieving linear speedup with partial worker participation in non-iid federated learning,” arXiv preprint arXiv:2101.11203, 2021.   \n[17] S. P. Karimireddy, M. Jaggi, S. Kale, M. Mohri, S. J. Reddi, S. U. Stich, and A. T. Suresh, “Mime: Mimicking centralized stochastic algorithms in federated learning,” arXiv preprint arXiv:2008.03606, 2020.   \n[18] R. Das, A. Hashemi, S. Sanghavi, and I. S. Dhillon, “Improved convergence rates for non-convex federated learning with compression,” arXiv preprint arXiv:2012.04061, 2020.   \n[19] B. Woodworth, K. K. Patel, S. U. Stich, Z. Dai, B. Bullins, H. B. McMahan, O. Shamir, and N. Srebro, “Is local sgd better than minibatch sgd?” arXiv preprint arXiv:2002.07839, 2020.   \n[20] H. Yu and R. Jin, “On the computation and communication complexity of parallel sgd with dynamic batch sizes for stochastic non-convex optimization,” in International Conference on Machine Learning. PMLR, 2019, pp. 7174–7183.   \n[21] J. Wang and G. Joshi, “Cooperative sgd: A unified framework for the design and analysis of local-update sgd algorithms,” Journal of Machine Learning Research, vol. 22, no. 213, pp. 1–50, 2021.   \n[22] A. Khaled, K. Mishchenko, and P. Richtárik, “Better communication complexity for local sgd,” arXiv, 2019.   \n[23] S. U. Stich, “Local sgd converges fast and communicates little,” arXiv preprint arXiv:1805.09767, 2018.   \n[24] T. Lin, S. U. Stich, K. K. Patel, and M. Jaggi, “Don’t use large mini-batches, use local sgd,” in International Conference on Learning Representations, 2020.   \n[25] F. Zhou and G. Cong, “On the convergence properties of a k-step averaging stochastic gradient descent algorithm for nonconvex optimization,” in Proceedings of the Twenty-Seventh International Joint Conference on Artificial Intelligence, IJCAI-18, 7 2018, pp. 3219–3227.   \n[26] F. Sattler, S. Wiedemann, K.-R. Müller, and W. Samek, “Robust and communication-efficient federated learning from non-iid data,” IEEE transactions on neural networks and learning systems, vol. 31, no. 9, pp. 3400–3413, 2019.   \n[27] Y. Zhao, M. Li, L. Lai, N. Suda, D. Civin, and V. Chandra, “Federated learning with non-iid data,” arXiv preprint arXiv:1806.00582, 2018.   \n[28] J. Wang, V. Tantia, N. Ballas, and M. Rabbat, “Slowmo: Improving communication-efficient distributed sgd with slow momentum,” arXiv preprint arXiv:1910.00643, 2019.   \n[29] X. Liang, S. Shen, J. Liu, Z. Pan, E. Chen, and Y. Cheng, “Variance reduced local sgd with lower communication complexity,” arXiv preprint arXiv:1912.12844, 2019.   \n[30] P. Sharma, P. Khanduri, S. Bulusu, K. Rajawat, and P. K. Varshney, “Parallel restarted SPIDER – communication efficient distributed nonconvex optimization with optimal computation complexity,” arXiv preprint arXiv:1912.06036, 2019.   \n[31] S. J. Reddi, S. Kale, and S. Kumar, “On the convergence of adam and beyond,” arXiv preprint arXiv:1904.09237, 2019.   \n[32] A. Koloskova, N. Loizou, S. Boreiri, M. Jaggi, and S. Stich, “A unified theory of decentralized sgd with changing topology and local updates,” in International Conference on Machine Learning. PMLR, 2020, pp. 5381–5393.   \n[33] R. Johnson and T. Zhang, “Accelerating stochastic gradient descent using predictive variance reduction,” in Advances in Neural Information Processing Systems 26. Curran Associates, Inc., 2013, pp. 315–323.   \n[34] L. Bottou, F. E. Curtis, and J. Nocedal, “Optimization methods for large-scale machine learning,” SIAM Review, vol. 60, no. 2, pp. 223–311, 2018.   \n[35] Y. Drori and O. Shamir, “The complexity of finding stationary points with stochastic gradient descent,” in International Conference on Machine Learning. PMLR, 2020, pp. 2658–2667.   \n[36] D. A. E. Acar, Y. Zhao, R. Matas, M. Mattina, P. Whatmough, and V. Saligrama, “Federated learning based on dynamic regularization,” in International Conference on Learning Representations, 2020.   \n[37] S. Caldas, S. M. K. Duddu, P. Wu, T. Li, J. Konecnˇ ý, H. B. McMahan, V. Smith, and A. Talwalkar, “Leaf: A benchmark for federated settings,” 2019. ",
+        "bbox": [
+            173,
+            90,
+            828,
+            920
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            68,
+            828,
+            909
+        ],
+        "page_idx": 11
+    }
+]

parse/train/lMgDDWb1ULW/lMgDDWb1ULW.md

@@ -0,0 +1,253 @@
+# Hash Layers For Large Sparse Models
+
+# Stephen Roller Sainbayar Sukhbaatar Arthur Szlam Jason Weston
+
+Facebook AI Research
+
+# Abstract
+
+We investigate the training of sparse layers that use different parameters for different inputs based on hashing in large Transformer models. Specifically, we modify the feedforward layer to hash to different sets of weights depending on the current token, over all tokens in the sequence. We show that this procedure either outperforms or is competitive with learning-to-route mixture-of-expert methods such as Switch Transformers and BASE Layers, while requiring no routing parameters or extra terms in the objective function such as a load balancing loss, and no sophisticated assignment algorithm. We study the performance of different hashing techniques, hash sizes and input features, and show that balanced and random hashes focused on the most local features work best, compared to either learning clusters or using longer-range context. We show our approach works well both on large language modeling and dialogue tasks, and on downstream fine-tuning tasks.
+
+# 1 Introduction
+
+Recent studies of Transformer models have shown a clear trend towards improvements with scale in data and model size [1], mirroring the same trend in Machine Learning more generally. However, when architected naively, larger (in terms of parameter count) models are slower to train and to evaluate; and at extreme scale, with current computer systems, necessitate complex engineering to facilitate communication between workers. To address these challenges, researchers have studied Mixtures-of-Experts (MoE) models [2, 3, 4, 5, 6, 7, 8], where a “gater” routes computation through a sparse subset of the weights of the model (the “expert modules”). Specifically in the setting of Transformers for Natural Language Processing (NLP), recent approaches have led to state of the art performance in language modeling [8]. MoE models allow increasing the number of parameters in the model while holding steady the number of computations that affect a given sample.
+
+A key component to a MoE model is the routing (gating) strategy. While MoE models can be computationally advantageous per parameter compared to a dense model, they might be functionally less powerful per parameter. A poor routing strategy might lead to expert modules that are not properly specialized (essentially making a stochastic ensemble model); or overly specialized, using the data assignment function to overfit. Meanwhile, the routing strategy itself must be efficient.
+
+A standard approach is to train a layer of weights that makes the routing decision based upon the input to the layer to be routed. Classically, this may have been implemented with a softmax over the choice of expert modules, and fitted via backpropagation. However, a dense softmax requires all expert modules to run on all data points at train time, which negates the computational savings. Several works have shown that sparsity can be maintained during training, e.g. [9, 7, 8, 10]. In particular, Switch Transformers [8] select the top expert per token using a softmax over the token’s hidden state, but require a load balancing term in the objective function or they can become imbalanced or degenerate, giving poor results. BASE Layers [10] employ a linear assignment algorithm to try to resolve the same problem.
+
+![](images/ff2e0ac739f989887c380d02586f285cef622333df54066fd01369ec580f27ee.jpg)  
+Figure 1: Overview of the Hash Layer. Tokens are routed to fixed expert modules based on their hash.
+
+In this work, we describe a simple, sparse, efficient routing strategy based on hashing input tokens that is effective in the Transformers-for-NLP setting. We show this approach is effective on a number of datasets, comparing favorably to both Switch Transformers and BASE Layers. As the routing strategy requires no extra parameters, no change to the objective function or assignment algorithm, its simplicity means it is robust, fast and easy to implement. We provide detailed analysis to explain why our method works, and in which conditions. Given that when training very large models one may typically have only one shot given the required compute budget, and experimenters will be unable to try many parameter choices, we hence advocate our approach as a strong candidate for such a setting.
+
+# 2 Background
+
+Let us first introduce the Mixture-of-Experts setting where we apply our hash-based routing strategy. We use the same setting as [11, 8, 10] where a feedforward network (FFN) in a Transformer is replaced by its MoE version. Given a tokenized input sequence $\{ x _ { 1 } , x _ { 2 } , \dots , x _ { T } \}$ of $T$ tokens, a representation for each token is computed in parallel by a standard Transformer [12]
+
+$$
+\mathbf { h } _ { 1 } ^ { L } , \mathbf { h } _ { 2 } ^ { L } , \ldots , \mathbf { h } _ { T } ^ { L } = \mathrm { T R A N S F O R M E R } ( x _ { 1 } , x _ { 2 } , \ldots , x _ { T } ) .
+$$
+
+The Transformer consists of $L$ layers that computes final hidden states for each token, and each layer is composed of self-attention and FFN sublayers, where FFNs are two-layer fully connected networks
+
+$$
+\bar { \mathbf { h } } _ { t } ^ { l } = \mathrm { S e l f A t t n } ( \mathbf { h } _ { t } ^ { l - 1 } ) \qquad \mathbf { h } _ { t } ^ { l } = \mathrm { F F N } ( \bar { \mathbf { h } } _ { t } ^ { l } ) .
+$$
+
+Here we omit skip-connections and normalization for brevity. We can then replace one or more of the FFN sublayers with expert modules. Replacing the FNN at layer $l$ with $K$ expert FFNs, their output is then mixed with some gating function $g ( \cdot )$ :
+
+$$
+\mathbf h _ { t } ^ { l } = \mathrm { F F N } ( \bar { \mathbf h } _ { t } ^ { l } ) \quad \to \quad \mathbf h _ { t } ^ { l } = \sum _ { i = 1 } ^ { K } g _ { i } ( \bar { \mathbf h } _ { t } ^ { l } ) \mathrm { F F N } _ { i } ( \bar { \mathbf h } _ { t } ^ { l } ) , \quad t = 1 , \dots , T ,
+$$
+
+where importantly each token is routed to a different mixture of experts, as the gating function depends on the token’s specific hidden state $\bar { \mathbf { h } } _ { t } ^ { l }$ .
+
+Sparse MoE methods assume gating values $g _ { i }$ are often zero, so only a few experts need to be computed for better efficiency. As expert FFNs do not share parameters, the number of parameters increases with $K$ while the amount of computations per input token stays the same if the MoE FFN only routes to a single expert, and computation of $g _ { i }$ is cheap. While this allows training of large capacity models with small compute budget, optimizing $g _ { i }$ in the sparse setting can be tricky.
+
+# 3 Method
+
+In this paper we propose a simple gating mechanism that is especially efficient because only one expert is active, and it has no routing network parameters to be learnt. Recent work [11, 8, 10] has to learn parameters that determine the routing to expert modules based on hidden states, which have to be optimized in tandem with the expert weights themselves. This can potentially cause difficulty because during training membership for each expert is changing while it is trying to learn the mapping for those members. We instead advocate for a fixed mapping to experts. Namely, by hashing the tokens into a fixed number of buckets, each bucket corresponding to an expert:
+
+$$
+\mathbf { h } _ { t } ^ { l } = \mathrm { F F N } _ { \mathrm { h a s h } ( x _ { t } ) } ( \bar { \mathbf { h } } _ { t } ^ { l } ) , \quad t = 1 , \ldots , T .
+$$
+
+While the FFN still takes the hidden state $\bar { \mathbf { h } } _ { t } ^ { l }$ as input, our routing function uses the original input token $x _ { t }$ rather than the hidden state, see Figure 1 for a graphical depiction. We are free to choose from various possible hash functions, which we will consider below. However, for training purposes, the hash function is fixed in advance, and in this way, our routing mechanism requires no training and has no adjustable parameters.
+
+# 3.1 Hash Functions
+
+Hash functions have long been employed throughout Computer Science [13], and can take a variety of forms. In our work, we generally employ pre-computed hash functions, which use a lookup table during learning – precomputed in advance – to map tokens to expert modules.
+
+We consider several kinds of hash functions as possible choices for routing tokens to expert modules. The simplest is Random Hash, wherein we assign every token to a fixed, random expert at initialization. Due to the Zipfian distribution of token frequency, this naturally produces imbalance across the different expert modules. As balancing has been previously shown to be important for training MoE models [8, 10], we also consider Balanced assignment. In this method, we build the lookup table before training the model using the training data distribution by greedily assigning the most frequent tokens to the emptiest buckets. The resulting assignment structure is significantly more balanced than Random Hashing, but not perfect, as the frequency of some tokens exceeds the ideal distribution.
+
+Random and Balanced hashing exploit the inductive bias of auto-regressive models and hash on the input token, but we also consider other possibilities: Bigram Hash uses the current and previous token $( x _ { t - 1 } , x _ { t } )$ rather than only the current token, while Previous Token Hash uses the previous token $x _ { t - 1 }$ , ignoring the current input. We also consider a sanity check which hashes based on the Position in the sequence, which we expect to have little impact, as absolute positions carry little information in natural language. Each of these hash functions is used to assess the value of the information being routed-on in our subsequent experimental analysis.
+
+As an upper baseline, we also evaluate using an Oracle Future Hash, which hashes based on the output token $x _ { t + 1 }$ , rather than input token. This Oracle Hash checks how powerful routing decisions can be in solving a task. Similarly, we also consider Predicted Future Token Hash, which utilizes a baseline Transformer to make a prediction of the output token, and then hashes over this prediction.
+
+Clustered Hashes Based on the intuition that similar tokens may want to be routed to the same expert, we also experiment with Clustered Hashes. We obtain clusters by performing k-means clustering with a fixed number of clusters using token embeddings from a baseline Transformer model. Each expert is assigned a centroid, and tokens are assigned to their closest cluster.
+
+Dispersed Hashes We also consider the opposite hypothesis: that similar-tokens should be placed in different buckets, where the assumption is that very similar tokens need fine distinctions which requires more model capacity (hence assigning to different experts). To do this, we use the same $\mathbf { k }$ -means clusters as before, but distribute all tokens within each cluster equally across all buckets.
+
+# 3.2 MultiHash Layers
+
+In the standard FFN MoE approach, all $K$ expert modules have independent parameters, but here we consider another option. It is known in the hashing literature that multiple hashes can provide better allocations in many contexts [14]. We consider such schemes in the context of sparse routing. Let us assume we are given $N$ different hashing functions, and for a given input token $x$ we compute these hashes, denoted as $k _ { m } =  { \mathrm { h a s h } _ { m } } ( x )$ , $m = 1 , \ldots , N$ . Assuming the usual expert FFN is a function $B ( \mathrm { r e l u } ( A ( { \bf h } ) ) )$ where $A : \mathbb { R } ^ { d }  \mathbb { R } ^ { D }$ and $B : \mathbb { R } ^ { D }  \mathbb { R } ^ { d }$ , we split the linear layers into $N$ segments, $A _ { m } : \mathbb { R } ^ { d }  \mathbb { R } ^ { D / N }$ and $B _ { m } : \mathbb { R } ^ { D }  \mathbb { R } ^ { d / N }$ . Then we compute:
+
+$$
+\mathbf { v } = \mathrm { r e l u } ( [ A _ { k _ { 1 } } ( \mathbf { h } ) , \dots , A _ { k _ { N } } ( \mathbf { h } ) ] ) \qquad \mathrm { F F N } _ { \mathrm { M H } } ( \mathbf { h } ) = [ B _ { k _ { 1 } } ( \mathbf { v } ) , \dots , B _ { k _ { N } } ( \mathbf { v } ) ] .
+$$
+
+That is, use hashing to select the parameters we are going to use for each segment, and then concatenate them together. The advantage is that we are now no longer reliant on the quality of a single hash function, but have multiple chances to produce good quality partitions. This perhaps can also be seen as analogous to the multi-head attention process already used in Transformers.
+
+# 4 Related Work
+
+Sparse MoE models, where only a few expert modules are active for any input, in particular in the context of NLP, have been studied recently in [6, 11]. In these works, the gating is learned via backpropagation, perhaps with a regularizer to encourage load balancing across experts. [8] showed that models in [11] can be successfully trained with each input assigned to exactly one expert. Another such approach for Transformers, where the routing is learned via solving a linear assignment problem, is studied in [10]. [15] uses a different approach, where product keys enable nearest neighbor search to select parameters. More generally, using MoE to trade off compute time (at the cost of possible data fragmentation) has a long history, see e.g. [3, 7].
+
+The approach in this work is different from all of these in that the assignments use no learning whatsoever, and instead make use of the inductive biases possible in the setting of natural language. In particular, we use the fact that $n$ -grams are themselves decent language models [16]. Thus this work is related to previous work attempting to combine neural and $n$ -gram language models [17, 18, 19, 20, 21, 22].
+
+Our work is also related to feature hashing in linear models and kernel methods [23, 24], where word or n-gram features are hashed to provide a new lower dimensional feature space. [23] showed that when performing such feature hashing the interaction between random subspaces is negligible with high probability. [25] uses hashing to compress neural networks, rather than increase their parameters as we do here. Work on long-context Transformers has recently used hashing techniques to speed up access to long-range token history via sparse self-attention patterns, particularly in Routing Transformers [26] and the Reformer [27]. In contrast, our work uses hashing to access a large set of parameters via sparse routing, rather than sparse access to input features.
+
+# 5 Experiments
+
+# 5.1 Tasks
+
+Pushshift.io Reddit We use a variant of Reddit discussions, which has also been used in several existing studies, see e.g. [28, 29, 30, 31]. Following [32], we use a previously existing Reddit dataset extracted and obtained by a third party and made available on pushshift.io [33], training to generate a comment conditioned on the full thread leading up to the comment, spanning 1.5B training examples. We use the same BPE dictionary as [34], comprising of 8008 tokens.
+
+RoBERTa+cc100en Data We use the same data used to train BASE [10], which consists of approximately 100B tokens, combining corpora used in RoBERTa [35] with the English subset of the CC100 corpus [36]. The GPT2 dictionary, of size 51200, is used for tokenization. For our seq2seq experiments, we arrange this data splitting by sentence to predict the next turn. We consider it as the originally intended language modeling task in our experiments comparing with BASE [10].
+
+Wikitext-103 Wikitext-103 is a smaller language modeling benchmark [37] consisting of a collection of Wikipedia articles of over 100 million tokens, and a fixed vocabulary size of 270K tokens is provided. We view this as a seq2seq task in our experiments, again splitting by sentence.
+
+Downstream BST tasks Finally, we use the Blended Skill Talk (BST) dialogue tasks used in [34] after pushshift.io Reddit pre-training to evaluate fine-tuning performance of dense vs. sparse models.
+
+# 5.2 Experimental Setup
+
+Seq2Seq Setup The majority of our experiments are carried out in ParlAI1 platform using an encoder-decoder Transformer framework. We first train several standard (dense) Transformers, with
+
+Table 1: Comparison of Models on pushshift.io Reddit. We show three sizes of dense Transformer compared to Switch Transformers and using Hash Layers with various numbers of modules and sparse layers, e.g. $5 \mathrm { x } 1 6$ means 5 sparse layers with 16 modules each. All Switch and Hash Layer modules are built to the same computational complexity as the 11 layer baseline Transformer, but have more parameters; the larger dense models have similar total parameters, but use more compute.   
+
+<table><tr><td>Model</td><td>Configuration</td><td>Params</td><td>Valid PPL</td><td>Test PPL</td></tr><tr><td>Baseline Transformer</td><td>layers=11,d=1024,D=4096</td><td>222M</td><td>24.90</td><td>24.96</td></tr><tr><td>Wider Transformer (more compute)</td><td>layers=11,d=2048,D=6144</td><td>755M</td><td>23.32</td><td>23.38</td></tr><tr><td>Deeper Transformer (more compute)</td><td>layers=22,d=1536,D=4096</td><td>755M</td><td>22.72</td><td>22.78</td></tr><tr><td>Switch Transformer</td><td>layers=11,modules=1x64,load_bal=0.1</td><td>751M</td><td>23.65</td><td>23.73</td></tr><tr><td>Hash Layer</td><td>layers=11,modules=1x64</td><td>751M</td><td>23.16</td><td>23.23</td></tr><tr><td>Switch Transformer</td><td>layers=11,modules=1x128,load_bal=0.1</td><td>1.28B</td><td>23.52</td><td>23.58</td></tr><tr><td>Hash Layer</td><td>layers=11,modules=1x128</td><td>1.28B</td><td>22.89</td><td>22.95</td></tr><tr><td>Switch Transformer</td><td>layers=11,modules=5x16,load_bal=0.01</td><td>852M</td><td>23.19</td><td>23.25</td></tr><tr><td>Switch Transformer</td><td>layers=11,modules=5x16,load_bal=0.1</td><td>852M</td><td>23.00</td><td>22.93</td></tr><tr><td>Hash Layer</td><td>layers=11,modules=5x16</td><td>852M</td><td>23.21</td><td>23.27</td></tr></table>
+
+Table 2: Comparison of Models on RoBERTa $^ +$ cc100en Data. We compare a dense transformer with the same parameters as our sparse models, except with 1 sparse layer with 64 modules (1x64).   
+
+<table><tr><td>Model</td><td>Configuration</td><td>Params</td><td>Valid PPL</td></tr><tr><td>Baseline Transformer</td><td>layers=11,d=1024,D=4096</td><td>266M</td><td>28.85</td></tr><tr><td>Switch Transformer</td><td>layers=11,modules=1x64,load_bal=0.1</td><td>795M</td><td>27.41</td></tr><tr><td>Hash Layer</td><td>layers=11,modules=1x64</td><td>794M</td><td>26.99</td></tr></table>
+
+2 encoder layers and either 11 or 22 decoder layers, following the structure in [34] for training on pushshift.io Reddit. We refer to the one with 11 layers and embedding size of $d = 1 0 2 4$ and FFN hidden layer size of $D = 4 0 9 6$ as our Baseline Transformer. We also train a "Wider" model with $D = 6 1 4 4$ , and a "Deeper" model with 22 decoder layers, and $D = 4 0 9 6$ . The Baseline model has 222M parameters, and the "Wider" and "Deeper" are selected to both have ${ 7 5 5 } \mathbf { M }$ parameters each. These models are compared to the Hash Layer methods detailed in section 3 and to Switch Transformers of the same sizes and settings. The load balancing for Switch is optimized on the validation set. For both Hash and Switch we use the "Baseline" Transformer size detailed above as the architecture that we add sparse routing layers to by replacing one or more of the original dense layers. All experiments are run for 100k updates; a table of hyperparameters is provided in subsection B.1.
+
+BASE Comparison While most of our analysis takes place in the setup described above with models up to 1.28B parameters, to test our methods at scale on larger sparse models, we adopt the BASE Layer setup [10] and code base2 instead where we compare 4.5B parameter Hash and BASE Layer models. This setting uses pure language models rather than the Seq2Seq setup above. We use the architecture, data (RoBERTa+cc100en), and hyperparameters directly from [10], using either a single sparse routing layer consisting of 3 stacked FFNs $D = 8 1 9 2$ ) on the middle layer of a 25 layer network, or 3 routing layers evenly spaced in the network. In order to compare with BASE directly, we keep all hyperparameters fixed and only change the routing method; we use a balanced assignment Hash Layer in this case. We trained until 40k steps had been reached. A table of hyperparameters is provided in subsection B.2.
+
+# 5.3 Results and Analysis
+
+# 5.3.1 Comparison between Hash, Switch and Dense models
+
+Hash vs. Switch routing on a single layer We first compare a Hash layer (with balanced hash) to a Switch layer, on an otherwise dense Transformer, where sparse routing is performed on layer 7 of the decoder. Both methods use 64 expert FFNs with 751M total parameters. Results on pushshift.io Reddit are given in Table 1 (rows 4 and 5) and on the RoBERTa+cc100en data in Table 2 (rows 2 and 3). We find Hash Layers outperforming Switch on both datasets by about 0.4-0.5 perplexity.
+
+![](images/38e3adf8c3e5c944343b8a66221296c62f3dd6aaa50568bd72a04b8f80797965.jpg)  
+Figure 2: Comparison of Hash Layers with other models. (left) Validation perplexity of a baseline Transformer, Switch Transformer, and Hash Layer on the pushshift.io Reddit dataset with 128 modules. (right) Validation perplexity of BASE, Hash Layer, and a deeper Hash Layer model on the RoBERTa+cc100en dataset. All sparse models have the same number of parameters.
+
+![](images/e9821b650a8cee3619053871c71f76b3a3a1e1fdd770c0d62211166988012056.jpg)  
+Figure 3: Comparing Different Number of Expert Modules and Layer Position. We compare (left) the validation perplexity wrt. the number of expert modules on the pushshift.io Reddit task for a Hash or Switch Layer on layer 7 of an 11 layer decoder in a Transformer. The baseline Transformer obtains a perplexity of 24.9. We compare the performance when adjusting the layer position of a 64 module Hash Layer on the same task (right). Placing on later layers works best.
+
+Dense vs. Sparse Models Both Hash and Switch sparse models outperform the dense Baseline (222M parameters) they are based on, as well as the Wider Transformer (755M parameters). However, the Deeper Transformer (755M parameters) outperforms the sparse models which have a similar number of parameters. However, we note that due to its dense rather than conditional compute it is slower in inference speed. We see this as a general trend: good dense models can get more power out of the same number of parameters than sparse models. However, sparse models, although more wasteful in memory, give better perplexity for the same speed (i.e, we should compare to the Baseline Transformer in this case, which has roughly the same amount of computation).
+
+Hash layer module size We conduct the same pushshift.io Reddit experiments as above, but altering the number of expert modules in both Hash and Switch. Increasing from 64 to 128 modules (1.28B parameters total) sees an even larger improvement of Hash over Switch (about 0.6 perplexity), see Table 1 (rows 6 and 7), and Figure 2 (left). Trying smaller numbers of modules, 16 and 32, and plotting all the results in Figure 3 (left) we see that for small numbers of modules Hash and Switch perform similarly, but the gap grows larger as the number of modules increases. For small numbers of modules, we hypothesize that learning to route, as Switch does, would be more important to be performant with those choices, but with larger numbers of modules many routing choices could work. Hence, Hash layers can work well in that setting, and learning to route becomes less important.
+
+Hash layer position We also experiment to find the best position layer-wise for the sparse routing to take place. In Figure 3 (right) we plot perplexity for the 64 module Hash Layer, placing on different layers of the decoder. We find that later layers perform better, but even the worst performing choice (layer 1) is still performing well compared to other baselines: as good as Switch Transformers using later layers in fact. We note that analysis of BASE Layers [10] showed a similar trend that later layers work well. Hypothesizing that conditional compute gives the ability to make fine-grained specializations, it follows that it is worth making those distinctions after more obvious features have first been extracted. We will return to this argument in later experiments.
+
+![](images/f711c252dacc82166509d939efebb2d7892082b0388b8acfd9f97b522bb19c2a.jpg)  
+Figure 4: Relative frequency for 64 expert modules with Random Hash (left) and Balanced Hash (right). The Zipfian distribution makes perfect balance impossible, but Balanced Hash is closer.
+
+Multi-layer routing We evaluate placing sparse routing every other layer, 16 different modules each in Table 1 (rows 8-10). Switch and Hash perform similarly in this setting, with Switch outperforming with the optimal choice of 0.1 load balancing (23.00 vs. 23.21), and the same performance (23.19) for balancing parameter 0.01. Given the results of Figure 3 (left), the small number of modules in this case may make performance close.
+
+Downstream fine-tuning We compare several of the pushshift.io Reddit models for the goal of fine-tuning on downstream tasks. We experiment with either fine-tuning the whole model, or freezing some parts of the model during fine-tuning, as well as altering the load balancing for Switch at fine-tune time. Results are given in Appendix A. We find that the fine-tune results generally agree with the original performance on the pre-training pushshift.io Reddit task, and the order of methods is retained. Hash outperforms Switch slightly, both outperform the Baseline model, and the larger dense models perform better, as expected. Freezing parts of the model generally hurts fine-tuning, unless the part frozen is the sparse part of the model. It appears in that case just fine-tuning the dense parts of the model is sufficient for good performance. Only tuning the sparse part of the model, on the other hand, hurts performance, perhaps because the majority of the capacity of the model lies there.
+
+# 5.3.2 Hash Function Analysis
+
+We evaluate the different choices of hashing function detailed in subsection 3.1. The overall results are given in Table 3 on the pushshift.io Reddit dataset using a 64 module Hash Layer.
+
+Random and Balanced Hash Functions We find that fixed random assignment (row 3) and balanced assignment (row 2) perform similarly well in terms of perplexity (23.22 vs. 23.16 valid perplexity). However, balanced assignment, as its name suggests, is more balanced, see Figure 4, which may render it more efficient in terms of distributed training schemes.
+
+Clustering Hash Functions Interestingly, using cluster based hashes (“Token clustering”, row 4) performs clearly worse than randomized hashes (23.90 vs. 23.22). We hypothesize that if the goal of conditional computation is to make fine distinctions, then those distinctions are more likely to appear between tokens within the same cluster, hence they should be in different hashes (parts of the compute graph), not the same one. We provide partial evidence for this by hashing within token clusters instead (“Dispersed Hash”, row 5), which restores the performance to be similar to random hashes (23.17 vs. 23.22). We note that learn-to-route methods such as Switch Transformers and BASE use simple functions of the hidden state to perform routing, which generally provide clustered expert modules [10], which could hence be a disadvantage for those methods.
+
+Table 4: Comparison of Models on Wikitext-103. We compare a baseline dense Transformer to our sparse models, which have 1 sparse layer with 16 modules (1x16). We show results with two different dictionaries, the BB [34] BPE dictionary (8008 tokens) and the standard one for the task (267,739 tokens). As these are different dictionaries, perplexities are not comparable across columns.   
+
+<table><tr><td>Model</td><td>Configuration</td><td>Std. Dict Valid PPL</td><td>BB Dict Valid PPL</td></tr><tr><td>Baseline Transformer</td><td>layers=8,d=512,D=512</td><td>33.09</td><td>12.58</td></tr><tr><td>Switch Transformer</td><td>layers=8,modules=1x16,load_bal=0.1</td><td>31.76</td><td>11.67</td></tr><tr><td>Hash Layer</td><td>layers=8,modules=1x16</td><td>32.32</td><td>11.58</td></tr></table>
+
+Position-based Hash Function We conduct experiments hashing based on sequence position only. We consider this experiment as a sanity check, we did not expect choosing conditional compute based on position in the output sequence to help. Indeed, it turns out that this is no better than the dense Transformer baseline. Thus it appears that routing based on input content is much more important.
+
+Bigram Hash Function Hashing based on the last two tokens (bigrams) performs worse than using only the last token (24.19 vs. 23.16). We hypothesize there are two reasons for this: (1) first, the last token is clearly the most pertinent, and bigrams add a less relevant feature; (2) this creates too many hashes, which performs less well. Subsequent experiments will help test these claims.
+
+Previous Token Hashing Hashing based on the previous token is clearly worse than using the current token (24.16 vs. 23.16), and gives similar performance to using bigrams, helping confirm the first part of our above bigram hypothesis.
+
+Dictionary size We perform experiments on Wikitext-103 in two settings: using the given dictionary of 267k tokens, or using the 8k dictionary we use in our pushshift.io Reddit experiments, following [34]. The results, comparing to Switch and a baseline Transformer, are given in Table 4. We find that Hash works well for the small dictionary, slightly outperforming Switch. However, on the larger dictionary, it performs worse than Switch. As this is the same data but just the tokenization has changed we conclude the hashing induced from the smaller dictionary is easier to learn from, helping confirm the second part of our above bigram hypothesis.
+
+Oracle Future Token Hashing We evaluate hashing using the oracle next token that is to be predicted. This yields a perplexity of 1.9. Using oracle information just to choose between modules is sufficient to essentially solve a task.
+
+Predicted Future Token Hashing The last result poses the question: if we can predict the next token, and hash based on that prediction instead – will it be better than hashing on the current token? We thus tried hashing using the Baseline Transformer to predict labels, yielding a perplexity of 25.02 – which does not actually beat the Baseline itself. It appears that the bias of the token predictions limits the ability of the sparse routing to improve.
+
+Multi-hashing We evaluate the multi-hashing technique described in subsection 3.2. Results are given in Appendix A, comparing to Switch and standard hashing. Even though the same number of parameters is used in all cases, we see improvements for splitting the hash into 2, 4 or 8 different hashes compared to a single hash, with steadily improving results for both 16 or 32 modules.
+
+# 5.3.3 Switch Transformer Analysis
+
+Switch load balancing We show the performance of Switch for different values of the load balancing parameter on pushshift.io Reddit in Appendix A. Clearly the choice of parameter is important, with results varying over a 1 perplexity point range.
+
+Switch with Token-based Routing Given our analysis of oracle and predicted token hashing in subsection 5.3.2, we hypothesize that the hidden representations in layers of the Transformer, being biased towards the predictions of the model, may be suboptimal for routing. We therefore experiment with a hybrid between Switch and Hash Layers: on the sparse layer, instead of using hidden state as the Switch router input, we use the current token instead. To convert the token to a vector we use an extra lookup table, i.e., an extra set of learnable parameters that is the size of the dictionary. These parameters are independent of the hidden state and are only used by the router to learn the best route. Results are given in Table 6. We find this brings some small improvements to Switch for 64 and 128 modules on a single layer, affirming the usefulness of token-based routing.
+
+Table 5: Multi-hashing experiments on pushshift.io Reddit. When multi-hashing, the same number of parameters is used, but the FFN weights are split and indexed into multiple hashes and then concatenated together for the forward step.   
+
+<table><tr><td>Model</td><td>Configuration</td><td>Params</td><td>Valid PPL</td><td>Test PPL</td></tr><tr><td>Switch Transformer</td><td>layers=11,modules=1x32,load_bal=0.1</td><td>483M</td><td>23.79</td><td>23.84</td></tr><tr><td>Hash Layer</td><td>layers=11,modules=1x32</td><td>483M</td><td>23.58</td><td>23.65</td></tr><tr><td>MultiHash Layer</td><td>layers=11,modules=1x32,hashes=2</td><td>483M</td><td>23.48</td><td>23.53</td></tr><tr><td>MultiHash Layer</td><td>layers=11,modules=1x32,hashes=4</td><td>483M</td><td>23.38</td><td>23.45</td></tr><tr><td>MultiHash Layer</td><td>layers=11,modules=1x32,hashes=8</td><td>483M</td><td>23.28</td><td>23.34</td></tr></table>
+
+Table 6: Switch Transformers with Token-Based Routing on pushshift.io Reddit. We compare standard Switch which routes based on the hidden state to token feature-routing (‘Token Switch’).   
+
+<table><tr><td>Model</td><td>Configuration</td><td>Params</td><td>Valid PPL</td><td>Test PPL</td></tr><tr><td>Switch Transformer</td><td>layers=11,modules=1x64,load_bal=0.1</td><td>751M</td><td>23.65</td><td>23.73</td></tr><tr><td>Token Switch</td><td>layers=11,modules=1x64,load_bal=0.1</td><td>751M</td><td>23.43</td><td>23.43</td></tr><tr><td>Switch Transformer</td><td>layers=11,modules=1x128,load_bal=0.1</td><td>1.28B</td><td>23.52</td><td>23.58</td></tr><tr><td>Token Switch</td><td>layers=11,modules=1x128,load_bal=0.1</td><td>1.28B</td><td>23.26</td><td>23.32</td></tr></table>
+
+# 5.3.4 Comparison to BASE Layers
+
+We next compare to BASE Layers. Using the BASE Layer code base, we implement Hash Layers in exactly the same setup, changing only the routing method, and leaving everything else fixed. Figure 2 (right) shows results comparing Hash with BASE for 4.5B parameter models. Across the entire run, we see that Hash outperforms BASE at each training step. During early parts of training, Hash would presumably have an advantage in being able to specialize expert modules earlier, while BASE must learn membership for each of the expert modules. Later in training, BASE becomes mildly unstable presumably as expert assignments shift, while Hash performance continues to improve smoothly.
+
+Additionally, to demonstrate Hash Layers remain performant when stacked, we trained a model with 3 Hash Layers (using random hashes), but fewer parameters per expert module so the total parameters remained constant at 4.5B (see subsection B.2). We find that using multiple Hash Layers gives a small but consistent improvement, suggesting Hash Layers will be effective at even more depth.
+
+In addition to performance gains compared to BASE, we also find that Hash Layers are more efficient in total computation. In particular, BASE requires two all-to-all communications: the first de-correlates batches in order to make assignment balancing more stochastic, and the second routes states to their assigned expert. As Hash Layers use fixed, pre-computed assignments they avoid the decorrelation step. In practice, we find this gives an improvement of about $11 \%$ in updates-per-second. As the number of expert layers increases, this difference will become more exaggerated.
+
+# 6 Conclusion
+
+We have introduced a simple and efficient approach to sparse models in the Transformers-for-NLP setting based on hash layers. We showed on a variety of datasets and with analysis in various settings that this approach is highly competitive with existing methods such as Switch Transformers and BASE Layers, whilst being robust and far simpler – requiring no extra learning parameters, assignment algorithm or changes to the objective function. Given that researchers typically have only one opportunity to train very large models, this makes our approach a strong candidate for such runs. While our experiments scale up to 4.5B parameters, we do not reach the scales of large industrial works such as [8], and we hope to see future work conduct such experiments. Finally, given that our routing approach is learning free, our results perhaps suggest that none of the current approaches are routing particularly well. We thus believe learning-to-route should continue to be the study of future work, and consider our work a strong baseline for such research.
+
+References   
+[1] Jared Kaplan, Sam McCandlish, Tom Henighan, Tom B Brown, Benjamin Chess, Rewon Child, Scott Gray, Alec Radford, Jeffrey Wu, and Dario Amodei. Scaling laws for neural language models. arXiv preprint arXiv:2001.08361, 2020.   
+[2] Robert A Jacobs, Michael I Jordan, Steven J Nowlan, and Geoffrey E Hinton. Adaptive mixtures of local experts. Neural computation, 3(1):79–87, 1991.   
+[3] Yoshua Bengio, Réjean Ducharme, Pascal Vincent, and Christian Janvin. A neural probabilistic language model. The journal of machine learning research, 3:1137–1155, 2003.   
+[4] Seniha Esen Yuksel, Joseph N Wilson, and Paul D Gader. Twenty years of mixture of experts. IEEE transactions on neural networks and learning systems, 23(8):1177–1193, 2012.   
+[5] David Eigen, Marc’Aurelio Ranzato, and Ilya Sutskever. Learning factored representations in a deep mixture of experts. arXiv preprint arXiv:1312.4314, 2013.   
+[6] Noam Shazeer, Azalia Mirhoseini, Krzysztof Maziarz, Andy Davis, Quoc Le, Geoffrey Hinton, and Jeff Dean. Outrageously large neural networks: The sparsely-gated mixture-of-experts layer. arXiv preprint arXiv:1701.06538, 2017.   
+[7] Sam Gross, Marc’Aurelio Ranzato, and Arthur Szlam. Hard mixtures of experts for large scale weakly supervised vision. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 6865–6873, 2017.   
+[8] William Fedus, Barret Zoph, and Noam Shazeer. Switch transformers: Scaling to trillion parameter models with simple and efficient sparsity. arXiv preprint arXiv:2101.03961, 2021.   
+[9] Ronan Collobert, Yoshua Bengio, and Samy Bengio. Scaling large learning problems with hard parallel mixtures. International Journal of pattern recognition and artificial intelligence, 17 (03):349–365, 2003.   
+[10] Mike Lewis, Shruti Bhosale, Tim Dettmers, Naman Goyal, and Luke Zettlemoyer. Base layers: Simplifying training of large, sparse models. arXiv preprint arXiv:2103.16716, 2021.   
+[11] Dmitry Lepikhin, HyoukJoong Lee, Yuanzhong Xu, Dehao Chen, Orhan Firat, Yanping Huang, Maxim Krikun, Noam Shazeer, and Zhifeng Chen. Gshard: Scaling giant models with conditional computation and automatic sharding. arXiv preprint arXiv:2006.16668, 2020.   
+[12] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in neural information processing systems, pages 5998–6008, 2017.   
+[13] Thomas H Cormen, Charles E Leiserson, Ronald L Rivest, and Clifford Stein. Introduction to algorithms. MIT press, 2009.   
+[14] Andrei Z Broder and Anna R Karlin. Multilevel adaptive hashing. In Proceedings of the first annual ACM-SIAM symposium on Discrete algorithms, pages 43–53, 1990.   
+[15] Guillaume Lample, Alexandre Sablayrolles, Marc’Aurelio Ranzato, Ludovic Denoyer, and Hervé Jégou. Large memory layers with product keys. In Advances in Neural Information Processing Systems, pages 8548–8559, 2019.   
+[16] Reinhard Kneser and Hermann Ney. Improved backing-off for m-gram language modeling. In 1995 international conference on acoustics, speech, and signal processing, volume 1, pages 181–184. IEEE, 1995.   
+[17] Tomáš Mikolov, Martin Karafiát, Lukáš Burget, Jan Cernock ˇ y, and Sanjeev Khudanpur. Recur- \` rent neural network based language model. In Eleventh annual conference of the international speech communication association, 2010.   
+[18] Ciprian Chelba, Tomas Mikolov, Mike Schuster, Qi Ge, Thorsten Brants, Phillipp Koehn, and Tony Robinson. One billion word benchmark for measuring progress in statistical language modeling. arXiv preprint arXiv:1312.3005, 2013.
+
+[19] Graham Neubig and Chris Dyer. Generalizing and hybridizing count-based and neural language models. arXiv preprint arXiv:1606.00499, 2016.
+
+[20] Sébastien Jean, Kyunghyun Cho, Roland Memisevic, and Yoshua Bengio. On using very large target vocabulary for neural machine translation. arXiv preprint arXiv:1412.2007, 2014.
+
+[21] Armand Joulin, Moustapha Cissé, David Grangier, Hervé Jégou, et al. Efficient softmax approximation for gpus. In International Conference on Machine Learning, pages 1302–1310. PMLR, 2017.
+
+[22] Anton Bakhtin, Arthur Szlam, Marc’Aurelio Ranzato, and Edouard Grave. Lightweight adaptive mixture of neural and n-gram language models. arXiv preprint arXiv:1804.07705, 2018.
+
+[23] Kilian Weinberger, Anirban Dasgupta, John Langford, Alex Smola, and Josh Attenberg. Feature hashing for large scale multitask learning. In Proceedings of the 26th annual international conference on machine learning, pages 1113–1120, 2009.
+
+[24] Bing Bai, Jason Weston, David Grangier, Ronan Collobert, Kunihiko Sadamasa, Yanjun Qi, Olivier Chapelle, and Kilian Weinberger. Learning to rank with (a lot of) word features. Information retrieval, 13(3):291–314, 2010.
+
+[25] Wenlin Chen, James Wilson, Stephen Tyree, Kilian Weinberger, and Yixin Chen. Compressing neural networks with the hashing trick. In International conference on machine learning, pages 2285–2294. PMLR, 2015.
+
+[26] Aurko Roy, Mohammad Saffar, Ashish Vaswani, and David Grangier. Efficient content-based sparse attention with routing transformers. Transactions of the Association for Computational Linguistics, 9:53–68, 2021.
+
+[27] Nikita Kitaev, Łukasz Kaiser, and Anselm Levskaya. Reformer: The efficient transformer. arXiv preprint arXiv:2001.04451, 2020.
+
+[28] Yinfei Yang, Steve Yuan, Daniel Cer, Sheng-yi Kong, Noah Constant, Petr Pilar, Heming Ge, Yun-Hsuan Sung, Brian Strope, and Ray Kurzweil. Learning semantic textual similarity from conversations. In Proceedings of The Third Workshop on Representation Learning for NLP, pages 164–174, Melbourne, Australia, July 2018. Association for Computational Linguistics.
+
+[29] Pierre-Emmanuel Mazaré, Samuel Humeau, Martin Raison, and Antoine Bordes. Training millions of personalized dialogue agents. In Proceedings of the 2018 Conference on Empirical Methods in Natural Language Processing, pages 2775–2779, Brussels, Belgium, OctoberNovember 2018. Association for Computational Linguistics.
+
+[30] Nitish Shirish Keskar, Bryan McCann, Lav R Varshney, Caiming Xiong, and Richard Socher. CTRL: A conditional transformer language model for controllable generation. arXiv preprint arXiv:1909.05858, 2019.
+
+[31] Kurt Shuster, Da Ju, Stephen Roller, Emily Dinan, Y-Lan Boureau, and Jason Weston. The dialogue dodecathlon: Open-domain knowledge and image grounded conversational agents, 2019.
+
+[32] Samuel Humeau, Kurt Shuster, Marie-Anne Lachaux, and Jason Weston. Poly-encoders: Architectures and pre-training strategies for fast and accurate multi-sentence scoring. In Proceedings of the International Conference on Learning Representations, 2019.
+
+[33] Jason Baumgartner, Savvas Zannettou, Brian Keegan, Megan Squire, and Jeremy Blackburn. The pushshift reddit dataset. arXiv preprint arXiv:2001.08435, 2020.
+
+[34] Stephen Roller, Emily Dinan, Naman Goyal, Da Ju, Mary Williamson, Yinhan Liu, Jing Xu, Myle Ott, Kurt Shuster, Eric M Smith, et al. Recipes for building an open-domain chatbot. arXiv preprint arXiv:2004.13637, 2020.
+
+[35] Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, and Veselin Stoyanov. Roberta: A robustly optimized bert pretraining approach. arXiv preprint arXiv:1907.11692, 2019.
+
+[36] Alexis Conneau, Kartikay Khandelwal, Naman Goyal, Vishrav Chaudhary, Guillaume Wenzek, Francisco Guzmán, Edouard Grave, Myle Ott, Luke Zettlemoyer, and Veselin Stoyanov. Unsupervised cross-lingual representation learning at scale. arXiv preprint arXiv:1911.02116, 2019.
+
+[37] Stephen Merity, Caiming Xiong, James Bradbury, and Richard Socher. Pointer sentinel mixture models. arXiv preprint arXiv:1609.07843, 2016.
+
+[38] Myle Ott, Sergey Edunov, Alexei Baevski, Angela Fan, Sam Gross, Nathan Ng, David Grangier, and Michael Auli. fairseq: A fast, extensible toolkit for sequence modeling. arXiv preprint arXiv:1904.01038, 2019.

parse/train/lMgDDWb1ULW/lMgDDWb1ULW_content_list.json

@@ -0,0 +1,1270 @@
+[
+    {
+        "type": "text",
+        "text": "Hash Layers For Large Sparse Models ",
+        "text_level": 1,
+        "bbox": [
+            263,
+            122,
+            735,
+            147
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Stephen Roller Sainbayar Sukhbaatar Arthur Szlam Jason Weston ",
+        "text_level": 1,
+        "bbox": [
+            238,
+            200,
+            758,
+            215
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Facebook AI Research ",
+        "bbox": [
+            424,
+            228,
+            573,
+            242
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            279,
+            535,
+            295
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We investigate the training of sparse layers that use different parameters for different inputs based on hashing in large Transformer models. Specifically, we modify the feedforward layer to hash to different sets of weights depending on the current token, over all tokens in the sequence. We show that this procedure either outperforms or is competitive with learning-to-route mixture-of-expert methods such as Switch Transformers and BASE Layers, while requiring no routing parameters or extra terms in the objective function such as a load balancing loss, and no sophisticated assignment algorithm. We study the performance of different hashing techniques, hash sizes and input features, and show that balanced and random hashes focused on the most local features work best, compared to either learning clusters or using longer-range context. We show our approach works well both on large language modeling and dialogue tasks, and on downstream fine-tuning tasks. ",
+        "bbox": [
+            233,
+            314,
+            766,
+            479
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            515,
+            310,
+            532
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recent studies of Transformer models have shown a clear trend towards improvements with scale in data and model size [1], mirroring the same trend in Machine Learning more generally. However, when architected naively, larger (in terms of parameter count) models are slower to train and to evaluate; and at extreme scale, with current computer systems, necessitate complex engineering to facilitate communication between workers. To address these challenges, researchers have studied Mixtures-of-Experts (MoE) models [2, 3, 4, 5, 6, 7, 8], where a “gater” routes computation through a sparse subset of the weights of the model (the “expert modules”). Specifically in the setting of Transformers for Natural Language Processing (NLP), recent approaches have led to state of the art performance in language modeling [8]. MoE models allow increasing the number of parameters in the model while holding steady the number of computations that affect a given sample. ",
+        "bbox": [
+            174,
+            550,
+            825,
+            689
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A key component to a MoE model is the routing (gating) strategy. While MoE models can be computationally advantageous per parameter compared to a dense model, they might be functionally less powerful per parameter. A poor routing strategy might lead to expert modules that are not properly specialized (essentially making a stochastic ensemble model); or overly specialized, using the data assignment function to overfit. Meanwhile, the routing strategy itself must be efficient. ",
+        "bbox": [
+            174,
+            695,
+            825,
+            763
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A standard approach is to train a layer of weights that makes the routing decision based upon the input to the layer to be routed. Classically, this may have been implemented with a softmax over the choice of expert modules, and fitted via backpropagation. However, a dense softmax requires all expert modules to run on all data points at train time, which negates the computational savings. Several works have shown that sparsity can be maintained during training, e.g. [9, 7, 8, 10]. In particular, Switch Transformers [8] select the top expert per token using a softmax over the token’s hidden state, but require a load balancing term in the objective function or they can become imbalanced or degenerate, giving poor results. BASE Layers [10] employ a linear assignment algorithm to try to resolve the same problem. ",
+        "bbox": [
+            174,
+            771,
+            825,
+            895
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/ff2e0ac739f989887c380d02586f285cef622333df54066fd01369ec580f27ee.jpg",
+        "image_caption": [
+            "Figure 1: Overview of the Hash Layer. Tokens are routed to fixed expert modules based on their hash. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            259,
+            90,
+            740,
+            224
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we describe a simple, sparse, efficient routing strategy based on hashing input tokens that is effective in the Transformers-for-NLP setting. We show this approach is effective on a number of datasets, comparing favorably to both Switch Transformers and BASE Layers. As the routing strategy requires no extra parameters, no change to the objective function or assignment algorithm, its simplicity means it is robust, fast and easy to implement. We provide detailed analysis to explain why our method works, and in which conditions. Given that when training very large models one may typically have only one shot given the required compute budget, and experimenters will be unable to try many parameter choices, we hence advocate our approach as a strong candidate for such a setting. ",
+        "bbox": [
+            174,
+            282,
+            825,
+            395
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Background ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            412,
+            308,
+            430
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Let us first introduce the Mixture-of-Experts setting where we apply our hash-based routing strategy. We use the same setting as [11, 8, 10] where a feedforward network (FFN) in a Transformer is replaced by its MoE version. Given a tokenized input sequence $\\{ x _ { 1 } , x _ { 2 } , \\dots , x _ { T } \\}$ of $T$ tokens, a representation for each token is computed in parallel by a standard Transformer [12] ",
+        "bbox": [
+            173,
+            444,
+            825,
+            501
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f119da0704e1fba4ccc12883757ee32ccc3c3b3379de43a9243fc505059b54f6.jpg",
+        "text": "$$\n\\mathbf { h } _ { 1 } ^ { L } , \\mathbf { h } _ { 2 } ^ { L } , \\ldots , \\mathbf { h } _ { T } ^ { L } = \\mathrm { T R A N S F O R M E R } ( x _ { 1 } , x _ { 2 } , \\ldots , x _ { T } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            323,
+            506,
+            674,
+            525
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The Transformer consists of $L$ layers that computes final hidden states for each token, and each layer is composed of self-attention and FFN sublayers, where FFNs are two-layer fully connected networks ",
+        "bbox": [
+            173,
+            531,
+            821,
+            559
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4280057934e902022650b0c2b21c2fcb7cb5502e86493f6c05309c94b9b1f030.jpg",
+        "text": "$$\n\\bar { \\mathbf { h } } _ { t } ^ { l } = \\mathrm { S e l f A t t n } ( \\mathbf { h } _ { t } ^ { l - 1 } ) \\qquad \\mathbf { h } _ { t } ^ { l } = \\mathrm { F F N } ( \\bar { \\mathbf { h } } _ { t } ^ { l } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            361,
+            565,
+            635,
+            584
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Here we omit skip-connections and normalization for brevity. We can then replace one or more of the FFN sublayers with expert modules. Replacing the FNN at layer $l$ with $K$ expert FFNs, their output is then mixed with some gating function $g ( \\cdot )$ : ",
+        "bbox": [
+            174,
+            590,
+            826,
+            633
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ea2f5b6cdf647772e57df243828c8ee710371973936bd98702a5aa5d86d15180.jpg",
+        "text": "$$\n\\mathbf h _ { t } ^ { l } = \\mathrm { F F N } ( \\bar { \\mathbf h } _ { t } ^ { l } ) \\quad \\to \\quad \\mathbf h _ { t } ^ { l } = \\sum _ { i = 1 } ^ { K } g _ { i } ( \\bar { \\mathbf h } _ { t } ^ { l } ) \\mathrm { F F N } _ { i } ( \\bar { \\mathbf h } _ { t } ^ { l } ) , \\quad t = 1 , \\dots , T ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            274,
+            638,
+            718,
+            683
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where importantly each token is routed to a different mixture of experts, as the gating function depends on the token’s specific hidden state $\\bar { \\mathbf { h } } _ { t } ^ { l }$ . ",
+        "bbox": [
+            174,
+            688,
+            823,
+            717
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Sparse MoE methods assume gating values $g _ { i }$ are often zero, so only a few experts need to be computed for better efficiency. As expert FFNs do not share parameters, the number of parameters increases with $K$ while the amount of computations per input token stays the same if the MoE FFN only routes to a single expert, and computation of $g _ { i }$ is cheap. While this allows training of large capacity models with small compute budget, optimizing $g _ { i }$ in the sparse setting can be tricky. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            792
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 Method ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            810,
+            271,
+            827
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper we propose a simple gating mechanism that is especially efficient because only one expert is active, and it has no routing network parameters to be learnt. Recent work [11, 8, 10] has to learn parameters that determine the routing to expert modules based on hidden states, which have to be optimized in tandem with the expert weights themselves. This can potentially cause difficulty because during training membership for each expert is changing while it is trying to learn the mapping for those members. We instead advocate for a fixed mapping to experts. Namely, by hashing the tokens into a fixed number of buckets, each bucket corresponding to an expert: ",
+        "bbox": [
+            174,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            90,
+            823,
+            119
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cfe98bfcd0bfc15878217a14dc8c8690b111a0a42206bc31be1edf515dbee074.jpg",
+        "text": "$$\n\\mathbf { h } _ { t } ^ { l } = \\mathrm { F F N } _ { \\mathrm { h a s h } ( x _ { t } ) } ( \\bar { \\mathbf { h } } _ { t } ^ { l } ) , \\quad t = 1 , \\ldots , T .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            366,
+            127,
+            632,
+            150
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "While the FFN still takes the hidden state $\\bar { \\mathbf { h } } _ { t } ^ { l }$ as input, our routing function uses the original input token $x _ { t }$ rather than the hidden state, see Figure 1 for a graphical depiction. We are free to choose from various possible hash functions, which we will consider below. However, for training purposes, the hash function is fixed in advance, and in this way, our routing mechanism requires no training and has no adjustable parameters. ",
+        "bbox": [
+            173,
+            159,
+            825,
+            229
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 Hash Functions ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            247,
+            323,
+            262
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Hash functions have long been employed throughout Computer Science [13], and can take a variety of forms. In our work, we generally employ pre-computed hash functions, which use a lookup table during learning – precomputed in advance – to map tokens to expert modules. ",
+        "bbox": [
+            174,
+            272,
+            825,
+            315
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We consider several kinds of hash functions as possible choices for routing tokens to expert modules. The simplest is Random Hash, wherein we assign every token to a fixed, random expert at initialization. Due to the Zipfian distribution of token frequency, this naturally produces imbalance across the different expert modules. As balancing has been previously shown to be important for training MoE models [8, 10], we also consider Balanced assignment. In this method, we build the lookup table before training the model using the training data distribution by greedily assigning the most frequent tokens to the emptiest buckets. The resulting assignment structure is significantly more balanced than Random Hashing, but not perfect, as the frequency of some tokens exceeds the ideal distribution. ",
+        "bbox": [
+            173,
+            321,
+            825,
+            433
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Random and Balanced hashing exploit the inductive bias of auto-regressive models and hash on the input token, but we also consider other possibilities: Bigram Hash uses the current and previous token $( x _ { t - 1 } , x _ { t } )$ rather than only the current token, while Previous Token Hash uses the previous token $x _ { t - 1 }$ , ignoring the current input. We also consider a sanity check which hashes based on the Position in the sequence, which we expect to have little impact, as absolute positions carry little information in natural language. Each of these hash functions is used to assess the value of the information being routed-on in our subsequent experimental analysis. ",
+        "bbox": [
+            173,
+            438,
+            825,
+            536
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "As an upper baseline, we also evaluate using an Oracle Future Hash, which hashes based on the output token $x _ { t + 1 }$ , rather than input token. This Oracle Hash checks how powerful routing decisions can be in solving a task. Similarly, we also consider Predicted Future Token Hash, which utilizes a baseline Transformer to make a prediction of the output token, and then hashes over this prediction. ",
+        "bbox": [
+            173,
+            542,
+            825,
+            598
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Clustered Hashes Based on the intuition that similar tokens may want to be routed to the same expert, we also experiment with Clustered Hashes. We obtain clusters by performing k-means clustering with a fixed number of clusters using token embeddings from a baseline Transformer model. Each expert is assigned a centroid, and tokens are assigned to their closest cluster. ",
+        "bbox": [
+            174,
+            614,
+            825,
+            670
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Dispersed Hashes We also consider the opposite hypothesis: that similar-tokens should be placed in different buckets, where the assumption is that very similar tokens need fine distinctions which requires more model capacity (hence assigning to different experts). To do this, we use the same $\\mathbf { k }$ -means clusters as before, but distribute all tokens within each cluster equally across all buckets. ",
+        "bbox": [
+            174,
+            686,
+            825,
+            742
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 MultiHash Layers ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            761,
+            339,
+            776
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In the standard FFN MoE approach, all $K$ expert modules have independent parameters, but here we consider another option. It is known in the hashing literature that multiple hashes can provide better allocations in many contexts [14]. We consider such schemes in the context of sparse routing. Let us assume we are given $N$ different hashing functions, and for a given input token $x$ we compute these hashes, denoted as $k _ { m } =  { \\mathrm { h a s h } _ { m } } ( x )$ , $m = 1 , \\ldots , N$ . Assuming the usual expert FFN is a function $B ( \\mathrm { r e l u } ( A ( { \\bf h } ) ) )$ where $A : \\mathbb { R } ^ { d }  \\mathbb { R } ^ { D }$ and $B : \\mathbb { R } ^ { D }  \\mathbb { R } ^ { d }$ , we split the linear layers into $N$ segments, $A _ { m } : \\mathbb { R } ^ { d }  \\mathbb { R } ^ { D / N }$ and $B _ { m } : \\mathbb { R } ^ { D }  \\mathbb { R } ^ { d / N }$ . Then we compute: ",
+        "bbox": [
+            173,
+            786,
+            826,
+            888
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/15d3fe78a5c6a5ff67eec19e6531d67c90caaee6684124b657dc78c3fab5316f.jpg",
+        "text": "$$\n\\mathbf { v } = \\mathrm { r e l u } ( [ A _ { k _ { 1 } } ( \\mathbf { h } ) , \\dots , A _ { k _ { N } } ( \\mathbf { h } ) ] ) \\qquad \\mathrm { F F N } _ { \\mathrm { M H } } ( \\mathbf { h } ) = [ B _ { k _ { 1 } } ( \\mathbf { v } ) , \\dots , B _ { k _ { N } } ( \\mathbf { v } ) ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            245,
+            895,
+            751,
+            912
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "That is, use hashing to select the parameters we are going to use for each segment, and then concatenate them together. The advantage is that we are now no longer reliant on the quality of a single hash function, but have multiple chances to produce good quality partitions. This perhaps can also be seen as analogous to the multi-head attention process already used in Transformers. ",
+        "bbox": [
+            174,
+            92,
+            825,
+            147
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            165,
+            321,
+            183
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Sparse MoE models, where only a few expert modules are active for any input, in particular in the context of NLP, have been studied recently in [6, 11]. In these works, the gating is learned via backpropagation, perhaps with a regularizer to encourage load balancing across experts. [8] showed that models in [11] can be successfully trained with each input assigned to exactly one expert. Another such approach for Transformers, where the routing is learned via solving a linear assignment problem, is studied in [10]. [15] uses a different approach, where product keys enable nearest neighbor search to select parameters. More generally, using MoE to trade off compute time (at the cost of possible data fragmentation) has a long history, see e.g. [3, 7]. ",
+        "bbox": [
+            174,
+            196,
+            825,
+            309
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The approach in this work is different from all of these in that the assignments use no learning whatsoever, and instead make use of the inductive biases possible in the setting of natural language. In particular, we use the fact that $n$ -grams are themselves decent language models [16]. Thus this work is related to previous work attempting to combine neural and $n$ -gram language models [17, 18, 19, 20, 21, 22]. ",
+        "bbox": [
+            174,
+            314,
+            825,
+            383
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our work is also related to feature hashing in linear models and kernel methods [23, 24], where word or n-gram features are hashed to provide a new lower dimensional feature space. [23] showed that when performing such feature hashing the interaction between random subspaces is negligible with high probability. [25] uses hashing to compress neural networks, rather than increase their parameters as we do here. Work on long-context Transformers has recently used hashing techniques to speed up access to long-range token history via sparse self-attention patterns, particularly in Routing Transformers [26] and the Reformer [27]. In contrast, our work uses hashing to access a large set of parameters via sparse routing, rather than sparse access to input features. ",
+        "bbox": [
+            174,
+            390,
+            825,
+            501
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "5 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            520,
+            312,
+            537
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "5.1 Tasks ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            550,
+            253,
+            565
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Pushshift.io Reddit We use a variant of Reddit discussions, which has also been used in several existing studies, see e.g. [28, 29, 30, 31]. Following [32], we use a previously existing Reddit dataset extracted and obtained by a third party and made available on pushshift.io [33], training to generate a comment conditioned on the full thread leading up to the comment, spanning 1.5B training examples. We use the same BPE dictionary as [34], comprising of 8008 tokens. ",
+        "bbox": [
+            174,
+            575,
+            825,
+            646
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "RoBERTa+cc100en Data We use the same data used to train BASE [10], which consists of approximately 100B tokens, combining corpora used in RoBERTa [35] with the English subset of the CC100 corpus [36]. The GPT2 dictionary, of size 51200, is used for tokenization. For our seq2seq experiments, we arrange this data splitting by sentence to predict the next turn. We consider it as the originally intended language modeling task in our experiments comparing with BASE [10]. ",
+        "bbox": [
+            174,
+            656,
+            825,
+            727
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Wikitext-103 Wikitext-103 is a smaller language modeling benchmark [37] consisting of a collection of Wikipedia articles of over 100 million tokens, and a fixed vocabulary size of 270K tokens is provided. We view this as a seq2seq task in our experiments, again splitting by sentence. ",
+        "bbox": [
+            174,
+            737,
+            825,
+            780
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Downstream BST tasks Finally, we use the Blended Skill Talk (BST) dialogue tasks used in [34] after pushshift.io Reddit pre-training to evaluate fine-tuning performance of dense vs. sparse models. ",
+        "bbox": [
+            171,
+            790,
+            825,
+            819
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "5.2 Experimental Setup ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            834,
+            351,
+            849
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Seq2Seq Setup The majority of our experiments are carried out in ParlAI1 platform using an encoder-decoder Transformer framework. We first train several standard (dense) Transformers, with ",
+        "bbox": [
+            174,
+            859,
+            823,
+            888
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/51ccfffda1227951052731fae1b053f304a0df67380dae64b46ea1b7ca842984.jpg",
+        "table_caption": [
+            "Table 1: Comparison of Models on pushshift.io Reddit. We show three sizes of dense Transformer compared to Switch Transformers and using Hash Layers with various numbers of modules and sparse layers, e.g. $5 \\mathrm { x } 1 6$ means 5 sparse layers with 16 modules each. All Switch and Hash Layer modules are built to the same computational complexity as the 11 layer baseline Transformer, but have more parameters; the larger dense models have similar total parameters, but use more compute. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Configuration</td><td>Params</td><td>Valid PPL</td><td>Test PPL</td></tr><tr><td>Baseline Transformer</td><td>layers=11,d=1024,D=4096</td><td>222M</td><td>24.90</td><td>24.96</td></tr><tr><td>Wider Transformer (more compute)</td><td>layers=11,d=2048,D=6144</td><td>755M</td><td>23.32</td><td>23.38</td></tr><tr><td>Deeper Transformer (more compute)</td><td>layers=22,d=1536,D=4096</td><td>755M</td><td>22.72</td><td>22.78</td></tr><tr><td>Switch Transformer</td><td>layers=11,modules=1x64,load_bal=0.1</td><td>751M</td><td>23.65</td><td>23.73</td></tr><tr><td>Hash Layer</td><td>layers=11,modules=1x64</td><td>751M</td><td>23.16</td><td>23.23</td></tr><tr><td>Switch Transformer</td><td>layers=11,modules=1x128,load_bal=0.1</td><td>1.28B</td><td>23.52</td><td>23.58</td></tr><tr><td>Hash Layer</td><td>layers=11,modules=1x128</td><td>1.28B</td><td>22.89</td><td>22.95</td></tr><tr><td>Switch Transformer</td><td>layers=11,modules=5x16,load_bal=0.01</td><td>852M</td><td>23.19</td><td>23.25</td></tr><tr><td>Switch Transformer</td><td>layers=11,modules=5x16,load_bal=0.1</td><td>852M</td><td>23.00</td><td>22.93</td></tr><tr><td>Hash Layer</td><td>layers=11,modules=5x16</td><td>852M</td><td>23.21</td><td>23.27</td></tr></table>",
+        "bbox": [
+            176,
+            165,
+            826,
+            321
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/737e284eca309f74133b928e170e11b5f87f5ee97407038ed3e4b919c7158402.jpg",
+        "table_caption": [
+            "Table 2: Comparison of Models on RoBERTa $^ +$ cc100en Data. We compare a dense transformer with the same parameters as our sparse models, except with 1 sparse layer with 64 modules (1x64). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Configuration</td><td>Params</td><td>Valid PPL</td></tr><tr><td>Baseline Transformer</td><td>layers=11,d=1024,D=4096</td><td>266M</td><td>28.85</td></tr><tr><td>Switch Transformer</td><td>layers=11,modules=1x64,load_bal=0.1</td><td>795M</td><td>27.41</td></tr><tr><td>Hash Layer</td><td>layers=11,modules=1x64</td><td>794M</td><td>26.99</td></tr></table>",
+        "bbox": [
+            241,
+            371,
+            754,
+            433
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2 encoder layers and either 11 or 22 decoder layers, following the structure in [34] for training on pushshift.io Reddit. We refer to the one with 11 layers and embedding size of $d = 1 0 2 4$ and FFN hidden layer size of $D = 4 0 9 6$ as our Baseline Transformer. We also train a \"Wider\" model with $D = 6 1 4 4$ , and a \"Deeper\" model with 22 decoder layers, and $D = 4 0 9 6$ . The Baseline model has 222M parameters, and the \"Wider\" and \"Deeper\" are selected to both have ${ 7 5 5 } \\mathbf { M }$ parameters each. These models are compared to the Hash Layer methods detailed in section 3 and to Switch Transformers of the same sizes and settings. The load balancing for Switch is optimized on the validation set. For both Hash and Switch we use the \"Baseline\" Transformer size detailed above as the architecture that we add sparse routing layers to by replacing one or more of the original dense layers. All experiments are run for 100k updates; a table of hyperparameters is provided in subsection B.1. ",
+        "bbox": [
+            173,
+            459,
+            825,
+            598
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "BASE Comparison While most of our analysis takes place in the setup described above with models up to 1.28B parameters, to test our methods at scale on larger sparse models, we adopt the BASE Layer setup [10] and code base2 instead where we compare 4.5B parameter Hash and BASE Layer models. This setting uses pure language models rather than the Seq2Seq setup above. We use the architecture, data (RoBERTa+cc100en), and hyperparameters directly from [10], using either a single sparse routing layer consisting of 3 stacked FFNs $D = 8 1 9 2$ ) on the middle layer of a 25 layer network, or 3 routing layers evenly spaced in the network. In order to compare with BASE directly, we keep all hyperparameters fixed and only change the routing method; we use a balanced assignment Hash Layer in this case. We trained until 40k steps had been reached. A table of hyperparameters is provided in subsection B.2. ",
+        "bbox": [
+            173,
+            611,
+            825,
+            750
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5.3 Results and Analysis ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            767,
+            356,
+            782
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5.3.1 Comparison between Hash, Switch and Dense models ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            792,
+            596,
+            808
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Hash vs. Switch routing on a single layer We first compare a Hash layer (with balanced hash) to a Switch layer, on an otherwise dense Transformer, where sparse routing is performed on layer 7 of the decoder. Both methods use 64 expert FFNs with 751M total parameters. Results on pushshift.io Reddit are given in Table 1 (rows 4 and 5) and on the RoBERTa+cc100en data in Table 2 (rows 2 and 3). We find Hash Layers outperforming Switch on both datasets by about 0.4-0.5 perplexity. ",
+        "bbox": [
+            174,
+            818,
+            825,
+            888
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/38e3adf8c3e5c944343b8a66221296c62f3dd6aaa50568bd72a04b8f80797965.jpg",
+        "image_caption": [
+            "Figure 2: Comparison of Hash Layers with other models. (left) Validation perplexity of a baseline Transformer, Switch Transformer, and Hash Layer on the pushshift.io Reddit dataset with 128 modules. (right) Validation perplexity of BASE, Hash Layer, and a deeper Hash Layer model on the RoBERTa+cc100en dataset. All sparse models have the same number of parameters. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            207,
+            92,
+            789,
+            222
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/e9821b650a8cee3619053871c71f76b3a3a1e1fdd770c0d62211166988012056.jpg",
+        "image_caption": [
+            "Figure 3: Comparing Different Number of Expert Modules and Layer Position. We compare (left) the validation perplexity wrt. the number of expert modules on the pushshift.io Reddit task for a Hash or Switch Layer on layer 7 of an 11 layer decoder in a Transformer. The baseline Transformer obtains a perplexity of 24.9. We compare the performance when adjusting the layer position of a 64 module Hash Layer on the same task (right). Placing on later layers works best. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            310,
+            810,
+            424
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Dense vs. Sparse Models Both Hash and Switch sparse models outperform the dense Baseline (222M parameters) they are based on, as well as the Wider Transformer (755M parameters). However, the Deeper Transformer (755M parameters) outperforms the sparse models which have a similar number of parameters. However, we note that due to its dense rather than conditional compute it is slower in inference speed. We see this as a general trend: good dense models can get more power out of the same number of parameters than sparse models. However, sparse models, although more wasteful in memory, give better perplexity for the same speed (i.e, we should compare to the Baseline Transformer in this case, which has roughly the same amount of computation). ",
+        "bbox": [
+            173,
+            536,
+            825,
+            648
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Hash layer module size We conduct the same pushshift.io Reddit experiments as above, but altering the number of expert modules in both Hash and Switch. Increasing from 64 to 128 modules (1.28B parameters total) sees an even larger improvement of Hash over Switch (about 0.6 perplexity), see Table 1 (rows 6 and 7), and Figure 2 (left). Trying smaller numbers of modules, 16 and 32, and plotting all the results in Figure 3 (left) we see that for small numbers of modules Hash and Switch perform similarly, but the gap grows larger as the number of modules increases. For small numbers of modules, we hypothesize that learning to route, as Switch does, would be more important to be performant with those choices, but with larger numbers of modules many routing choices could work. Hence, Hash layers can work well in that setting, and learning to route becomes less important. ",
+        "bbox": [
+            173,
+            661,
+            825,
+            786
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Hash layer position We also experiment to find the best position layer-wise for the sparse routing to take place. In Figure 3 (right) we plot perplexity for the 64 module Hash Layer, placing on different layers of the decoder. We find that later layers perform better, but even the worst performing choice (layer 1) is still performing well compared to other baselines: as good as Switch Transformers using later layers in fact. We note that analysis of BASE Layers [10] showed a similar trend that later layers work well. Hypothesizing that conditional compute gives the ability to make fine-grained specializations, it follows that it is worth making those distinctions after more obvious features have first been extracted. We will return to this argument in later experiments. ",
+        "bbox": [
+            173,
+            801,
+            825,
+            912
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/f711c252dacc82166509d939efebb2d7892082b0388b8acfd9f97b522bb19c2a.jpg",
+        "image_caption": [
+            "Figure 4: Relative frequency for 64 expert modules with Random Hash (left) and Balanced Hash (right). The Zipfian distribution makes perfect balance impossible, but Balanced Hash is closer. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            209,
+            109,
+            789,
+            395
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Multi-layer routing We evaluate placing sparse routing every other layer, 16 different modules each in Table 1 (rows 8-10). Switch and Hash perform similarly in this setting, with Switch outperforming with the optimal choice of 0.1 load balancing (23.00 vs. 23.21), and the same performance (23.19) for balancing parameter 0.01. Given the results of Figure 3 (left), the small number of modules in this case may make performance close. ",
+        "bbox": [
+            174,
+            465,
+            825,
+            535
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Downstream fine-tuning We compare several of the pushshift.io Reddit models for the goal of fine-tuning on downstream tasks. We experiment with either fine-tuning the whole model, or freezing some parts of the model during fine-tuning, as well as altering the load balancing for Switch at fine-tune time. Results are given in Appendix A. We find that the fine-tune results generally agree with the original performance on the pre-training pushshift.io Reddit task, and the order of methods is retained. Hash outperforms Switch slightly, both outperform the Baseline model, and the larger dense models perform better, as expected. Freezing parts of the model generally hurts fine-tuning, unless the part frozen is the sparse part of the model. It appears in that case just fine-tuning the dense parts of the model is sufficient for good performance. Only tuning the sparse part of the model, on the other hand, hurts performance, perhaps because the majority of the capacity of the model lies there. ",
+        "bbox": [
+            174,
+            547,
+            825,
+            686
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.3.2 Hash Function Analysis ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            702,
+            392,
+            717
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We evaluate the different choices of hashing function detailed in subsection 3.1. The overall results are given in Table 3 on the pushshift.io Reddit dataset using a 64 module Hash Layer. ",
+        "bbox": [
+            173,
+            727,
+            823,
+            755
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Random and Balanced Hash Functions We find that fixed random assignment (row 3) and balanced assignment (row 2) perform similarly well in terms of perplexity (23.22 vs. 23.16 valid perplexity). However, balanced assignment, as its name suggests, is more balanced, see Figure 4, which may render it more efficient in terms of distributed training schemes. ",
+        "bbox": [
+            174,
+            762,
+            825,
+            819
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Clustering Hash Functions Interestingly, using cluster based hashes (“Token clustering”, row 4) performs clearly worse than randomized hashes (23.90 vs. 23.22). We hypothesize that if the goal of conditional computation is to make fine distinctions, then those distinctions are more likely to appear between tokens within the same cluster, hence they should be in different hashes (parts of the compute graph), not the same one. We provide partial evidence for this by hashing within token clusters instead (“Dispersed Hash”, row 5), which restores the performance to be similar to random hashes (23.17 vs. 23.22). We note that learn-to-route methods such as Switch Transformers and BASE use simple functions of the hidden state to perform routing, which generally provide clustered expert modules [10], which could hence be a disadvantage for those methods. ",
+        "bbox": [
+            174,
+            828,
+            823,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/a1885d12a41d26cbdca0641f965a3c0c62f37adb94d4952140eec7183a7a8ec7.jpg",
+        "table_caption": [
+            "Table 4: Comparison of Models on Wikitext-103. We compare a baseline dense Transformer to our sparse models, which have 1 sparse layer with 16 modules (1x16). We show results with two different dictionaries, the BB [34] BPE dictionary (8008 tokens) and the standard one for the task (267,739 tokens). As these are different dictionaries, perplexities are not comparable across columns. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Configuration</td><td>Std. Dict Valid PPL</td><td>BB Dict Valid PPL</td></tr><tr><td>Baseline Transformer</td><td>layers=8,d=512,D=512</td><td>33.09</td><td>12.58</td></tr><tr><td>Switch Transformer</td><td>layers=8,modules=1x16,load_bal=0.1</td><td>31.76</td><td>11.67</td></tr><tr><td>Hash Layer</td><td>layers=8,modules=1x16</td><td>32.32</td><td>11.58</td></tr></table>",
+        "bbox": [
+            218,
+            151,
+            779,
+            232
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            257,
+            825,
+            299
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Position-based Hash Function We conduct experiments hashing based on sequence position only. We consider this experiment as a sanity check, we did not expect choosing conditional compute based on position in the output sequence to help. Indeed, it turns out that this is no better than the dense Transformer baseline. Thus it appears that routing based on input content is much more important. ",
+        "bbox": [
+            174,
+            308,
+            825,
+            363
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Bigram Hash Function Hashing based on the last two tokens (bigrams) performs worse than using only the last token (24.19 vs. 23.16). We hypothesize there are two reasons for this: (1) first, the last token is clearly the most pertinent, and bigrams add a less relevant feature; (2) this creates too many hashes, which performs less well. Subsequent experiments will help test these claims. ",
+        "bbox": [
+            174,
+            371,
+            825,
+            426
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Previous Token Hashing Hashing based on the previous token is clearly worse than using the current token (24.16 vs. 23.16), and gives similar performance to using bigrams, helping confirm the first part of our above bigram hypothesis. ",
+        "bbox": [
+            174,
+            435,
+            825,
+            477
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Dictionary size We perform experiments on Wikitext-103 in two settings: using the given dictionary of 267k tokens, or using the 8k dictionary we use in our pushshift.io Reddit experiments, following [34]. The results, comparing to Switch and a baseline Transformer, are given in Table 4. We find that Hash works well for the small dictionary, slightly outperforming Switch. However, on the larger dictionary, it performs worse than Switch. As this is the same data but just the tokenization has changed we conclude the hashing induced from the smaller dictionary is easier to learn from, helping confirm the second part of our above bigram hypothesis. ",
+        "bbox": [
+            174,
+            484,
+            825,
+            583
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Oracle Future Token Hashing We evaluate hashing using the oracle next token that is to be predicted. This yields a perplexity of 1.9. Using oracle information just to choose between modules is sufficient to essentially solve a task. ",
+        "bbox": [
+            176,
+            590,
+            821,
+            632
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Predicted Future Token Hashing The last result poses the question: if we can predict the next token, and hash based on that prediction instead – will it be better than hashing on the current token? We thus tried hashing using the Baseline Transformer to predict labels, yielding a perplexity of 25.02 – which does not actually beat the Baseline itself. It appears that the bias of the token predictions limits the ability of the sparse routing to improve. ",
+        "bbox": [
+            173,
+            640,
+            825,
+            710
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Multi-hashing We evaluate the multi-hashing technique described in subsection 3.2. Results are given in Appendix A, comparing to Switch and standard hashing. Even though the same number of parameters is used in all cases, we see improvements for splitting the hash into 2, 4 or 8 different hashes compared to a single hash, with steadily improving results for both 16 or 32 modules. ",
+        "bbox": [
+            174,
+            718,
+            825,
+            773
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.3.3 Switch Transformer Analysis ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            789,
+            428,
+            803
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Switch load balancing We show the performance of Switch for different values of the load balancing parameter on pushshift.io Reddit in Appendix A. Clearly the choice of parameter is important, with results varying over a 1 perplexity point range. ",
+        "bbox": [
+            176,
+            806,
+            825,
+            848
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Switch with Token-based Routing Given our analysis of oracle and predicted token hashing in subsection 5.3.2, we hypothesize that the hidden representations in layers of the Transformer, being biased towards the predictions of the model, may be suboptimal for routing. We therefore experiment with a hybrid between Switch and Hash Layers: on the sparse layer, instead of using hidden state as the Switch router input, we use the current token instead. To convert the token to a vector we use an extra lookup table, i.e., an extra set of learnable parameters that is the size of the dictionary. These parameters are independent of the hidden state and are only used by the router to learn the best route. Results are given in Table 6. We find this brings some small improvements to Switch for 64 and 128 modules on a single layer, affirming the usefulness of token-based routing. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/140e7040321133d0dbe99bda94e7377f690c2c7a58e7bc7eb04955cf09402561.jpg",
+        "table_caption": [
+            "Table 5: Multi-hashing experiments on pushshift.io Reddit. When multi-hashing, the same number of parameters is used, but the FFN weights are split and indexed into multiple hashes and then concatenated together for the forward step. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Configuration</td><td>Params</td><td>Valid PPL</td><td>Test PPL</td></tr><tr><td>Switch Transformer</td><td>layers=11,modules=1x32,load_bal=0.1</td><td>483M</td><td>23.79</td><td>23.84</td></tr><tr><td>Hash Layer</td><td>layers=11,modules=1x32</td><td>483M</td><td>23.58</td><td>23.65</td></tr><tr><td>MultiHash Layer</td><td>layers=11,modules=1x32,hashes=2</td><td>483M</td><td>23.48</td><td>23.53</td></tr><tr><td>MultiHash Layer</td><td>layers=11,modules=1x32,hashes=4</td><td>483M</td><td>23.38</td><td>23.45</td></tr><tr><td>MultiHash Layer</td><td>layers=11,modules=1x32,hashes=8</td><td>483M</td><td>23.28</td><td>23.34</td></tr></table>",
+        "bbox": [
+            215,
+            133,
+            781,
+            218
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/38122f27648ccac53166bdb5d0440b3bc4eeeee6edac63a8dedfe6e4270f411d.jpg",
+        "table_caption": [
+            "Table 6: Switch Transformers with Token-Based Routing on pushshift.io Reddit. We compare standard Switch which routes based on the hidden state to token feature-routing (‘Token Switch’). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Configuration</td><td>Params</td><td>Valid PPL</td><td>Test PPL</td></tr><tr><td>Switch Transformer</td><td>layers=11,modules=1x64,load_bal=0.1</td><td>751M</td><td>23.65</td><td>23.73</td></tr><tr><td>Token Switch</td><td>layers=11,modules=1x64,load_bal=0.1</td><td>751M</td><td>23.43</td><td>23.43</td></tr><tr><td>Switch Transformer</td><td>layers=11,modules=1x128,load_bal=0.1</td><td>1.28B</td><td>23.52</td><td>23.58</td></tr><tr><td>Token Switch</td><td>layers=11,modules=1x128,load_bal=0.1</td><td>1.28B</td><td>23.26</td><td>23.32</td></tr></table>",
+        "bbox": [
+            212,
+            262,
+            785,
+            342
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            367,
+            825,
+            436
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.3.4 Comparison to BASE Layers ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            450,
+            426,
+            465
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We next compare to BASE Layers. Using the BASE Layer code base, we implement Hash Layers in exactly the same setup, changing only the routing method, and leaving everything else fixed. Figure 2 (right) shows results comparing Hash with BASE for 4.5B parameter models. Across the entire run, we see that Hash outperforms BASE at each training step. During early parts of training, Hash would presumably have an advantage in being able to specialize expert modules earlier, while BASE must learn membership for each of the expert modules. Later in training, BASE becomes mildly unstable presumably as expert assignments shift, while Hash performance continues to improve smoothly. ",
+        "bbox": [
+            173,
+            468,
+            825,
+            564
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Additionally, to demonstrate Hash Layers remain performant when stacked, we trained a model with 3 Hash Layers (using random hashes), but fewer parameters per expert module so the total parameters remained constant at 4.5B (see subsection B.2). We find that using multiple Hash Layers gives a small but consistent improvement, suggesting Hash Layers will be effective at even more depth. ",
+        "bbox": [
+            174,
+            570,
+            825,
+            626
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In addition to performance gains compared to BASE, we also find that Hash Layers are more efficient in total computation. In particular, BASE requires two all-to-all communications: the first de-correlates batches in order to make assignment balancing more stochastic, and the second routes states to their assigned expert. As Hash Layers use fixed, pre-computed assignments they avoid the decorrelation step. In practice, we find this gives an improvement of about $11 \\%$ in updates-per-second. As the number of expert layers increases, this difference will become more exaggerated. ",
+        "bbox": [
+            174,
+            632,
+            825,
+            715
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            734,
+            299,
+            752
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We have introduced a simple and efficient approach to sparse models in the Transformers-for-NLP setting based on hash layers. We showed on a variety of datasets and with analysis in various settings that this approach is highly competitive with existing methods such as Switch Transformers and BASE Layers, whilst being robust and far simpler – requiring no extra learning parameters, assignment algorithm or changes to the objective function. Given that researchers typically have only one opportunity to train very large models, this makes our approach a strong candidate for such runs. While our experiments scale up to 4.5B parameters, we do not reach the scales of large industrial works such as [8], and we hope to see future work conduct such experiments. Finally, given that our routing approach is learning free, our results perhaps suggest that none of the current approaches are routing particularly well. We thus believe learning-to-route should continue to be the study of future work, and consider our work a strong baseline for such research. ",
+        "bbox": [
+            174,
+            758,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "References   \n[1] Jared Kaplan, Sam McCandlish, Tom Henighan, Tom B Brown, Benjamin Chess, Rewon Child, Scott Gray, Alec Radford, Jeffrey Wu, and Dario Amodei. Scaling laws for neural language models. arXiv preprint arXiv:2001.08361, 2020.   \n[2] Robert A Jacobs, Michael I Jordan, Steven J Nowlan, and Geoffrey E Hinton. Adaptive mixtures of local experts. Neural computation, 3(1):79–87, 1991.   \n[3] Yoshua Bengio, Réjean Ducharme, Pascal Vincent, and Christian Janvin. A neural probabilistic language model. The journal of machine learning research, 3:1137–1155, 2003.   \n[4] Seniha Esen Yuksel, Joseph N Wilson, and Paul D Gader. Twenty years of mixture of experts. IEEE transactions on neural networks and learning systems, 23(8):1177–1193, 2012.   \n[5] David Eigen, Marc’Aurelio Ranzato, and Ilya Sutskever. Learning factored representations in a deep mixture of experts. arXiv preprint arXiv:1312.4314, 2013.   \n[6] Noam Shazeer, Azalia Mirhoseini, Krzysztof Maziarz, Andy Davis, Quoc Le, Geoffrey Hinton, and Jeff Dean. Outrageously large neural networks: The sparsely-gated mixture-of-experts layer. arXiv preprint arXiv:1701.06538, 2017.   \n[7] Sam Gross, Marc’Aurelio Ranzato, and Arthur Szlam. Hard mixtures of experts for large scale weakly supervised vision. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 6865–6873, 2017.   \n[8] William Fedus, Barret Zoph, and Noam Shazeer. Switch transformers: Scaling to trillion parameter models with simple and efficient sparsity. arXiv preprint arXiv:2101.03961, 2021.   \n[9] Ronan Collobert, Yoshua Bengio, and Samy Bengio. Scaling large learning problems with hard parallel mixtures. International Journal of pattern recognition and artificial intelligence, 17 (03):349–365, 2003.   \n[10] Mike Lewis, Shruti Bhosale, Tim Dettmers, Naman Goyal, and Luke Zettlemoyer. Base layers: Simplifying training of large, sparse models. arXiv preprint arXiv:2103.16716, 2021.   \n[11] Dmitry Lepikhin, HyoukJoong Lee, Yuanzhong Xu, Dehao Chen, Orhan Firat, Yanping Huang, Maxim Krikun, Noam Shazeer, and Zhifeng Chen. Gshard: Scaling giant models with conditional computation and automatic sharding. arXiv preprint arXiv:2006.16668, 2020.   \n[12] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in neural information processing systems, pages 5998–6008, 2017.   \n[13] Thomas H Cormen, Charles E Leiserson, Ronald L Rivest, and Clifford Stein. Introduction to algorithms. MIT press, 2009.   \n[14] Andrei Z Broder and Anna R Karlin. Multilevel adaptive hashing. In Proceedings of the first annual ACM-SIAM symposium on Discrete algorithms, pages 43–53, 1990.   \n[15] Guillaume Lample, Alexandre Sablayrolles, Marc’Aurelio Ranzato, Ludovic Denoyer, and Hervé Jégou. Large memory layers with product keys. In Advances in Neural Information Processing Systems, pages 8548–8559, 2019.   \n[16] Reinhard Kneser and Hermann Ney. Improved backing-off for m-gram language modeling. In 1995 international conference on acoustics, speech, and signal processing, volume 1, pages 181–184. IEEE, 1995.   \n[17] Tomáš Mikolov, Martin Karafiát, Lukáš Burget, Jan Cernock ˇ y, and Sanjeev Khudanpur. Recur- \\` rent neural network based language model. In Eleventh annual conference of the international speech communication association, 2010.   \n[18] Ciprian Chelba, Tomas Mikolov, Mike Schuster, Qi Ge, Thorsten Brants, Phillipp Koehn, and Tony Robinson. One billion word benchmark for measuring progress in statistical language modeling. arXiv preprint arXiv:1312.3005, 2013. ",
+        "bbox": [
+            171,
+            64,
+            828,
+            917
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[19] Graham Neubig and Chris Dyer. Generalizing and hybridizing count-based and neural language models. arXiv preprint arXiv:1606.00499, 2016. ",
+        "bbox": [
+            171,
+            90,
+            823,
+            119
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[20] Sébastien Jean, Kyunghyun Cho, Roland Memisevic, and Yoshua Bengio. On using very large target vocabulary for neural machine translation. arXiv preprint arXiv:1412.2007, 2014. ",
+        "bbox": [
+            174,
+            127,
+            823,
+            157
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[21] Armand Joulin, Moustapha Cissé, David Grangier, Hervé Jégou, et al. Efficient softmax approximation for gpus. In International Conference on Machine Learning, pages 1302–1310. PMLR, 2017. ",
+        "bbox": [
+            174,
+            165,
+            825,
+            208
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[22] Anton Bakhtin, Arthur Szlam, Marc’Aurelio Ranzato, and Edouard Grave. Lightweight adaptive mixture of neural and n-gram language models. arXiv preprint arXiv:1804.07705, 2018. ",
+        "bbox": [
+            174,
+            217,
+            825,
+            246
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[23] Kilian Weinberger, Anirban Dasgupta, John Langford, Alex Smola, and Josh Attenberg. Feature hashing for large scale multitask learning. In Proceedings of the 26th annual international conference on machine learning, pages 1113–1120, 2009. ",
+        "bbox": [
+            174,
+            253,
+            825,
+            297
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[24] Bing Bai, Jason Weston, David Grangier, Ronan Collobert, Kunihiko Sadamasa, Yanjun Qi, Olivier Chapelle, and Kilian Weinberger. Learning to rank with (a lot of) word features. Information retrieval, 13(3):291–314, 2010. ",
+        "bbox": [
+            174,
+            305,
+            823,
+            348
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[25] Wenlin Chen, James Wilson, Stephen Tyree, Kilian Weinberger, and Yixin Chen. Compressing neural networks with the hashing trick. In International conference on machine learning, pages 2285–2294. PMLR, 2015. ",
+        "bbox": [
+            174,
+            356,
+            823,
+            400
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[26] Aurko Roy, Mohammad Saffar, Ashish Vaswani, and David Grangier. Efficient content-based sparse attention with routing transformers. Transactions of the Association for Computational Linguistics, 9:53–68, 2021. ",
+        "bbox": [
+            174,
+            407,
+            825,
+            450
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[27] Nikita Kitaev, Łukasz Kaiser, and Anselm Levskaya. Reformer: The efficient transformer. arXiv preprint arXiv:2001.04451, 2020. ",
+        "bbox": [
+            173,
+            458,
+            821,
+            488
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[28] Yinfei Yang, Steve Yuan, Daniel Cer, Sheng-yi Kong, Noah Constant, Petr Pilar, Heming Ge, Yun-Hsuan Sung, Brian Strope, and Ray Kurzweil. Learning semantic textual similarity from conversations. In Proceedings of The Third Workshop on Representation Learning for NLP, pages 164–174, Melbourne, Australia, July 2018. Association for Computational Linguistics. ",
+        "bbox": [
+            174,
+            496,
+            826,
+            553
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[29] Pierre-Emmanuel Mazaré, Samuel Humeau, Martin Raison, and Antoine Bordes. Training millions of personalized dialogue agents. In Proceedings of the 2018 Conference on Empirical Methods in Natural Language Processing, pages 2775–2779, Brussels, Belgium, OctoberNovember 2018. Association for Computational Linguistics. ",
+        "bbox": [
+            174,
+            561,
+            826,
+            618
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[30] Nitish Shirish Keskar, Bryan McCann, Lav R Varshney, Caiming Xiong, and Richard Socher. CTRL: A conditional transformer language model for controllable generation. arXiv preprint arXiv:1909.05858, 2019. ",
+        "bbox": [
+            174,
+            626,
+            821,
+            670
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[31] Kurt Shuster, Da Ju, Stephen Roller, Emily Dinan, Y-Lan Boureau, and Jason Weston. The dialogue dodecathlon: Open-domain knowledge and image grounded conversational agents, 2019. ",
+        "bbox": [
+            174,
+            678,
+            825,
+            719
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[32] Samuel Humeau, Kurt Shuster, Marie-Anne Lachaux, and Jason Weston. Poly-encoders: Architectures and pre-training strategies for fast and accurate multi-sentence scoring. In Proceedings of the International Conference on Learning Representations, 2019. ",
+        "bbox": [
+            173,
+            728,
+            825,
+            772
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[33] Jason Baumgartner, Savvas Zannettou, Brian Keegan, Megan Squire, and Jeremy Blackburn. The pushshift reddit dataset. arXiv preprint arXiv:2001.08435, 2020. ",
+        "bbox": [
+            169,
+            780,
+            825,
+            810
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[34] Stephen Roller, Emily Dinan, Naman Goyal, Da Ju, Mary Williamson, Yinhan Liu, Jing Xu, Myle Ott, Kurt Shuster, Eric M Smith, et al. Recipes for building an open-domain chatbot. arXiv preprint arXiv:2004.13637, 2020. ",
+        "bbox": [
+            171,
+            818,
+            825,
+            861
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[35] Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, and Veselin Stoyanov. Roberta: A robustly optimized bert pretraining approach. arXiv preprint arXiv:1907.11692, 2019. ",
+        "bbox": [
+            174,
+            868,
+            826,
+            911
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[36] Alexis Conneau, Kartikay Khandelwal, Naman Goyal, Vishrav Chaudhary, Guillaume Wenzek, Francisco Guzmán, Edouard Grave, Myle Ott, Luke Zettlemoyer, and Veselin Stoyanov. Unsupervised cross-lingual representation learning at scale. arXiv preprint arXiv:1911.02116, 2019. ",
+        "bbox": [
+            174,
+            90,
+            826,
+            146
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[37] Stephen Merity, Caiming Xiong, James Bradbury, and Richard Socher. Pointer sentinel mixture models. arXiv preprint arXiv:1609.07843, 2016. ",
+        "bbox": [
+            168,
+            156,
+            825,
+            184
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[38] Myle Ott, Sergey Edunov, Alexei Baevski, Angela Fan, Sam Gross, Nathan Ng, David Grangier, and Michael Auli. fairseq: A fast, extensible toolkit for sequence modeling. arXiv preprint arXiv:1904.01038, 2019. ",
+        "bbox": [
+            173,
+            194,
+            823,
+            236
+        ],
+        "page_idx": 11
+    }
+]