Add files using upload-large-folder tool

parse/train/3FK30d5BZdu/3FK30d5BZdu.md

@@ -0,0 +1,445 @@
+# HIDDEN INCENTIVES FOR AUTO-INDUCED DISTRIBUTIONAL SHIFT
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Decisions made by machine learning systems have increasing influence on the world, yet it is common for machine learning algorithms to assume that no such influence exists. An example is the use of the i.i.d. assumption in content recommendation. In fact, the (choice of) content displayed can change users’ perceptions and preferences, or even drive them away, causing a shift in the distribution of users. We introduce the term auto-induced distributional shift (ADS) to describe the phenomenon of an algorithm causing a change in the distribution of its own inputs. Our goal is to ensure that machine learning systems do not leverage ADS to increase performance when doing so could be undesirable. We demonstrate that changes to the learning algorithm, such as the introduction of meta-learning, can cause hidden incentives for auto-induced distributional shift (HI-ADS) to be revealed. To address this issue, we introduce ‘unit tests’ and a mitigation strategy for HI-ADS, as well as a toy environment for modelling real-world issues with HIADS in content recommendation, where we demonstrate that strong meta-learners achieve gains in performance via ADS. We show meta-learning and Q-learning both sometimes fail unit tests, but pass when using our mitigation strategy.
+
+# 1 INTRODUCTION
+
+Consider a content recommendation system whose performance is measured by accuracy of predicting what users will click. This system can achieve better performance by either 1) making better predictions, or 2) changing the distribution of users such that predictions are easier to make. We propose the term auto-induced distributional shift (ADS) to describe this latter kind of distributional shift, caused by the algorithm’s own predictions or behaviour (Figure 1).
+
+![](images/833d9ac6619b77e4b4c37b9014af227c1cffc0cdcc8236556ae4c01b6b89cd90.jpg)  
+Figure 1: Distributions of users over time. Left: A distribution which remains constant over time, following the i.i.d assumption. Right: Auto-induced Distributional Shift (ADS) results in a change in the distribution of users in our content recommendation environment. (see Section 5.2 for details).
+
+ADS are not inherently bad, and are sometimes even desirable. But they can cause problems if they occur unexpectedly. It is typical in machine learning (ML) to assume (e.g. via the i.i.d. assumption) that (2) will not happen. However, given the increasing real-world use of ML algorithms, we believe it is important to model and experimentally observe what happens when assumptions like this are violated. This is the motivation of our work.
+
+In many cases, including news recommendation, we would consider (2) a form of cheating—the algorithm changed the task rather than solving it as intended. We care which means the algorithm used to solve the problem (e.g. (1) and/or (2)), but we only told it about the ends, so it didn’t know not to ’cheat’. This is an example of a specification problem (Leike et al., 2017; Ortega et al., 2018): a problem which arises from a discrepancy between the performance metric (maximize accuracy) and “what we really meant”: in this case, to maximize accuracy via (1).
+
+Ideally, we’d like to quantify the desirability of all possible means, e.g. assign appropriate rewards to all potential strategies and “side-effects”, but this is intractable for real-world settings. Using human feedback to learn reward functions which account for such impacts is a promising approach to specifying desired behavior (Leike et al., 2018; Christiano et al., 2017). But the same issue can arise whenever human feedback is used in training: one means of improving performance could be to alter human preferences, making them easier to satisfy. Thus in this work, we pursue a complementary approach: managing learners’ incentives.
+
+A learner has an incentive to behave in a certain way when doing so can increase performance (e.g. accuracy or reward). Informally, we say an incentive is hidden when the learner behaves as if it were not present. But we note that changes to the learning algorithm or training regime could cause previously hidden incentives to be revealed, resulting in unexpected and potentially undesirable behaviour. Managing incentives (e.g. controlling which incentives are hidden/ revealed) can allow algorithm designers to disincentivize broad classes of strategies (such as any that rely on manipulating human preferences) without knowing their exact instantiation.1
+
+The goal of our work is to provide insights and practical tools for understanding and managing incentives, specifically hidden incentives for auto-induced distributional shift: HI-ADS. To study which conditions cause HI-ADS to be revealed, we present unit tests for detecting HI-ADS in supervised learning (SL) and reinforcement learning (RL). We also create an environment that models ADS in news recommendation, illustrating possible effects of revealing HI-ADS in this setting.
+
+The unit tests both have two means by which the learner can improve performance: one which creates ADS and one which does not. The intended method of improving performance is one that does not induce ADS; the other is ’hidden’ and we want it to remain hidden. A learner "fails" the unit test if it nonetheless pursues the incentive to increase performance via ADS. In both the RL and SL unit tests, we find that introducing an outer-loop of meta-learning (e.g. Population-Based Training (PBT) Jaderberg et al. (2017)) can lead to high levels of failure. Similarly, recommender systems trained with PBT induce larger drifts in user base and user interests. These results suggest that failure of our unit tests indicates that an algorithm is prone to revealing HI-ADS in other settings. Finally, we propose and test a mitigation strategy we call context swapping. The strategy consists of rotating learners through different environments throughout learning, so that they can’t see the results or correlations of their actions in one environment over longer time horizons. This effectively mitigates HI-ADS in our unit test environments, but did not work well in content recommendation experiments.
+
+# 2 BACKGROUND
+
+# 2.1 META-LEARNING AND POPULATION BASED TRAINING
+
+Meta-learning is the use of machine learning techniques to learn machine learning algorithms. This involves instantiating multiple learning scenarios which run in an inner loop $\mathbf { \Pi } ( \mathbf { I I L } )$ , while an outer loop (OL) uses the outcomes of the inner loop(s) as data-points from which to learn which learning algorithms are most effective (Metz et al., 2019). The number of IL steps per OL step is called the interval. Many recent works focus on multi-task meta-learning, where the OL seeks to find learning rules that generalize to unseen tasks by training the IL on a distribution of tasks (Finn et al., 2017). Single-task meta-learning includes learning an optimizer for a single task (Gong et al., 2018), and adaptive methods for selecting models (Kalousis, 2000) or setting hyperparameters (Snoek et al., 2012). For simplicity in this initial study we focus on single-task meta-learning.
+
+Population-based training (PBT; Jaderberg et al., 2017) is a meta-learning algorithm that trains multiple learners $L _ { 1 } , . . . , L _ { n }$ in parallel, after each interval ( $T$ steps of IL) applying an evolutionary OL step which consists of: (1) Evaluate the performance of each learner, (2) Replace both parameters and hyperparameters of $20 \%$ lowest-performing learners with copies of those from the $20 \%$ highperforming learners (EXPLOIT). (3) Randomly perturb the hyperparameters (but not the parameters) of all learners (EXPLORE).
+
+# 2.2 DISTRIBUTIONAL SHIFT AND CONTENT RECOMMENDATION
+
+In general, distributional shift refers to change of the data distribution over time. In supervised learning with data $\mathbf { x }$ and labels $y$ , this can be more specifically described as dataset shift: change in the joint distribution of $P ( \mathbf { x } , y )$ between the training and test sets (Moreno-Torres et al., 2012; Quionero-Candela et al., 2009). As identified by Moreno-Torres et al. (2012), two common kinds of shift are: (1) Covariate shift: changing $P ( \mathbf { x } )$ . In the example of content recommendation, this corresponds to changing the user base of the recommendation system. For instance, a media outlet which publishes inflammatory content may appeal to users with extreme views while alienating more moderate users. This self-selection effect (Kayhan, 2015) may appear to a recommendation system as an increase in performance, leading to a feedback effect, as previously noted by Shah et al. (2018). This type of feedback effect has been identified as contributing to filter bubbles and radicalization (Pariser, 2011; Kayhan, 2015). (2) Concept shift: changing $P ( \boldsymbol { y } | \mathbf { x } )$ . In the example of content recommendation, this corresponds to changing a given user’s interest in different kinds of content. For example, exposure to a fake news story has been shown to increase the perceived accuracy of (and thus presumably future interest in) the content, an example of the illusory truth effect (Pennycook et al., 2019). For further details on such effects in content recommendation, see Appendix 8.
+
+# 3 AUTO-INDUCED DISTRIBUTION SHIFT (ADS)
+
+Auto-induced distribution shift (ADS) is distributional shift caused by an algorithm’s behaviour. This is in contrast to distributional shift which would happen even if the learner were not present - e.g. for a crash prediction algorithm trained on data from the summer, encountering snowy roads is an example of distributional shift, but not auto-induced distributional shift (ADS).
+
+![](images/e073c2dfa79ed13d098885e0aecd106a567f60dc458af17cb1a90e8412bd2143.jpg)
+
+Figure 2: The widely studied problems of reinforcement learning (RL) with state $s$ , action $a$ , reward $r$ tuples, and i.i.d. supervised learning (SL) with inputs $x$ , predictions $\hat { y }$ and loss $l$ (a,d) are free from incentive problems. We focus on cases where there are incentives present which the learner is not meant to pursue $^ { ( \mathbf { b } , \mathbf { c } ) }$ . Lines show paths of influence. The learner may have incentives to influence any nodes descending from its action, $A$ , or prediction, $\hat { y }$ . Which incentives are undesirable (orange) or desirable (cyan) for the learner to pursue is context-dependent.
+
+We emphasize that ADS are not inherently bad or good; often ADS can even be desirable: consider an algorithm meant to alert drivers of imminent collisions. If it works well, such a system will help drivers avoid crashing, thus making self-refuting predictions which result in ADS. What separates desirable and undesirable ADS? The collision-alert system alters its data distribution in a way that is aligned with the goal of fewer collisions, whereas the news manipulation results in changes that are misaligned with the goal of better predicting existing users’ interests (Leike et al., 2018).
+
+In reinforcement learning (RL), ADS are typically encouraged as a means to increase performance. On the other hand, in supervised learning (SL), the i.i.d. assumption precludes ADS in theory. In practice, however, the possibility of using ADS to increase performance (and thus an incentive to do so) often remains. For instance, this occurs in online learning. In our experiments, we explicitly model such situations where i.i.d. assumptions are violated: We study the behavior of SL and myopic RL algorithms, in environments designed to include incentives for ADS, in order to understand when incentives are effectively hidden. Fig. 2 contrasts these settings with typical RL and SL.
+
+# 4 INCENTIVES
+
+For our study of incentives, we use the following terminology: an incentive for a behavior (e.g. an action, a classification, etc.) is present (not absent) to the extent that the behaviour will increase performance (e.g. reward, accuracy, etc.) (Everitt & Hutter, 2019). This incentive is revealed to (not hidden from) a learner if it would, at higher than chance levels, learn to perform the behavior given sufficient capacity and training experience. The incentive is pursued (not eschewed) by a learner if it actually performs the incentivized behaviour. Note even when an incentive is revealed, it may not be pursued, e.g. due to limited capacity and/or data, or simply chance. See Fig 3.
+
+For example, in content recommendation, the incentive to drive users away is present if some user types are easier to predict than others. But this incentive may be hidden from the learner by using a myopic algorithm, e.g. one that does not see the effects of its actions on the distribution of users. The incentive might instead be revealed to the outer loop of a meta-learning algorithm like PBT, which does see the effects of learner’s actions.
+
+![](images/2ade91d4be27c22a6f418d3a986aa9448815d5a0ddb40aa939127276f08bc9bc.jpg)  
+Figure 3: Types of incentives, and their relationship to ADS.
+
+Even when this incentive is revealed, however, it might not end up being pursued. For example, this could happen if predicting which recommendations will drive away users is too difficult a learning problem, or if the incentive to do so is dominated by other incentives (e.g. change individual users’ interests, or improve accuracy of predictions). In general, it may be difficult to determine empirically which incentives are revealed, because failure to pursue an incentive can be due to limited capacity, insufficient training, and/or random chance. To address this challenge, we devise extremely simple environments (“unit tests”), where we can be confident that revealed incentives will be pursued.
+
+# 4.1 HIDDEN INCENTIVES FOR AUTO-INDUCED DISTRIBUTIONAL SHIFT (HI-ADS)
+
+Following from the definitions in Sections 3 and 4, HI-ADS are incentives for behaviors that cause Auto-induced Distributional Shift that are hidden from the learner, i.e. the learner would not learn to perform the incentivized behaviors at higher than chance levels, even given infinite capacity and training experience.
+
+Like ADS, HI-ADS are not necessarily problematic. Indeed, hiding incentives can be an effective method of influencing learner behavior. For example, hiding the incentive to manipulate users from a content recommendation algorithm could prevent it from influencing users in a way they would not endorse. However, if machine learning practitioners are not aware that incentives are present, or that properties of the learning algorithm are hiding them, then seemingly innocuous changes to the learning algorithm may reveal HI-ADS, and lead to significant unexpected changes in behavior.
+
+Hiding incentives for ADS may seem counter-intuitive and counter-productive in the context of reinforcement learning (RL), where moving towards high-reward states is typically desirable. However, for real-world applications of RL, the ultimate goal is not a system that achieves high reward, but rather one that behaves according to the designer’s intentions. And as we discussed in the introduction, it can be intractable to design reward functions that perfectly specify intended behavior. Thus managing (e.g. hiding) some incentives can provide a useful tool for specification, even in RL.
+
+We have several reasons for focusing on HI-ADS: (1) The issue of HI-ADS has not yet been identified, and thus is liable to be neglected in practice. Indeed, our “unit tests” are the first published empirical methodology for assessing whether incentives are hidden or revealed by different learning algorithms. (2) Machine learning algorithms are commonly deployed in settings where ADS are present, violating assumptions used to analyze their properties theoretically. This means learners could exploit ADS in unexpected and undesirable ways if incentives for ADS are revealed. Hiding these incentives heuristically (e.g. via off-line training) is a common approach, but potentially brittle (if practitioners don’t understand how HI-ADS could become revealed). In particular, meta-learning can reveal HI-ADS in online learning settings. (3) Substantial real-world issues could result from improper management of learner’s incentives. Examples include tampering with human-generated reward signals (Everitt & Hutter, 2018) (e.g. selecting news articles which manipulate user interests), and creating “self-fulfilling prophecies” (e.g. driving up the value of an asset by publicly predicting its value will increase (Armstrong & O’Rorke, 2017)).
+
+# 4.2 REMOVING HI-ADS VIA CONTEXT SWAPPING
+
+We propose a technique called context swapping for removing incentives for ADS. The technique trains $N$ learners in parallel, and shuffles the learners through $N$ different copies of the same (or similar) environments.We use a deterministic permutation of learners in environment copies, so that the $i$ -th learner inhabits the $j$ -th environment on time-steps $t$ where $~ j ~ = ~ ( i + t )$ mod $N$ , makes an observation, takes an action, and receives a reward before moving to the next environment.
+
+When $N$ is larger than the interval of the OL optimizer, each learner inhabits each copy for at most a single time-step before an OL step is applied. Under the assumption that different copies of the environment do not influence each other, this technique can address HI-ADS in practice, as we show in Sec. 5.1.1.
+
+![](images/06fd14fc3c3117d01ce92cc59924cf8d1fe7f705cf8d340291c9e7534c747cd1.jpg)  
+Figure 4: Context swapping (right).
+
+# 5 EXPERIMENTS
+
+In Section 5.1, we introduce ‘unit tests’ for HI-ADS. Our primary goal with these experiments is to convey a crisp understanding of potential issues caused by revealing HI-ADS. Put simply, our experiments show that you can have a learner which behaves as intended, and just by using metalearning (e.g. PBT), without changing the performance metric (e.g. loss or rewards), the learner’s behavior can change completely. We also show that context swapping is an effective mitigation technique in these environments. On the practical side, the unit tests can be used to compare learning algorithms and diagnose their propensity to reveal incentives.
+
+In Section 5.2, we model a content recommendation system. The goal of these experiments is to demonstrate how HI-ADS could create issues for real-world content recommendation systems such as news feeds, search results, or automated suggestions. They also validate the usefulness of the unit tests: algorithms that failed the unit tests also reveal HI-ADS in this setting. We emphasize that ADS takes place in this environment by construction. The point of our experiments is that meta-learning can increase the rate and/or extent of ADS, by revealing this incentive. We find that context swapping is not effective in this environment, highlighting the need for alternative mitigation strategies.
+
+# 5.1 HI-ADS UNIT TESTS
+
+Unit test 1: Supervised Learning. This unit test consists of a simple prediction problem. There are no inputs, only an underlying state $s \in \{ 0 , 1 \}$ , and targets $\boldsymbol { y } \in \mathbb { R } ^ { 2 }$ with $\chi _ { 1 } , y _ { 2 } \sim \mathcal { N } ( 0 , s * \sigma ^ { 2 } ) , \mathcal { N } ( 0 , 1 )$ , with corresponding predictions $\hat { y } _ { 1 } , \hat { y } _ { 2 }$ . Additionally, $s _ { t + 1 } = 0$ iff $\hat { y } _ { 2 } >$ .5. We use Mean Squared Error as the loss function, so the optimal predictor is $\hat { y _ { 1 } } , \hat { y _ { 2 } } = ( 0 , 0 )$ . However, predicting $\hat { y } _ { 2 } > . 5$ reduces the variance of $\hat { y _ { 1 } }$ , i.e. reduces future loss. The baseline/IL predictor learns $\hat { y _ { 1 } } , \hat { y _ { 2 } }$ as parameters using SGD with a learning rate of 0.001. For experiments with meta-learning, PBT is the OL (with default settings, see Section 2.2), used to tune the learning rate, with negative loss on the final time-step of the interval as the performance measure for PBT.
+
+Unit test 2: Myopic RL. This unit test is based on a modification of the prisoner’s dilemma (Prisner, 2014) where an agent plays each round against its past self. The reward function is presented in Table 1. An agent in this environment has a long-term, non-myopic, incentive for cooperation (with its future self), but a current-time-step, myopic, incentive for defection (from its future self).
+
+The unit test evaluates whether a agent reveals the non-myopic incentive even when the agent is meant to optimize for the present reward only (i.e. uses discount rate $\gamma = 0$ ). Naively, we’d expect the nonmyopic incentive to be hidden from the agent in this case, and for the agent to consistently defect; learning algorithms that do so pass the test. But some learning algorithms also fail the unit test, revealing the incentive for the agent to cooperate with its future self. While aiming for myopic behavior
+
+Table 1: Rewards for the RL unit test. Note that the myopic (defect (D)) action always increases reward at the current time-step, but decreases reward at the next time-step - the incentive to (cooperate (C)) with one’s future self is hidden from the point of view of a myopic learner.
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>at=D</td><td rowspan=1 colspan=1>at=C</td></tr><tr><td rowspan=1 colspan=1>St=at-1=D</td><td rowspan=1 colspan=1>-1/2</td><td rowspan=1 colspan=1>-1</td></tr><tr><td rowspan=1 colspan=1>St=at-1=C</td><td rowspan=1 colspan=1>1/2</td><td rowspan=1 colspan=1>0</td></tr></table>
+
+may seem odd, myopic learners have no incentives to cause distributional shift, since it can only improve future performance. And while making learners myopic may seem like a ’brute-force’ guaranteed way to manage HI-ADS, we show it is in fact non-trivial to implement. See Appendix 9.1 for details and experiments varying the reward structure.
+
+# 5.1.1 HI-ADS UNIT TESTS EXPERIMENTAL RESULTS AND DISCUSSION
+
+We first show that agents trained with PBT fail the unit tests more often than “vanilla” algorithms which do not use meta-learning. We initialize the learning rate log-uniformly between 0.01 and 1.0 for all experiments (whether using PBT or not). We expect and confirm that the following two factors lead to higher rates of unit test failure: (1) Shorter intervals: These give the OL more opportunities to influence the population. (2) Larger populations: These make outliers with exceptional non-myopic performance more likely, and OL makes them likely to survive and propagate.
+
+The baseline (no meta-learning) algorithms all pass the unit tests: hidden incentives are almost never revealed - see blue curves in Fig. 5. However, agents trained with meta-learning and large populations often fail the unit tests: see orange curves in top rows of Fig. 5.
+
+Furthermore, we verify that context swapping significantly mitigates the effect of HI-ADS in both unit tests, decreasing undesirable behaviour to near-baseline levels - see bottom rows of Fig. 5. This effect can be explained as follows: Because context swapping transfers the benefits of one learner’s action to the next learner to inhabit that environment, it increases the second learner’s fitness, and thereby reduces the relative fitness (as evaluated by PBT’s EXPLOIT step) of the non-myopic cooperate behaviour. We observe some interesting exceptions with the combination of small populations and short PBT intervals: Although context swapping still significantly decreases the effect of HIADS, non-myopic cooperate behaviour is observed as much as $20 \%$ of the time (for #learner $_ { = 1 0 }$ , $T = 1$ ; see bottom-left plot).
+
+We also observe that PBT reveals HI-ADS even when $T = 1$ , where the explanation that PBT operates on a longer time horizon than the inner loop does not apply. We provide a detailed explanation for how this might happen in Appendix 9.1.2, but in summary, we hypothesize that there are at least 2 mechanisms by which PBT is revealing HI-ADS: (1) optimizing over a longer time-scale, and (2) picking up on the correlation between an agent’s current policy and the underlying state. Mechanism (2) can be explained informally as reasoning as: “If I’m cooperating, then I was probably cooperating on the last time-step as well, so my reward should be higher”. As support for these hypotheses, we run control experiments identifying two algorithms (each sharing only one of these properties) that can fail the unit test. Context swapping remains effective.
+
+# (1) Optimizing over a longer time-scale: replacing PBT with REINFORCE as an
+
+![](images/fb963b752d78b641eafae0011c4187a77f39ee589e94374f2b91ae0ecc03c850.jpg)  
+Figure 5: (A) Values of $\hat { y _ { 2 } }$ in the supervised learning (SL) unit test. Larger values mean sacrificing present performance for future performance (i.e. non-myopic exploitation of ADS). (B) Average level of non-myopic cooperate behavior observed in the RL unit test for HI-ADS, with two meta-learning algorithms (B1) PBT and (B2) REINFORCE. Lower is better, since the goal is for non-myopic incentives to remain hidden. Despite the inner loop being fully myopic (simple MLP in the SL test, $\gamma = 0$ in RL test), in all cases outer-loop (OL) optimizers reveal HI-ADS (top rows). Context swapping significantly mitigates HI-ADS (bottom rows).
+
+outer-loop optimizer. The outer-loop optimizes the parameters to maximize the summed reward of the last $T$ time-steps. As with PBT, we observe non-myopic behavior, but now only when $T > 1$ This supports our hypothesis that exploitation of HI-ADS is due not to PBT in particular, but just to the introduction of sufficiently powerful meta-learning. See Fig. 5 B2.
+
+(2) Exploiting correlation: Q-learning with $\gamma = 0$ an $\epsilon = 0 . 1$ -greedy behavior policy and no meta-learning. If either state was equally likely, the $\mathbf { Q }$ -values would be the average of the values in each column in Table 1, so the estimated $Q ( { \mathrm { d e f e c t } } )$ would be larger. But the $\epsilon$ -greedy policy correlates the previous action (i.e. the current state) and current action (so long as the policy did not just change), so the top-left and bottomright entries carry more weight in the estimates, sometimes causing $Q ( { \mathrm { d e f e c t } } ) \approx Q ($ (cooperate) and persistent nonmyopic behavior. See Fig. 6 for results, Appendix 9.1.4 for more results, and Appendix 9.1.3 for experimental details.
+
+# 5.2 CONTENT RECOMMENDATION
+
+![](images/c27ce5d1176c26223b5a51441be7d7fafa717c25c484532ba211b635ec5f8ba5.jpg)  
+Figure 6: Q-learning can fail the unit test, playing ${ \sim } 8 0 { \cdot } 9 0 \%$ cooperate in 3 of 5 experiments (bottom row). Each column represents an independent experiment. Q-values for the cooperate and defect actions stay tightly coupled in the failure cases (col. 1,2,5), while in the cases passing the unit test (col. 3,4) the Q-value of cooperate decreases over time.
+
+We now present a toy environment for modeling content recommendation of news articles, which includes the potential for ADS by incorporating the mechanisms mentioned in Sec. 2.2, discussed as contributing factors to the problems of fake news and filter bubbles. Specifically, the environment assumes that presenting an article to a user can influence (1) their interest in similar articles, and (2) their propensity to use the recommendation service. These correspond to modeling auto-induced concept shift of users, and auto-induced covariate shift of the user base, respectively (see Sec. 2.2).
+
+This environment includes the following components, which change over (discrete) time: User type: $x ^ { t }$ , Article type: $y ^ { t }$ , User interests: $\bar { \mathbf { W } } ^ { t }$ (propensity for users of each type to click on articles of each type), and User loyalty: $\mathbf { g } ^ { t }$ (propensity for users of each type to use the platform). At each time step $t$ , a user $x ^ { t }$ is sampled from a categorical distribution, based on the loyalty of the different user types. The recommendation system (a classifier) selects which type of article to present in the top position, and finally the user ‘clicks’ an article $y ^ { t }$ , according to their interests. User loyalty for user type $x ^ { t }$ undergoes covariate shift: in accordance with the self-selection effect, $g ^ { t }$ increases or decreases proportionally to that user type’s interest in the top article. The interests of user type $x ^ { t }$ (represented by a column of $\mathbf { W } ^ { t }$ ) undergoing concept shift; in accordance with the illusory truth effect, interest in the topic of the top article chosen by the recommender system always increases.
+
+# 5.2.1 CONTENT RECOMMENDATION EXPERIMENTAL RESULTS AND DISCUSSION
+
+We run 20 trials using an MLP trained with SGD for the recommender system. We find that PBT yields significant improvements in training time and accuracy, but also greater distributional shift (Fig. 7). User base and user interests both change faster with PBT, and user interests change more overall. We measure concept/covariate shift using the cosine distance and KL-divergence, respectively. We observe that the distributions over user types typically saturate (to a single user type) after a few hundred time-steps (Fig 1 and Fig. 7, Right). We run long enough to reach such states, to demonstrate that the increase in ADS from PBT is not transitory. The environment has a number of free parameters, and our results are qualitatively consistent so long as the covariate shift rate $( \alpha _ { 1 } )$ is faster than the concept shift rate $\left( \alpha _ { 2 } \right)$ . See Appendix 9.2.1 for details.
+
+![](images/95efffd0c2948471a88671bd2e264c0a9ccf142775dc7e578a618fd609eb6f42.jpg)  
+Figure 7: Content recommendation experiments. Left: using Population Based Training (PBT) increases accuracy of predictions faster, leads to a faster and larger drift in users’ interests, $P ( \boldsymbol { y } | \mathbf { x } )$ , (Center); as well as the distribution of users, $P ( \mathbf { x } )$ , (Right). Shading shows std error over 20 runs.
+
+# 6 RELATED WORK
+
+ADS in practice: We introduce the term ADS, but we are far from the first to study it. Caruana et al. (2015) provide an example of asthmatic patients having lower predicted risk of pneumonia. Treating asthmatics with pneumonia less aggressively on this basis would be an example of harmful ADS; the reason they had lower pneumonia risk was because they had received more aggressive care already. Schulam & Saria (2017) note that such predictive models are commonly used to inform decision-making, and propose modeling counterfactuals (e.g. “how would this patient fare with less aggressive treatment”) to avoid making such self-refuting predictions. While their goal is to make accurate predictions in the presence of ADS, our goal is to identify and manage incentives for ADS.
+
+Non-i.i.d bandits: Contextual bandits (Wang et al., 2005) are a common approach to content recommendation (Li et al., 2010). While bandit algorithms typically make the i.i.d. assumption, counter-examples exist (Gheshlaghi Azar et al., 2014; Auer et al., 1995). Closest to our work is Shah et al. (2018), who consider covariate shift caused by recommender systems’ recommendations. But while they seek to exploit ADS, our aim is to avoid hidden incentives for exploiting ADS.
+
+Safety and incentives: Emergent incentives to influence the world (such as HI-ADS) are at the heart of many concerns about the safety of advanced AI systems (Omohundro, 2008; Bostrom, 2014). Understanding and managing the incentives of learners is also a focus of Armstrong & O’Rourke (2017); Everitt (2018); Everitt et al. (2019); Cohen et al.. While Everitt et al. (2019) focus on identifying which incentives are present, we note that incentives may be present and yet not be revealed or pursued - for example, in supervised learning, there is an incentive to make predictions that are over-fit to the test set, but we typically hide the test set from the learner, which effectively hides this incentive. While Carey et al. (2020); Everitt et al. (2019); Armstrong & O’Rourke (2017) discuss methods of removing problematic incentives, we note in practice incentives are often hidden rather than removed. Our work addresses the efficacy of this approach and ways in which it can fail.
+
+HI-ADS and meta-learning: We believe our work is the first to consider HI-ADS and their relation to meta-learning. A few previous works have some relevance. Rabinowitz (2019) documents qualitative differences in learning behavior when meta-learning is applied. MacKay et al. (2019) and Lorraine & Duvenaud (2018) view meta-learning as a bilevel optimization problem, with the inner loop playing a best-response to the outer loop. In our work, the outer loop has a greater influence, and the inner loop often fails to play best-response. Sutton et al. (2007) noted that meta-learning can improve performance by preventing convergence of the inner loop to best response.
+
+# 7 DISCUSSION AND CONCLUSION
+
+We identify the phenomenon of auto-induced distributional shift (ADS) and problems that can arise when there are hidden incentives for learners to induce distributional shift (HI-ADS). We show that meta-learning can reveal HI-ADS and lead learners to use ADS as a means of increasing performance.
+
+Our work highlights the interdisciplinary nature of issues with real-world deployment of ML systems - we show how HI-ADS could play a role in important technosocial issues like filter bubbles and the propagation of fake news. There are a number of potential implications for our work: (1) When HI-ADS are a concern, our methodology and environments can be used to help diagnose whether and to what extent the final performance/behavior of a learner is due to ADS and/or incentives for ADS, i.e. to quantify their influence on that learner. (2) Comparing this quantitative analysis for different algorithms could help us understand which features of algorithms affect their propensity to reveal HI-ADS, and aid in the development of safer and more robust algorithms. (3) Characterizing and identifying HI-ADS in these tests is a first step to analyzing and mitigating other (problematic) hidden incentives, as well as to developing theoretical understanding of hidden incentives.
+
+Broadly speaking, our work emphasizes that the choice of machine learning algorithm plays an important role in specification, independently of the choice of performance metric. A learner can use ADS to increase performance according to the intended performance metric, and yet still behave in an undesirable way, if we did not intend the learner to improve performance by that method. In other words, performance metrics are typically incomplete specifications: they only specify our goals or ends, while our choice of learning algorithm plays a role in specifying the means by which we intend an learner to achieve those ends. With increasing deployment of ML algorithms in daily life, we believe that (1) understanding incentives and (2) specifying desired/allowed means of improving performance are important avenues of future work to ensure fair, robust, and safe outcomes.
+
+# REFERENCES
+
+Hunt Allcott and Matthew Gentzkow. Social media and fake news in the 2016 election. Journal of Economic Perspectives, 31(2):211–36, May 2017.
+
+Michelle A. Amazeen and Bartosz W. Wojdynski. Reducing native advertising deception: Revisiting the antecedents and consequences of persuasion knowledge in digital news contexts. Mass Communication and Society, 0(0):1–26, 2018.
+
+Stuart Armstrong and Xavier O’Rorke. Good and safe uses of ai oracles. arXiv preprint arXiv:1711.05541, 2017.
+
+Stuart Armstrong and Xavier O’Rourke. Indifference methods for managing agent rewards. Technical report, Future of Humanity Institute, 2017.
+
+K. J. Åström. Optimal control of Markov Processes with incomplete state information. Journal of Mathematical Analysis and Applications, 10:174–205, January 1965.
+
+P. Auer, N. Cesa-Bianchi, Y. Freund, and R. E. Schapire. Gambling in a rigged casino: The adversarial multi-armed bandit problem. In Foundations of Computer Science, 1995.
+
+Eytan Bakshy, Solomon Messing, and Lada A. Adamic. Exposure to ideologically diverse news and opinion on Facebook. Science, 348(6239):1130–1132, 2015. ISSN 0036-8075. doi: 10.1126/science.aaa1160. URL http://science.sciencemag.org/content/348/ 6239/1130.
+
+Nick Bostrom. Superintelligence: Paths, Dangers, Strategies. Oxford University Press, Inc., New York, NY, USA, 1st edition, 2014.
+
+Ryan Carey, Eric Langlois, Tom Everitt, and Shane Legg. The incentives that shape behaviour. arXiv preprint arXiv:2001.07118, 2020.
+
+Rich Caruana, Yin Lou, Johannes Gehrke, Paul Koch, Marc Sturm, and Noemie Elhadad. Intelligible models for healthcare: Predicting pneumonia risk and hospital 30-day readmission. In International Conference on Knowledge Discovery and Data Mining, pp. 1721–1730, 2015.
+
+Paul Christiano, Jan Leike, Tom B. Brown, Miljan Martic, Shane Legg, and Dario Amodei. Deep reinforcement learning from human preferences, 2017.
+
+Michael K Cohen, Badri N Vellambi, and Marcus Hutter. Asymptotically unambitious artificial general intelligence.
+
+Dominic DiFranzo and Kristine Gloria-Garcia. Filter bubbles and fake news. XRDS, 23(3):32–35, April 2017. ISSN 1528-4972. doi: 10.1145/3055153. URL http://doi.acm.org/10. 1145/3055153.
+
+Mostafa M. El-Bermawy. Your echo chamber is destroying democracy, 2016. URL https: //www.wired.com/2016/11/filter-bubble-destroying-democracy/.
+
+Tom Everitt. Towards Safe Artificial General Intelligence. PhD thesis, Australian National University, 2018.
+
+Tom Everitt and Marcus Hutter. The alignment problem for bayesian history-based reinforcement learners. 2018.
+
+Tom Everitt and Marcus Hutter. Reward tampering problems and solutions in reinforcement learning: A causal influence diagram perspective. arXiv preprint arXiv:1908.04734, 2019.
+
+Tom Everitt, Pedro A. Ortega, Elizabeth Barnes, and Shane Legg. Understanding agent incentives using causal influence diagrams. part i: Single action settings, 2019.
+
+Lisa K. Fazio, Nadia M. Brashier, B. Keith Payne, and Elizabeth J. Marsh. Knowledge does not protect against illusory truth. Journal of Experimental Psychology: General, 144(5):993–1002, 10 2015. ISSN 0096-3445. doi: 10.1037/xge0000098.
+
+Chelsea Finn, Pieter Abbeel, and Sergey Levine. Model-agnostic meta-learning for fast adaptation of deep networks. In International Conference on Machine Learning, 2017.
+
+Seth Flaxman and Sharad Goel. Filter bubbles, echo chambers, and online news consumption. Public Opinion Quarterly, 2015.
+
+Mohammad Gheshlaghi Azar, Alessandro Lazaric, and Emma Brunskill. Online stochastic optimization under correlated bandit feedback. ArXiv preprint, 2014.
+
+Dong Gong, Zhen Zhang, Qinfeng Shi, Anton van den Hengel, Chunhua Shen, and Yanning Zhang. Learning an optimizer for image deconvolution. ArXiv preprint, 2018.
+
+Jacob Groshek and Karolina Koc-Michalska. Helping populism win? Social media use, filter bubbles, and support for populist presidential candidates in the 2016 us election campaign. Information, Communication & Society, 20(9):1389–1407, 2017. doi: 10.1080/1369118X.2017.1329334. URL https://doi.org/10.1080/1369118X.2017.1329334.
+
+Dylan Hadfield-Menell, Smitha Milli, Pieter Abbeel, Stuart Russell, and Anca Dragan. Inverse reward design. In Neural Information Processing Systems, 2017.
+
+M. Jaderberg, V. Dalibard, S. Osindero, W. M. Czarnecki, J. Donahue, A. Razavi, O. Vinyals, T. Green, I. Dunning, K. Simonyan, C. Fernando, and K. Kavukcuoglu. Population Based Training of Neural Networks. ArXiv preprint, 2017.
+
+Leslie Pack Kaelbling, Michael L. Littman, and Anthony R. Cassandra. Planning and acting in partially observable stochastic domains. Artificial Intelligence, 101(1-2):99–134, May 1998. ISSN 0004-3702.
+
+A. Kalousis. Model selection via meta-learning: A comparative study. In IEEE International Conference on Tools with Artificial Intelligence, 2000.
+
+Varol Kayhan. Confirmation bias: Roles of search engines and search contexts. In International Conference on Information Systems, 2015.
+
+Ed. Lee Howell. Digital wildfires in a hyperconnected world. In Lee Howell (ed.), Global Risks 2013. World Economic Forum, 2013. URL http://reports.weforum.org/global-risks-2013/risk-case-1/ digital-wildfires-in-a-hyperconnected-world/.
+
+Jan Leike, Miljan Martic, Victoria Krakovna, Pedro A. Ortega, Tom Everitt, Andrew Lefrancq, Laurent Orseau, and Shane Legg. AI safety gridworlds. Technical report, DeepMind, 2017.
+
+Jan Leike, David Krueger, Tom Everitt, Miljan Martic, Vishal Maini, and Shane Legg. Scalable agent alignment via reward modeling: a research direction. Technical report, DeepMind Safety Research, 2018.
+
+Lihong Li, Wei Chu, John Langford, and Robert E. Schapire. A contextual-bandit approach to personalized news article recommendation. In International Conference on World Wide Web, 2010.
+
+Jonathan Lorraine and David Duvenaud. Stochastic hyperparameter optimization through hypernetworks. ArXiv preprint, 2018.
+
+D. D. Luxton, J. D. June, and J. M. Fairall. Social media and suicide: A public health perspective. American journal of public health, 102(2):195–200, 2012.
+
+Matthew MacKay, Paul Vicol, Jonathan Lorraine, David Duvenaud, and Roger Grosse. Self-tuning networks: Bilevel optimization of hyperparameters using structured best-response functions. ArXiv preprint, 2019.
+
+Merriam-Webster. The real story of fake news, 2017. URL https://www.merriam-webster. com/words-at-play/the-real-story-of-fake-news.
+
+Luke Metz, Niru Maheswaranathan, Brian Cheung, and Jascha Sohl-Dickstein. Learning unsupervised learning rules. In International Conference on Learning Representations, 2019.
+
+Paul Mihailidis and Samantha Viotty. Spreadable spectacle in digital culture: Civic expression, fake news, and the role of media literacies in "post-fact" society. American Behavioural Scientist, 2017.
+
+Jose G. Moreno-Torres, Troy Raeder, RocíO Alaiz-RodríGuez, Nitesh V. Chawla, and Francisco Herrera. A unifying view on dataset shift in classification. Pattern Recognition, 45(1):521–530, January 2012.
+
+Tien T. Nguyen, Pik-Mai Hui, F. Maxwell Harper, Loren Terveen, and Joseph A. Konstan. Exploring the filter bubble: The effect of using recommender systems on content diversity. In Proceedings of the 23rd International Conference on World Wide Web, WWW ’14, pp. 677–686, New York, NY, USA, 2014. ACM. ISBN 978-1-4503-2744-2. doi: 10.1145/2566486.2568012. URL http://doi.acm.org/10.1145/2566486.2568012.
+
+Safiya Umoja Noble. Algorithms of Oppression: How Search Engines Reinforce Racism. NYC Press, 2018.
+
+Stephen M. Omohundro. The basic AI drives. In Conference on Artificial General Intelligence, 2008.
+
+Pedro A. Ortega, Vishal Maini, et al. Building safe artificial intelligence: specification, robustness, and assurance, 2018.
+
+Eli Pariser. The Filter Bubble: What the Internet Is Hiding from You. The Penguin Group, 2011.
+
+Gordon Pennycook, Tyrone D Cannon, and David G. Rand. Prior exposure increases perceived accuracy of fake news. Journal of Experimental Psychology (forthcoming), 2019.
+
+Erich Prisner. Game Theory Through Examples. Mathematical Association of America, 2014.
+
+Joaquin Quionero-Candela, Masashi Sugiyama, Anton Schwaighofer, and Neil D. Lawrence. Dataset Shift in Machine Learning. The MIT Press, 2009.
+
+Neil C. Rabinowitz. Meta-learners’ learning dynamics are unlike learners’. ArXiv preprint, 2019.
+
+David Robson. The myth of the online echo chamber, 2018. URL http://www.bbc.com/ future/story/20180416-the-myth-of-the-online-echo-chamber.
+
+Peter Schulam and Suchi Saria. Reliable decision support using counterfactual models. In Neural Information Processing Systems, 2017.
+
+Virag Shah, Jose Blanchet, and Ramesh Johari. Bandit learning with positive externalities. Neural Information Processing Systems, 2018.
+
+Chengcheng Shao, Giovanni Luca Ciampaglia, Onur Varol, Kai-Cheng Yang, Alessandro Flammini, and Filippo Menczer. The spread of low-credibility content by social bots. Nature Communications, 9(4787), 2018.
+
+Jasper Snoek, Hugo Larochelle, and Ryan P Adams. Practical Bayesian optimization of machine learning algorithms. In Neural Information Processing Systems, 2012.
+
+Richard S Sutton and Andrew G Barto. Introduction to Reinforcement Learning. MIT Press, 1998.
+
+Richard S Sutton, Anna Koop, and David Silver. On the role of tracking in stationary environments. In International conference on Machine learning, 2007.
+
+Techopedia. Filter bubble, 2018. URL https://www.techopedia.com/definition/ 28556/filter-bubble.
+
+Chih-Chun Wang, Sanjeev R Kulkarni, and H Vincent Poor. Bandit problems with side observations. IEEE Transactions on Automatic Control, 50(3):338–355, 2005.
+
+Wikipedia contributors. Confirmation bias — Wikipedia, the free encyclopedia, 2018. URL https://en.wikipedia.org/w/index.php?title=Confirmation_bias& oldid=875026726. [Online; accessed 20-January-2019].
+
+Ronald J. Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. In Machine Learning, pp. 229–256, 1992.
+
+# APPENDICES
+
+# 8 CONTENT RECOMMENDATION IN THE WILD
+
+Filter bubbles, the spread of fake news, and other techno-social issues are widely reported to be responsible for the rise of populism (Groshek & Koc-Michalska, 2017), increase in racism and prejudice against immigrants and refugees (Noble, 2018), increase in social isolation and suicide (Luxton et al., 2012), and, particularly with reference to the 2016 US elections, are decried as threatening the foundations of democracy (El-Bermawy, 2016). Even in 2013, well before the 2016 American elections, a World Economic Forum report identified these problems as a global crisis (Lee Howell, 2013).
+
+We focus on two related issues in which content recommendation algorithms play a role: fake news and filter bubbles.
+
+# 8.1 FAKE NEWS
+
+Fake news (also called false news or junk news) is an extreme version of yellow journalism, propaganda, or clickbait, in which media that is ostensibly providing information focuses on being eye-catching or appealing, at the expense of the quality of research and exposition of factual information. Fake news is distinguished by being specifically and deliberately created to spread falsehoods or misinformation (Merriam-Webster, 2017; Mihailidis & Viotty, 2017).
+
+Why does fake news spread? It may at first seem the solution is simply to educate people about the truth, but research tells us the problem is more multifaceted and insidious, due to a combination of related biases and cognitive effects including confirmation bias (people are more likely to believe things that fit with their existing beliefs), priming (exposure to information unconsciously influences the processing of subsequent information, i.e. seeing something in a credible context makes things seem more credible) and the illusory truth effect (i.e. people are more likely to believe something simply if they are told it is true).
+
+Allcott & Gentzkow (2017) track about 150 fake news stories during the 2016 US election, and find the average American adult saw 1-2 fake news stories, just over half believed the story was true, and likelihood of believing fake news increased with ideological segregation (polarization) of their social media. Shao et al. (2018) examine the role of social bots in spreading fake news by analyzing 14 million Twitter messages. They find that bots are far more likely than humans to spread misinformation, and that success of a fake news story (in terms of human retweets) was heavily dependent on whether bots had shared the story.
+
+Pennycook et al. (2019) examine the role of the illusory truth effect in fake news. They find that even a single exposure to a news story makes people more likely to believe that it is true, and repeat viewings increase this likelihood. They find that this is not true for extremely implausible statements (e.g. “the world is a perfect cube”), but that “only a small degree of potential plausibility is sufficient for repetition to increase perceived accuracy” of the story. The situation is further complicated by peoples’ inability to distinguish promoted content from real news - Amazeen & Wojdynski (2018) find that fewer than 1/10 people were able to tell when content was an advertisement, even when it was explicitly labelled as such. Similarly, Fazio et al. (2015) find that repeated exposure to incorrect trivia make people more likely to believe it, even when they are later able to identify the trivia as incorrect.
+
+# 8.2 FILTER BUBBLES
+
+Filter bubbles, a term coined and popularized by Pariser (2011) are created by positive or negative feedback loops which encourage users or groups of users towards increasing within-group similarity, while driving up between-group dissimilarity. The curation of this echo chamber is called selfselection (people are more likely to look for or select things that fit their existing preferences), and favours what Techopedia (2018) calls intellectual isolation. In the context of social and political opinions, this is often called the polarization effect (Wikipedia contributors, 2018).
+
+Filter bubbles can be encouraged by algorithms in two main ways. The first is the most commonly described: simply by showing content that is similar to what a user has already searched for, search or recommender systems create a positive feedback loop of increasingly-similar content (Pariser, 2011; Kayhan, 2015). The second way is similar but opposite - if the predictions of an algorithm are good for a certain group of people, but bad for others, the algorithm can do better on its metrics by driving hard-to-predict users away. Then new users to the site will either be turned off entirely, or see an artificially homogenous community of like-minded peers, a phenomena Shah et al. (2018) call positive externalities.
+
+In a study of 50,000 US-based internet users, Flaxman & Goel (2015) find that two things increase with social media and search engine use: (1) exposure of an individual to opposing or different viewpoints, and (2) mean ideological distance between users. Many studies cite the first result as evidence of the benefits of internet and social media (Robson, 2018; Bakshy et al., 2015), but the correlation of exposure with ideological distances demonstrates that exposure is not enough, and might even be counterproductive.
+
+Facebook’s own study on filter bubbles results show that the impact of the news feed algorithm on filter bubble “size” (a measure of homogeneity of posts relative to a baseline) is almost as large as the impact of friend group composition (Bakshy et al., 2015). Kayhan (2015) specifically study the role of search engines in confirmation bias, and find that search context and the similarity of results in search engine results both reinforce existing biases and increase the likelihood of future biased searches. Nguyen et al. (2014) similarly study the effect of recommender systems on individual users’ content diversity, and find that the set of options recommended narrows over time.
+
+Filter bubbles create an ideal environment for the spread of fake news: they increase the likelihood of repeat viewings of similar content, and because of the illusory truth effect, that content is more likely to be believed and shared (Pennycook et al., 2019; DiFranzo & Gloria-Garcia, 2017; Pariser, 2011). We are not claiming that HI-ADS are entirely or even mostly responsible for these problems, but we do note that they can play a role that is worth addressing.
+
+![](images/5c7a8c62362379a4ec118b2d7cacc1bfea380d1d1281d25198b5cb5100eaef60.jpg)  
+incentive-compatible $\beta = 0 . 5$ )   
+Figure 8: Average level of non-myopic (i.e. cooperate) behavior learned by agents in the unit test for HI-ADS. Despite making the inner loop fully myopic $( \gamma = 0 )$ ), population-based training (PBT) can cause HI-ADS, leading agents to choose the cooperate action (top row). context swapping successfully prevents this (bottom row). Columns (from left to right) show results for populations of 10, 100, and 1000 learners. In the legend, “interval” refers to the interval $( T )$ of PBT (see Sec. 2.2). Sufficiently large populations and short intervals are necessary for PBT to induce nonmyopic behavior.
+
+# 9 EXTRA EXPERIMENTS AND REPRODUCIBILITY DETAILS
+
+# 9.1 HI-ADS UNIT TEST
+
+We used REINFORCE (Williams, 1992) with discount factor $\gamma = 0$ as the baseline/IL optimizer. PBT (with default settings, see Section 2.2) is used to tune the learning rate, with reward on the final time-step of the interval as the performance measure for PBT.
+
+Formally, the environment is not a $2 \mathbf { x } 2$ game (as the original prisoner’s dilemma); it’s a partially observable Markov Decision Process (Åström, 1965; Kaelbling et al., 1998):
+
+$$
+\begin{array} { r l r } & { } & { s _ { t } , o _ { t } = a _ { t - 1 } , \{ \} } \\ & { } & { a _ { t } \in \{ \mathsf { d e f e c t } , ~ \mathsf { c o o p e r a t e } \} } \\ & { } & { P ( s _ { t } , a _ { t } ) = \delta ( a _ { t } ) } \\ & { } & { R ( s _ { t } , a _ { t } ) = I ( s _ { t } = \mathsf { c o o p e r a t e } ) + \beta ~ I ( a _ { t } = \mathsf { c o o p e r a t e } ) - 1 / 2 } \end{array}
+$$
+
+where $I$ is an indicator function, and $\beta = - 1 / 2$ is a parameter controlling the alignment of incentives. The initial state is sampled as $s _ { 0 } \sim U ( { \tt d e f e c t }$ , cooperate). Policies are represented by a single real-valued parameter $\theta$ (initialized as $\theta \sim \mathcal { N } ( 0 , 1 ) \big )$ ) passed through a sigmoid whose output represents $P ( a _ { t } = \mathrm { \bar { d e f e c t } } )$ .
+
+# 9.1.1 ALIGNMENT OF INCENTIVES EXPLORATION
+
+This section presents an exploration of the parameter $\beta$ , which controls the alignment of incentives in the HI-ADS unit tests (see Table 2).
+
+To clarify the interpretation of experiments, we distinguish between environments in which myopic (defect) vs. nonmyopic (cooperate) incentives are opposed, orthogonal, or compatible. Note that in this unit test myopic behaviour (defection) is what we want to see.
+
+1. Incentive-opposed: Optimal myopic behavior is incompatible with optimal nonmyopic behavior (classic prisoner’s dilemma; these experiments are in the main paper).   
+2. Incentive-orthogonal: Optimal myopic behavior may or may not be optimal nonmyopic behavior.   
+3. Incentive-compatible: Optimal myopic behavior is necessarily also optimal nonmyopic behavior.
+
+We focused on incentive-opposed environment $( \beta = - 1 / 2 )$ ) in the main paper in order to demonstrate that HI-ADS can be powerful enough to change the behavior of the system in an undesirable way. Here we also explore incentive-compatible and incentive-orthogonal environments because they provide useful baselines, helping us distinguish a systematic bias towards nonmyopic behavior from other reasons (such as randomness or optimization issues) for behavior that does not follow a myopically optimal policy.
+
+# 9.1.2 WORKING THROUGH A DETAILED EXAMPLE FOR PBT WITH $T = 1$
+
+To help provide intuition on how (mechanistically) PBT could lead to persistent levels of cooperation, we walk through a simple example (with no inner loop). Consider PBT with $T = 1$ and a population of 5 deterministic agents $A _ { 1 } , . . . , A _ { 5 }$ playing cooperate and receiving reward of $r ( A _ { i } ) = 0$ . Now suppose $A _ { 1 }$ suddenly switches to play defect. Then $r ( A _ { 1 } ) = 1 / 2$ on the next time-step (while the other agents’ reward is still 0), and so PBT’s EXPLOIT step will copy $A _ { 1 }$ (without loss of generality to $A _ { 2 }$ ). On the following time-step, $r ( A _ { 2 } ) = 1 / 2$ , and $r ( A _ { 1 } ) = - 1 / 2$ , so PBT will clone $A _ { 2 }$ to $A _ { 1 }$ , and the cycle repeats. Similar reasoning applies for larger populations, and $T > 1$ .
+
+# 9.1.3 Q-LEARNING EXPERIMENT DETAILS
+
+We show that, under certain conditions, Q-learning can learn to (primarily) cooperate, and thus fails the HI-ADS unit test. We estimate Q-values using the sample-average method, which is guaranteed to converge in the fully observed, tabular case (Sutton & Barto, 1998). The agent follows the $\epsilon$ -greedy policy with $\epsilon = 0 . 1$ . In order to achieve this result, we additionally start the agent off with one synthetic memory where both state and action are defect and therefor $R ( \mathrm { d e f e c t } ) = - . 5$ , and we hard-code the starting state to be cooperate (which normally only happens $50 \%$ of the time). Without this kind of an initialization, the agent always learns to defect. However, under these conditions, we find that 10/30 agents learned to play cooperate most of the time, with $Q$ (cooperate) and $Q ( { \mathrm { d e f e c t } } )$ both hovering around $- 0 . 0 7$ , while others learn to always defect, with $Q ( { \mathrm { c o o p e r a t e } } ) \approx - 0 . 9 2$ and $Q ( { \mathrm { d e f e c t } } ) \approx - 0 . 4 5$ . context swapping, however, prevents majority-cooperate behavior from ever emerging, see Figure 11.
+
+Table 2: $\beta$ controls the extent to which myopic and nonmyopic incentives are aligned.   
+
+<table><tr><td>β</td><td>Environment</td><td>Cooperating</td></tr><tr><td>&lt;0</td><td>incentive-opposed</td><td>yields less reward on the current time-step (myopically detrimental)</td></tr><tr><td>=0</td><td>incentive-orthogonal</td><td>does not affect the current reward (myopically indifferent)</td></tr><tr><td>v0</td><td>incentive-compatible</td><td>yields more reward on the current time-step (myopically beneficial)</td></tr></table>
+
+# 9.1.4 Q-LEARNING: FURTHER RESULTS
+
+To give a more representative picture of how often Q-learning fails the unit test, we run a larger set of experiments with Q-learning, results are in Figure 10. It’s possible that the failure of Q-learning is not persistent, since we have not proved otherwise, but we did run much longer experiments and still observe persistent failure, see Figure 9.
+
+![](images/93bc9858be4e122e4aa54709b97526f0b712f8b3de8f38002ec30b69c8b8d7ee.jpg)  
+Figure 9: The same experiments as Figures 6, 10, run for 50,000 time-steps instead of 3000, to illustrate the persistence of non-myopic behavior.
+
+![](images/3e860d515c7ba817cb56c44c846a248ed6df5909c2c2c53c73553c58f29bb252.jpg)  
+Figure 10: More independent experiments with Q-learning, exactly following Figure 6. Q-learning fails the unit test in a total of 10/30 experiments (including those from Figure 6).
+
+![](images/18011e0877d74bf4ea8b3877bc9a66d2f427d421200bb03d1cb2dd7167b3d022.jpg)  
+Figure 11: More independent experiments with Q-learning, exactly following Figure 6, except also using context swapping. This leads to a $100 \%$ success rate on the unit test.
+
+# 9.2 CONTENT RECOMMENDATION
+
+# 9.2.1 ENVIRONMENT DETAILS
+
+The evironment has the following components:
+
+1. User type, $x ^ { t }$ : categorical variable representing different types of users. The content recommender conditions its predictions on the type of the current user.   
+2. User loyalty, $\mathbf { g } ^ { t }$ : the propensity for users of each type to use the platform. User $x ^ { t }$ is sampled from a categorical distribution with parameters given by softmax $( \mathbf { g } ^ { t } )$ .   
+3. Article type, $y ^ { t }$ : a categorical variable (one-hot encoding) representing the type of article selected by the user.   
+4. User interests, $\mathbf { W } ^ { t }$ : a matrix whose entries $W _ { x , y } ^ { t }$ represent the average interest user of type $x$ have in articles of type $y$ .
+
+At each time step $t$ , a user $x ^ { t }$ is sampled from a categorical distribution (based on the loyalty of the different user types), then the recommendation system selects which type of article to present in the top position, and finally, the user selects an article. The goal of the recommendation system is to predict the likelihood that the user would click on each of the available articles, in order to select the one which is most interesting to the user.
+
+User loyalty for $x ^ { t }$ then changes in accordance with the self-selection effect, increasing or decreasing proportionally to their interest in the top article. The interests of user type $x ^ { t }$ (represented by a column of $\mathbf { W } ^ { t }$ ) also change; in accordance with the illusory truth effect, their interest in the topic of the top article (as chosen by the recommender system) always increases. Overall, this environment is an extremely crude representation of reality, but it allows us to incorporate both the effects of self-selection (via covariate shift), and the illusory truth effect (via concept shift).
+
+Formally, this environment is similar to a POMDP\R, i.e. a POMDP with no reward function, also known as a world model (Armstrong & O’Rourke, 2017; Hadfield-Menell et al., 2017); the difference is that the learner observes the input before acting and only observes the target after acting. The states, observations, and actions given below.
+
+$$
+\begin{array} { c } { { \boldsymbol { s } ^ { t } = ( \mathbf { g } ^ { t } , \mathbf { W } ^ { t } , \boldsymbol { x } ^ { t } , \boldsymbol { y } ^ { t } ) } } \\ { { \boldsymbol { o } _ { \mathrm { p r e } } ^ { t } , ~ \boldsymbol { a } ^ { t } , ~ \boldsymbol { o } _ { \mathrm { p o s t } } ^ { t } = ( \boldsymbol { x } ^ { t } , \hat { \boldsymbol { y } } ^ { t } , \boldsymbol { y } ^ { t } ) } } \end{array}
+$$
+
+The state transition function is defined by:
+
+$$
+\begin{array} { r l r } { \mathbf { g } _ { x ^ { t } } ^ { t + 1 } = \mathbf { g } _ { x ^ { t } } ^ { t } + \alpha _ { 1 } W _ { x ^ { t } , \hat { y } ^ { t } } ^ { t } } & { } & \\ { \mathbf { W } _ { x ^ { t } , \hat { y } ^ { t } } ^ { t + 1 / 2 } = W _ { x ^ { t } , \hat { y } ^ { t } } ^ { t } + \alpha _ { 2 } ; \quad \mathbf { W } _ { x ^ { t } } ^ { t + 1 } = \frac { \mathbf { W } _ { x ^ { t } } ^ { t + 1 / 2 } } { \Vert \mathbf { W } _ { x ^ { t } } ^ { t + 1 / 2 } \Vert _ { 2 } } } & { } & \\ { x ^ { t + 1 } \sim \mathrm { s o f t m a x } ( \mathbf { g } ^ { t + 1 } ) } & { } & \\ { y ^ { t + 1 } \sim \mathrm { s o f t m a x } ( \mathbf { W } _ { x ^ { t + 1 } } ^ { t + 1 } ) } & { } & \end{array}
+$$
+
+Where $\hat { y } ^ { t }$ is the top article as chosen by the recommender, and $\alpha _ { 1 }$ , $\alpha _ { 2 }$ represent the rate of covariate and concept shift (respectively). The update for $\mathbf { W } ^ { t + 1 }$ merely increases the interest of user type $x ^ { t }$ in article type $\hat { y } ^ { t }$ , then normalizes the interests for that user type.
+
+# 9.2.2 REPRODUCIBILITY DETAILS
+
+For these experiments, the recommendation system is a ReLU-MLP with 1 hidden layer of 100 units, trained via supervised learning with SGD (learning rate $= 0 . 0 1 $ ) to predict which article a user will select. Actions are sampled from the MLP’s predictive distribution. We apply PBT without any hyperparameter selection (this amounts to just doing the EXPLOIT step), and an interval of 10, selecting on accuracy. We use a population of 20 learners (whether applying PBT or not), and match random seeds for the trials with and without PBT. We initialize $\mathbf { g } ^ { 1 }$ and $\dot { \mathbf { W } } ^ { 1 }$ to be the same across the 20 copies of the environment (i.e. the learners start with the same user population), but these values diverge throughout learning. For the environment, we set the number of user and article types both to 10. Initial user loyalties are randomly sampled from $\mathcal { N } ( 0 , 0 . 0 3 )$ , $\alpha _ { 1 } = 0 . 0 3$ , and $\alpha _ { 2 } = 0 . 0 0 3$ .
+
+# 9.2.3 DETAILS OF EVALUATION
+
+We measure concept shift (change in $P ( \boldsymbol { y } | \mathbf { x } ) .$ ) as the cosine distance between each user types’ initial and current interest vectors. And we measure covariate shift (change in $P ( \mathbf { x } ) )$ ) as the KL-divergence between the current and initial user distributions, parametrized by $\mathbf { g } ^ { 1 }$ and $\mathbf { g } ^ { t }$ , respectively. Results are presented in 7 (main text). In Figure 12, we additionally plot concept shift and covariate shift as a function of accuracy. We observe that for both types of ADS, at low levels of accuracy PBT actually causes less shift than occur in baseline agents; HI-ADS are only observed for accuracies above $60 \%$ . This suggests that only relatively strong performers are able to pick up on the HI-ADS revealed by PBT (Fig. 12).
+
+![](images/4ee83ea25b84d00e9bd2c93c72bcfe37100fc4c406703659c71aeb8e4ba6b65a.jpg)  
+Figure 12: Amount of auto-induced covariate shift (left) and auto-induced concept shift (right) as a function of performance (accuracy) averaged over all trials, learners, and time-steps. Only relatively strong learners (those which achieve accuracy $> 6 0 \%$ ) exhibit HI-ADS.
+
+# 9.2.4 CONTEXT SWAPPING IN CONTENT RECOMMENDATION
+
+We believe context swapping is not appropriate for the content recommendation environment, since when the environments diverge, optimal behavior may differ across environments. Nevertheless, we ran experiments with it for completeness. The main effect appears to be to hamper learning when PBT is not used, see Figure 13. Notably, it does not appear to significantly influence the rate or extent of ADS when combined with PBT.
+
+# 9.2.5 EXPLORATION OF ENVIRONMENT PARAMETERS
+
+In Figure 14, we examine the effect of the rate-of-change parameters $( \alpha _ { 1 } , \alpha _ { 2 } )$ of the content recommendation environment on the results provided in the paper. As noted there, our results are qualitatively consistent so long as (1) the initial user distribution is approximately uniform, and (2) the covariate shift rate $( \alpha _ { 1 } )$ is faster than the concept shift rate $\left( \alpha _ { 2 } \right)$ . These distributions are updated by different mechanisms, and are not directly comparable. Concept shift changes the task more radically, requiring a learner to change its predictions, rather than just become accurate on a wider range of inputs. We conjecture that changes in $P ( \boldsymbol { y } | \boldsymbol { x } )$ must therefore be kept smooth enough for the outer loop to have pressure to capitalize on HI-ADS.
+
+![](images/32bff10367ed93273e67c56861072a16c782eb88536e394129f2eaa0da72bbf8.jpg)  
+Figure 13: Context swapping doesn’t have the desired effect in the content recommendation environment.
+
+![](images/a89f27f3d6a426966da5d92bf05f995060ebcc886850b49f7d5327641103133d.jpg)  
+Figure 14: Content recommendation results for different values of $\alpha _ { 1 } , \alpha _ { 2 }$
+
+# 10 OFFLINE Q-LEARNING CAN REVEAL INCENTIVES FOR ADS
+
+First, recall that this unit test is a POMDP, and the state is not observed. Since there are only 2 possible actions, a policy is defined by a single parameter $\theta = p ( { \mathrm { c o o p e r a t e } } )$ . Now, the state distribution is $P ( s = { \mathrm { c o o p e r a t e } } ) = \theta$ (ignoring the first state, which is appropriate in the limit of infinite data). More specifically, the probability of each state-action combination are as follows:
+
+Suppose we have a dataset of $N$ examples generated by following a fixed policy.
+
+$$
+\begin{array} { r l } & { Q ( C ) = \frac { | s = C , a = C | R ( s = C , a = C ) + | s = D , a = C | R ( s = D , a = C ) } { | a = C | } } \\ & { \quad \quad = \frac { N P ( s = C , a = C ) R ( s = C , a = C ) + N P ( s = D , a = C ) R ( s = D , a = C ) } { N P ( a = C ) } } \\ & { \quad \quad = \frac { P ( s = C , a = C ) R ( s = C , a = C ) + P ( s = D , a = C ) R ( s = D , a = C ) } { P ( a = C ) } } \\ & { \quad \quad = \frac { \theta ^ { 2 } R ( s = C , a = C ) + \theta ( 1 - \theta ) R ( s = D , a = C ) } { \theta } } \\ & { \quad \quad = \theta R ( s = C , a = C ) + ( 1 - \theta ) R ( s = D , a = C ) } \\ & { \quad \quad = \theta ( 0 ) + ( 1 - \theta ) ( - 1 ) } \\ & { \quad \quad = \theta - 1 } \end{array}
+$$
+
+$$
+\begin{array} { l } { Q ( D ) = \frac { \left| s = C , a = D \right| R \left( s = C , a = D \right) + \left| s = D , a = D \right| R \left( s = D , a = D \right) } { \left| a = D \right| } } \\ { \ = \frac { P \left( s = C , a = D \right) R \left( s = C , a = D \right) + P \left( s = D , a = D \right) R \left( s = D , a = D \right) } { P \left( a = D \right) } } \\ { \ = P ( s = C ) R ( s = C , a = D ) + P ( s = D ) R ( s = D , a = D ) } \\ { \ = \theta ( 1 / 2 ) + ( 1 - \theta ) ( - 1 / 2 ) } \\ { \ = 1 / 2 ( 2 \theta - 1 ) } \\ { \ = \theta - 1 / 2 } \end{array}
+$$
+
+So we see that $Q ( D ) > Q ( C )$ , regardless of $\theta$ .
+
+Now, suppose instead that we have $N$ examples from each of 2 different policies (given by parameters $\theta _ { 1 }$ and $\theta _ { 2 }$ ) operating in different environments. Intuitively, this sort of data might arise in practice from “A/B testing”, where 2 different users have been assigned to 2 different policies in order to compare the policies’ performance. We now use $_ { D C }$ to represent $s = D , a = C$ , etc.
+
+$$
+\begin{array} { r l } & { Q ^ { \theta _ { 1 } , \theta _ { 2 } } ( C ) = \frac { | C C | R ( C C ) + | D C | | R ( U C ) } { | C | } } \\ & { \quad \quad \quad = \frac { N \left( P ^ { \theta _ { 1 } } ( C C ) + P ^ { \theta _ { 2 } } ( C C ) \right) R ( C C ) + N ( P ^ { \theta _ { 1 } } ( D C ) + P ^ { \theta _ { 2 } } ( D C ) ) R ( D C ) } { N \left( P ^ { \theta _ { 1 } } ( C ) + P ^ { \theta _ { 2 } } ( C ) \right) } } \\ & { \quad \quad \quad = \frac { ( P ^ { \theta _ { 1 } } ( C C ) + P ^ { \theta _ { 2 } } ( C C ) ) I ( C C ) C + ( P ^ { \theta _ { 1 } } ( D C ) + P ^ { \theta _ { 2 } } ( D C ) ) R ( D C ) } { ( F ^ { \theta _ { 1 } } ( C ) + P ^ { \theta _ { 2 } } ( C ) ) } } \\ & { \quad \quad \quad = \frac { ( \theta _ { 1 } ^ { 2 } + \theta _ { 2 } ^ { 2 } ) R ( C C ) + ( \theta _ { 1 } ( 1 - \theta _ { 1 } ) + \theta _ { 2 } ( 1 - \theta _ { 2 } ) ) R ( D C ) } { \theta _ { 1 } + \theta _ { 2 } } } \\ & { \quad \quad \quad = - \frac { \theta _ { 1 } ( 1 - \theta _ { 1 } ) + \theta _ { 2 } ( 1 - \theta _ { 2 } ) } { \theta _ { 1 } + \theta _ { 2 } } } \\ & { \quad \quad \quad = \frac { \theta _ { 1 } ^ { 2 } - \theta _ { 1 } + \theta _ { 2 } ^ { 2 } - \theta _ { 2 } } { \theta _ { 1 } + \theta _ { 2 } } } \\ & { \quad \quad \quad = \frac { \theta _ { 1 } ^ { 2 } - \theta _ { 1 } + \theta _ { 2 } ^ { 2 } - \theta _ { 2 } } { \theta _ { 1 } + \theta _ { 2 } } } \\ & { \quad \quad \quad = \frac { \theta _ { 1 } ^ { 2 } - \theta _ { 1 } + \theta _ { 2 } ^ { 2 } - \theta _ { 2 } } { \theta _ { 1 } + \theta _ { 2 } } } \end{array}
+$$
+
+$$
+\begin{array} { l } { { Q ^ { \theta _ { 1 } , \theta _ { 2 } } ( D ) = \frac { \left| C D \right| R \left( C D \right) + \left| D D \right| R \left( D D \right) } { \left| D \right| } } } \\ { { \ = \frac { \left( P ^ { \theta _ { 1 } } \left( C D \right) + P ^ { \theta _ { 2 } } \left( C D \right) \right) R \left( C D \right) + \left( P ^ { \theta _ { 1 } } \left( D D \right) + P ^ { \theta _ { 2 } } \left( D D \right) \right) R \left( D D \right) } { \left( P ^ { \theta _ { 1 } } \left( D \right) + P ^ { \theta _ { 2 } } \left( D \right) \right) } } } \\ { { \ = \frac { 1 / 2 \left( \theta _ { 1 } \left( 1 - \theta _ { 1 } \right) + \theta _ { 2 } \left( 1 - \theta _ { 2 } \right) \right) - 1 / 2 \left( ( 1 - \theta _ { 1 } ) ^ { 2 } + ( 1 - \theta _ { 2 } ) ^ { 2 } \right) } { 2 - \theta _ { 1 } - \theta _ { 2 } } } } \\ { { \ = \frac { \left( 2 \theta _ { 1 } - 1 \right) \left( 1 - \theta _ { 1 } \right) + \left( 2 \theta _ { 2 } - 1 \right) \left( 1 - \theta _ { 2 } \right) } { 4 - 2 \theta _ { 1 } - 2 \theta _ { 2 } } } } \end{array}
+$$
+
+Now, in Figure 15 we see that $Q ( C ) > Q ( D )$ when one of the policies cooperates with high probability, and the other defects with high probability. Intuitively, the result of pooling data from 2 such policies is very similar to collecting data from an $\epsilon$ -greedy policy trained online (as in Figure 6).
+
+![](images/f8cf957c6b390dfb762d079853f1b8f334d627fe895c972607d8fe3c71e3938d.jpg)  
+Figure 15: Offline Q-learning can also reveal HI-ADS, when pooling data from different (policy, environment) pairs. Yellow regions represent policy pairs for which $\mathbf { \bar { Q } } ( C ) > Q ( D )$ , resulting in non-myopic behavior.

parse/train/AHm3dbp7D1D/AHm3dbp7D1D.md

@@ -0,0 +1,525 @@
+# SEED: SELF-SUPERVISED DISTILLATION FOR VISUAL REPRESENTATION
+
+Zhiyuan Fang† , Jianfeng Wang‡, Lijuan Wang‡, Lei Zhang‡, Yezhou Yang†, Zicheng Liu‡
+
+†Arizona State University, ‡Microsoft Corporation {zy.fang, yz.yang}@asu.edu {jianfw, lijuanw, leizhang, zliu}@microsoft.com
+
+# ABSTRACT
+
+This paper is concerned with self-supervised learning for small models. The problem is motivated by our empirical studies that while the widely used contrastive self-supervised learning method has shown great progress on large model training, it does not work well for small models. To address this problem, we propose a new learning paradigm, named SElf-SupErvised Distillation (SEED), where we leverage a larger network (as Teacher) to transfer its representational knowledge into a smaller architecture (as Student) in a self-supervised fashion. Instead of directly learning from unlabeled data, we train a student encoder to mimic the similarity score distribution inferred by a teacher over a set of instances. We show that SEED dramatically boosts the performance of small networks on downstream tasks. Compared with self-supervised baselines, SEED improves the top-1 accuracy from $4 2 . 2 \%$ to $6 7 . 6 \%$ on EfficientNet-B0 and from $3 6 . 3 \%$ to $6 8 . 2 \%$ on MobileNetV3-Large on the ImageNet-1k dataset.
+
+# 1 INTRODUCTION
+
+The burgeoning studies and success on self-supervised learning (SSL) for visual representation are mainly marked by its extraordinary potency of learning from unlabeled data at scale. Accompanying with the SSL is its phenomenal benefit of obtaining task-agnostic representations while allowing the training to dispense with prohibitively expensive data labeling. Major ramifications of visual SSL include pretext tasks (Noroozi & Favaro, 2016; Zhang et al., 2016; Gidaris et al., 2018; Zhang et al., 2019; Feng et al., 2019), contrastive representation learning (Wu et al., 2018; He et al., 2020; Chen et al., 2020a), online/offline clustering (Yang et al., 2016; Caron et al., 2018; Li et al., 2020; Caron et al., 2020; Grill et al., 2020), etc. Among them, several recent works (He et al., 2020; Chen et al., 2020a; Caron et al., 2020) have achieved comparable or even better accuracy than the supervised pre-training when transferring to downstream tasks, e.g. semi-supervised classification, object detection.
+
+The aforementioned top-performing SSL algorithms all involve large networks (e.g., ResNet-50 (He et al., 2016) or larger), with, however, little attention on small networks. Empirically, we find that existing techniques like contrastive learning do not work well on small networks. For instance, the linear probe top-1 accuracy on ImageNet using MoCo-V2 (Chen et al., 2020c) is only $3 6 . 3 \%$ with MobileNetV3-Large (see Figure 1), which is much lower compared with its supervised training accuracy
+
+![](images/d4fb00f69f184e9fccdf211a9f298a6ff3e7571f5dfb94ff7b3d5393734ffc54.jpg)  
+Figure 1: SEED vs. MoCo-V2 (Chen et al., 2020c)) on ImageNet-1K linear probe accuracy. The vertical axis is the top-1 accuracy and the horizontal axis is the number of learnable parameters for different network architectures. Directly applying self-supervised contrastive learning (MoCo-V2) does not work well for smaller architectures, while our method (SEED) leads to dramatic performance boost. Details of the setting can be found in Section 4.
+
+$7 5 . 2 \%$ (Howard et al., 2019). For EfficientNet-B0, the accuracy is $4 2 . 2 \%$ compared with its supervised training accuracy $7 7 . 1 \%$ (Tan & Le, 2019). We conjecture that this is because smaller models with fewer parameters cannot effectively learn instance level discriminative representation with large amount of data.
+
+To address this challenge, we inject knowledge distillation (KD) (Bucilua et al. ˇ , 2006; Hinton et al., 2015) into self-supervised learning and propose self-supervised distillation (dubbed as SEED) as a new learning paradigm. That is, train the larger, and distill to the smaller both in self-supervised manner. Instead of directly conducting self-supervised training on a smaller model, SEED first trains a large model (as the teacher) in a self-supervised way, and then distills the knowledge to the smaller model (as the student). Note that the conventional distillation is for supervised learning, while the distillation here is in the self-supervised setting without any labeled data. Supervised distillation can be formulated as training a student to mimic the probability mass function over classes predicted by a teacher model. In unsupervised knowledge distillation setting, however, the distribution over classes is not directly attainable. Therefore, we propose a simple yet effective self-supervised distillation method. Similar to (He et al., 2020; Wu et al., 2018), we maintain a queue of data samples. Given an instance, we first use the teacher network to obtain its similarity scores with all the data samples in the queue as well as the instance itself. Then the student encoder is trained to mimic the similarity score distribution inferred by the teacher over these data samples.
+
+The simplicity and flexibility that SEED brings are self-evident. 1) It does not require any clustering/prototypical computing procedure to retrieve the pseudo-labels or latent classes. 2) The teacher model can be pre-trained with any advanced SSL approach, e.g., MoCo-V2 (Chen et al., 2020c), SimCLR (Chen et al., 2020a), SWAV (Caron et al., 2020). 3) The knowledge can be distilled to any target small networks (either shallower, thinner, or totally different architectures).
+
+To demonstrate the effectiveness, we comprehensively evaluate the learned representations on series of downstream tasks, e.g., fully/semi-supervised classification, object detection, and also assess the transferability to other domains. For example, on ImageNet-1k dataset, SEED improves the linear probe accuracy of EfficientNet-B0 from $4 2 . 2 \%$ to $6 7 . 6 \%$ (a gain over $2 5 \%$ ), and MobileNet-V3 from $3 6 . 3 \%$ to $6 8 . 2 \%$ (a gain over $3 1 \%$ ) compared to MoCo-V2 baselines, as shown in Figure 1 and Section 4.
+
+Our contributions can be summarized as follows:
+
+• We are the first to address the problem of self-supervised visual representation learning for small models. We propose a self-supervised distillation (SEED) technique to transfer knowledge from a large model to a small model without any labeled data. With the proposed distillation technique (SEED), we significantly improve the state-of-theart SSL performance on small models.   
+• We exhaustively compare a variety of distillation strategies to show the validity of SEED under multiple settings.
+
+# 2 RELATED WORK
+
+Among the recent literature in self-supervised learning, contrastive based approaches show prominent results on downstream tasks. Majority of the techniques along this direction are stemming from noise-contrastive estimation (Gutmann & Hyvärinen, 2010) where the latent distribution is estimated by contrasting with randomly or artificially generated noises. Oord et al. (2018) first proposed Info-NCE to learn image representations by predicting the future using an auto-regressive model for unsupervised learning. Follow-up works include improving the efficiency (Hénaff et al., 2019), and using multi-view as positive samples (Tian et al., 2019b). As these approaches can only have the access to limited negative instances, Wu et al. (2018) designed a memory-bank to store the previously seen random representations as negative samples, and treat each of them as independent categories (instance discrimination). However, this approach also comes with a deficiency that the previously stored vectors are inconsistent with the recently computed representations during the earlier stage of pre-training. Chen et al. (2020a) mitigate this issue by sampling negative samples from a large batch. Concurrently, He et al. (2020) improve the memory-bank based method and propose to use the momentum updated encoder for the remission of representation inconsistency. Other techniques include Misra & Maaten (2020) that combines the pretext-invariant objective loss with contrastive learning, and Wang & Isola (2020) that decomposes contrastive loss into alignment and uniformity objectiveness.
+
+Knowledge distillation (Hinton et al., 2015) aims to transfer knowledge from a cumbersome model to a smaller one without losing too much generalization power, which is also well investigated in model compression (Bucilua et al. ˇ , 2006). Instead of mimicking the teacher’s output logit, attention transfer (Zagoruyko & Komodakis, 2016) formulates knowledge distillation on attention maps. Similarly, works in (Ahn et al., 2019; Yim et al., 2017; Koratana et al., 2019; Huang & Wang, 2017) have utilized different learning objectives including consistency on feature maps, consistency on probability mass function, and maximizing the mutual information. CRD (Tian et al., 2019a), which is derived from CMC (Tian et al., 2019b), optimizes the student network by a similar objective to Oord et al. (2018) using a derived lower bound on mutual information. However, the aforementioned efforts all focus on task-specific distillation (e.g., image classification) during the fine-tuning phase rather than a task-agnostic distillation in the pre-training phase for the representation learning. Several works on natural language pre-training proposed to leverage knowledge distillation for a smaller yet stronger small models. For instances, DistillBert (Sanh et al., 2019), TinyBert (Jiao et al., 2019), and MobileBert (Sun et al., 2020), have used knowledge distillation for model compression and shown their validity on multiple downstream tasks. Similar works also emphasize the value of smaller and faster models for language representation learning by leveraging knowledge distillation (Turc et al., 2019; Sun et al., 2019). These works all demonstrate the effectiveness of knowledge distillation for language representation learning in small models, while are not extended to the pre-training for visual representations. Notably, a recent concurrent work CompRess (Abbasi Koohpayegani et al., 2020) also point out the importance to develop better SSL method for smaller models. SEED closely relates to the above techniques but aims to facilitate visual representation learning during pre-training phase using distillation technique for small models, which as far as we know has not yet been investigated.
+
+# 3 METHOD
+
+# 3.1 PRELIMINARY ON KNOWLEDGE DISTILLATION
+
+Knowledge distillation (Hinton et al., 2015; Bucilua et al.ˇ , 2006) is an effective technique to transfer knowledge from a strong teacher network to a target student network. The training task can be generalized as the following formulation:
+
+$$
+\hat { \theta } _ { S } = \underset { \theta _ { S } } { \arg \operatorname* { m i n } } \sum _ { i } ^ { N } \mathcal { L } _ { \mathrm { s u p } } ( \mathbf { x } _ { i } , \theta _ { S } , y _ { i } ) + \mathcal { L } _ { \mathrm { d i s t i l l } } ( \mathbf { x } _ { i } , \theta _ { S } , \theta _ { T } ) ,
+$$
+
+where $\mathbf { x } _ { i }$ is an image, $y _ { i }$ is the corresponding annotation, $\theta _ { S }$ is the parameter set for the student network, and $\theta _ { T }$ is the set for the teacher network. The loss $\mathcal { L } _ { \mathrm { s u p } }$ is the alignment error between the network prediction and the annotation. For example in image classification task (Mishra & Marr, 2017; Shen & Savvides, 2020; Polino et al., 2018; Cho & Hariharan, 2019), it is normally a cross entropy loss. For object detection (Liu et al., 2019; Chen et al., 2017), it includes bounding box regression as well. The loss of ${ \mathcal { L } } _ { \mathrm { d i s t i l l } }$ is the mimic error of the student network towards a pre-trained teacher network. For example in (Hinton et al., 2015), the teacher signal comes from the softmax prediction of multiple large-scale networks and the loss is measured by the Kullback–Leibler divergence. In Romero et al. (2014), the task is to align the intermediate feature map values and to minimize the squared $l 2$ distance. The effectiveness has been well demonstrated in the supervised setting with labeled data, but remains unknown for the unsupervised setting, which is our focus.
+
+# 3.2 SELF-SUPERVISED DISTILLATION FOR VISUAL REPRESENTATION
+
+Different from supervised distillation, SEED aims to transfer knowledge from a large model to a small model without requiring labeled data, so that the learned representations in small model can be used for downstream tasks. Inspired by contrastive SSL, we formulate a simple approach for the distillation on the basis of instance similarity distribution over a contrastive instance queue. Similar to He et al. (2020), we maintain an instance queue for storing data samples’ encoding output from the teacher. Given a new sample, we compute its similarity scores with all the samples in the queue using both the teacher and the student models. We require that the similarity score distribution computed by the student matches with that computed by the teacher, which is formulated as minimizing the cross entropy between the student and the teacher’s similarity score distributions (as illustrated in Figure 2).
+
+![](images/2f2a03a1e9389d9452c8beee5f2f9f477f5576361541704a7434d89396409316.jpg)  
+Figure 2: Illustration of our self-supervised distillation pipeline. The teacher encoder is pre-trained by SSL and kept frozen during the distillation. The student encoder is trained by minimizing the cross entropy of probabilities from teacher & student for an augmented view of an image, computed over a dynamically maintained queue.
+
+Specifically, for a randomly augmented view $\mathbf { x } _ { i }$ of an image, it is first mapped and normalized into feature vector representations $\mathbf { z } _ { i } ^ { T } = f _ { \theta } ^ { T } ( \mathbf { x } _ { i } ) / \vert \vert f _ { \theta } ^ { T } ( \mathbf { x } _ { i } ) \vert \vert _ { 2 }$ , and $\mathbf { z } _ { i } ^ { S } = f _ { \theta } ^ { S } ( \mathbf { \bar { x } } _ { i } ^ { \star } ) / \vert \vert f _ { \theta } ^ { S } ( \mathbf { x } _ { i } ) \vert \vert _ { 2 }$ , where $\mathbf { z } _ { i } ^ { T } , \mathbf { z } _ { i } ^ { S } \in \mathbb { R } ^ { D }$ , and $f _ { \theta } ^ { T }$ and $f _ { \theta } ^ { S }$ θ θ θ θdenote the teacher and student encoders, respectively. Let $\mathbf { D } =$ $[ \mathbf { d } _ { 1 } . . . \mathbf { d } _ { K } ]$ denote the instance queue where $K$ is the queue length and ${ \bf d } _ { j }$ is the feature vector obtained from the teacher encoder. Similar to the contrastive learning framework, $\mathbf { D }$ is progressively updated under the “first-in first-out” strategy as distillation proceeds. That is, we en-queue the visual features of the current batch inferred by the teacher and de-queue the earliest seen samples at the end of iteration. Note that the maintained samples in queue $\mathbf { D }$ are mostly random and irrelevant to the target instance $\mathbf { x } _ { i }$ . Minimizing the cross entropy between the similarity score distribution computed by the student and teacher based on $\mathbf { D }$ softly contrasts $\mathbf { x } _ { i }$ with randomly selected samples, without directly aligning with the teacher encoder. To address this problem, we add the teacher’s embedding $( \mathbf { z } _ { i } ^ { T } )$ into the queue and form $\mathbf { D } ^ { + } = [ \mathbf { d } _ { 1 } . . . \mathbf { d } _ { K } , \mathbf { d } _ { K + 1 } ]$ with $\mathbf { d } _ { K + 1 } = \mathbf { z } _ { i } ^ { T }$ .
+
+Let $\mathbf { p } ^ { T } ( \mathbf { x } _ { i } ; \boldsymbol { \theta } _ { T } ; \mathbf { D } ^ { + } )$ denote the similarity score between the extracted teacher feature $\mathbf { z } _ { i } ^ { T }$ and ${ \bf d } _ { j }$ ’s $( j = 1 , . . . , K + 1 )$ computed by the teacher model. $\mathbf { p } ^ { T } ( \mathbf { x } _ { i } ; \boldsymbol { \theta } _ { T } ; \mathbf { D } ^ { + } )$ is defined as
+
+$$
+\mathbf { p } ^ { T } ( \mathbf { x } _ { i } ; \theta _ { T } , \mathbf { D } ^ { + } ) = \left[ p _ { 1 } ^ { T } \dots p _ { K + 1 } ^ { T } \right] , \qquad p _ { j } ^ { T } = \frac { \exp ( \mathbf { z } _ { i } ^ { T } \cdot \mathbf { d } _ { j } / \tau ^ { T } ) } { \sum _ { \mathbf { d } \sim \mathbf { D } ^ { + } } \exp ( \mathbf { z } _ { i } ^ { T } \cdot \mathbf { d } / \tau ^ { T } ) } ,
+$$
+
+and $\tau ^ { T }$ is a temperature parameter for the teacher. Note, we use $( ) ^ { T }$ to represent the feature from the teacher network and use $( \cdot )$ to represent the inner product between two features.
+
+Similarly let $\mathbf { p } ^ { S } ( x _ { i } ; \theta _ { S } , \mathbf { D } ^ { + } )$ denote the similarity score computed by the student model, which is defined as
+
+$$
+\mathbf { p } ^ { S } ( \mathbf { x } _ { i } ; \theta _ { S } , \mathbf { D } ^ { + } ) = \left[ p _ { 1 } ^ { S } \dots p _ { K + 1 } ^ { S } \right] , \qquad { \mathrm { w h e r e ~ } } p _ { j } ^ { S } = { \frac { \exp ( \mathbf { z } _ { i } ^ { S } \cdot \mathbf { d } _ { j } / \tau ^ { S } ) } { \sum _ { \mathbf { d } \sim \mathbf { D } ^ { + } } \exp ( \mathbf { z } _ { i } ^ { S } \cdot \mathbf { d } / \tau ^ { S } ) } } ,
+$$
+
+and $\tau ^ { S }$ is a temperature parameter for the student.
+
+Our self-supervised distillation can be formulated as minimizing the cross entropy between the similarity scores of the teacher, $\mathbf { p } ^ { T } ( \mathbf { x } _ { i } ; \theta _ { T } , \mathbf { D } ^ { + } )$ , and the student, $\mathbf { p } ^ { S } ( \mathbf { x } _ { i } ; \boldsymbol { \theta } _ { S } , \mathbf { D } ^ { \dagger } )$ , over all the instances $\mathbf { x } _ { i }$ , that is,
+
+$$
+\begin{array} { r l } & { \boldsymbol { \hat { \theta } _ { S } } = \underset { \boldsymbol { \theta _ { S } } } { \arg \operatorname* { m i n } } \sum _ { i } ^ { N } - \mathbf { p } ^ { T } ( \mathbf { x } _ { i } ; \boldsymbol { \theta _ { T } } , \mathbf { D } ^ { + } ) \cdot \log \mathbf { p } ^ { S } ( \mathbf { x } _ { i } ; \boldsymbol { \theta _ { S } } , \mathbf { D } ^ { + } ) } \\ & { \quad = \underset { \boldsymbol { \theta _ { S } } } { \arg \operatorname* { m i n } } \sum _ { i } ^ { N } \sum _ { j } ^ { K + 1 } - \frac { \exp \left( \mathbf { z } _ { i } ^ { T } \cdot \mathbf { d } _ { j } / \tau ^ { T } \right) } { \sum _ { \mathbf { d } \sim \mathbf { D } ^ { + } } \exp \left( \mathbf { z } _ { i } ^ { T } \cdot \mathbf { d } / \tau ^ { T } \right) } \cdot \log \frac { \exp \left( \mathbf { z } _ { i } ^ { S } \cdot \mathbf { d } _ { j } / \tau ^ { S } \right) } { \sum _ { \mathbf { d } \sim \mathbf { D } ^ { + } } \exp \left( \mathbf { z } _ { i } ^ { S } \cdot \mathbf { d } / \tau ^ { S } \right) } . } \end{array}
+$$
+
+Since the teacher network is pre-trained and frozen, the queued features are consistent during training w.r.t. the student network. The higher the value of $p _ { j } ^ { I ^ { \prime } }$ is, the larger weight will be laid on $p _ { j } ^ { S }$ . Due to the l2 normalization, similarity score between ${ \mathbf z } _ { i } ^ { T }$ and ${ \bf d } _ { K + 1 }$ remains constant 1 before softmax normalization, which is the largest among $p _ { j } ^ { T }$ . Thus, the weight for $p _ { K + 1 } ^ { S }$ is the largest and can be adjusted solely by tuning the value of $\tau ^ { T }$ . By minimizing the loss, the feature of $\mathbf { z } _ { i } ^ { S }$ can be aligned with ${ \mathbf z } _ { i } ^ { T }$ and meanwhile contrasts with other unrelated image features in $\mathbf { D }$ . We further discuss the relation of these two goals with our learning objective in Appendix A.5.
+
+Relations with Info-NCE loss. When $\tau ^ { T } \to 0$ , the softmax function for $\mathbf { p } ^ { T }$ smoothly approaches to a one-hot vector, where $p _ { K + 1 } ^ { T }$ equals 1 and all others 0. In this extreme case, the loss becomes
+
+$$
+\mathcal { L } _ { N C E } = \sum _ { i } ^ { N } - \log \frac { \exp ( \mathbf { z } _ { i } ^ { T } \cdot \mathbf { z } _ { i } ^ { S } / \tau ) } { \sum _ { \mathbf { d } \sim \mathbf { D } ^ { + } } \exp ( \mathbf { z } _ { i } ^ { S } \cdot \mathbf { d } / \tau ) } ,
+$$
+
+which is similar to the widely-used Info-NCE loss (Oord et al., 2018) in contrastive-based SSL (see discussion in Appendix A.6.
+
+# 4 EXPERIMENT
+
+# 4.1 PRE-TRAINING
+
+Self-Supervised Pre-training of Teacher Network. By default, we use MoCo-V2 (Chen et al., 2020c) to pre-train the teacher network. Following (Chen et al., 2020a), we use ResNet as the network backbone with different depths/widths and append a multi-layer-perceptron (MLP) layer (two linear layers and one ReLU (Nair & Hinton, 2010) activation layer in between) at the end of the encoder after average pooling. The dimension of the last feature dimension is 128. All teacher networks are pre-trained for 200 epochs due to the computational limitation unless explicitly specified. As our distillation is independent with the teacher pre-training algorithm, we also show results with other self-supervised pre-trained models for teacher network, e.g., SWAV (Caron et al., 2020), SimCLR (Chen et al., 2020a).
+
+Self-Supervised Distillation on Student Network. We choose multiple smaller networks with fewer learnable parameters as the student network: MobileNet-v3-Large (Howard et al., 2017), EfficientNet-B0 (Tan & Le, 2019), and smaller ResNet with fewer layers (ResNet-18, 34). Similar to the pre-training for teacher network, we add one additional MLP layer on the basis of the student network. Our distillation is trained with a standard SGD optimizer with momentum 0.9 and a weight decay parameter of 1e-4 for 200 epochs. The initial learning rate is set as 0.03 and updated by a cosine decay scheduler (Nair & Hinton, 2010) with 5 warm-up epochs and batch size 256. In Eq. 4, the teacher temperature is set as $\tau ^ { T } = 0 . 0 1$ and the student temperature is $\tau ^ { S } = 0 . 2$ . The queue size of $K$ is 65,536. In the following subsections and appendix, we also show results with different hyper-parameter values, e.g., for $\tau ^ { T }$ and $K$ .
+
+# 4.2 FINE-TUNING AND EVALUATION
+
+In order to validate the effectiveness of self-supervised distillation, we choose to assess the performance of representations of the student encoder on several downstream tasks. We first report its performances of linear evaluation and semi-supervised linear evaluation on the ImageNet ILSVRC2012 (Deng et al., 2009) dataset. To measure the feature transferability brought by distillation, we also conduct evaluations on other tasks, which include object detection and segmentation on the VOC07 (Everingham et al.) and MS-COCO (Lin et al., 2014) datasets. At the end, we compare the transferability of the features learned by distillation with ordinary self-supervised contrastive learning on the tasks of linear classification on datasets from different domains.
+
+Linear and KNN Evaluation on ImageNet. We conduct the supervised linear classification on ImageNet-1K, which contains ${ \sim } 1 . 3 \mathbf { M }$ images for training, and 50,000 images for validation, spanning 1,000 categories. Following previous works in (He et al., 2020; Chen et al., 2020a), we train a single linear layer classifier on top of the frozen network encoder after self-supervised pretraining/distillation. SGD optimizer is used to train the linear classifier for 100 epochs with weight decay to be 0. The initial learning rate is set as 30 and is then reduced by a factor of 10 at 60 and 80 epochs (similar as in Tian et al. (2019a)). Notably, when training the linear classifier for MobileNet and EfficientNet, we reduce the initial learning rate to 3. The results are reported in terms of Top-1 and Top-5 accuracy. We also perform classification using $K$ -Nearest Neighbors (KNN) based on the learned 128d vector from the last MLP layer. The sample is classified by taking the most frequent label of its $K$ ( $K = 1 0$ ) nearest neighbors.
+
+Table 1: ImageNet-1k test accuracy $( \% )$ using KNN and linear classification for multiple students and MoCov2 pre-trained deeper teacher architectures. $\pmb { \chi }$ denotes MoCo-V2 self-supervised learning baselines before distillation. \* indicates using a deeper teacher encoder pre-trained by SWAV, where additional small-patches are also utilized during distillation and trained for 800 epochs. $K$ denotes Top-1 accuracy using KNN. T-1 and T-5 denote Top-1 and Top-5 accuracy using linear evaluation. First column shows Top-1 Acc. of Teacher network. First row shows the supervised performances of student networks.   
+
+<table><tr><td rowspan="2">S T</td><td rowspan="2">T-1</td><td rowspan="2">K</td><td colspan="2">Eff-bo</td><td colspan="3">Eff-b1</td><td colspan="3">Mob-v3</td><td colspan="3">R-18</td><td colspan="3">R-34</td></tr><tr><td>T-1</td><td>T-5</td><td>K</td><td>T-1</td><td>T-5</td><td>K</td><td>T-1</td><td>T-5</td><td>K</td><td>T-1</td><td>T-5</td><td>K</td><td>T-1</td><td>T-5</td></tr><tr><td>Supervised Acc.</td><td></td><td></td><td>77.3</td><td></td><td></td><td>79.2</td><td></td><td></td><td>75.2</td><td></td><td></td><td>72.1</td><td></td><td></td><td>75.0</td><td></td></tr><tr><td>X</td><td></td><td>30.0</td><td>42.2</td><td></td><td>68.534.4</td><td>50.7</td><td>74.6</td><td>27.5</td><td>36.3</td><td>62.2</td><td>36.7</td><td>52.5</td><td>77.0</td><td>）41.5</td><td>57.4</td><td>81.6</td></tr><tr><td>R-50 △</td><td>67.4</td><td>46.0 +16.0</td><td>61.3 +19.1</td><td>82.7 +14.2</td><td>46.1 +16.1</td><td>61.4 +10.7</td><td>83.1 +8.8</td><td>44.8 +17.3</td><td>55.2 +18.9</td><td>80.3 +18.1</td><td>43.4 +6.7</td><td>57.9 +5.1</td><td>82.0 +4.8</td><td>45.2 +3.7</td><td>58.5 +1.1</td><td>82.6 +1.0</td></tr><tr><td>R-101 △</td><td>70.3</td><td>50.1 +20.1</td><td>63.0 +20.8</td><td>83.8 +15.3</td><td>50.3 +15.9</td><td>63.4 +12.7</td><td>84.6 +10.0</td><td>48.8 +21.3</td><td>59.9 +23.6</td><td>83.5 +21.3</td><td>48.6 +11.9</td><td>58.9 +6.4</td><td>82.5 +5.5</td><td>50.5 +9.0</td><td>61.6 +4.2</td><td>84.9 +3.3</td></tr><tr><td>R-152</td><td></td><td>50.7</td><td>65.3</td><td>86.0</td><td>52.4</td><td>67.3</td><td>86.9</td><td>49.5</td><td>61.4</td><td>84.6</td><td>49.1</td><td>59.5</td><td>83.3</td><td>51.4</td><td>62.7</td><td>85.8</td></tr><tr><td>△</td><td>74.2</td><td>+20.7</td><td>+23.1</td><td>+17.5</td><td>+18.0</td><td>+16.6</td><td>+12.3</td><td>+22.0</td><td>+25.1</td><td>+22.4</td><td>+12.4</td><td>+7.0</td><td>+6.3</td><td>+9.9</td><td>+5.3</td><td>+4.2</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>R50×2*</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td>87.4</td><td>60.3</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>△</td><td>77.3</td><td>57.4 +27.4</td><td>67.6 +25.4</td><td>+18.9</td><td>+25.9</td><td>68.0 +17.3</td><td>87.6 +13.0</td><td>55.9 +18.9</td><td>68.2 +31.9</td><td>88.2 +26.0</td><td>55.3 +18.6</td><td>63.0 +10.5</td><td>84.9 +7.9</td><td>58.2 +16.7</td><td>65.7 +8.3</td><td>86.8 +5.2</td></tr></table>
+
+![](images/3623a3702ec553403c1eb676464c6cd00d584bc812cc122bd666f370eb648b7c.jpg)  
+Figure 3: ImageNet-1k Top-1 accuracy for semi-supervised evaluations using $1 \%$ (red line), $10 \%$ (blue line) of the annotations for linear fine-tuning, in comparison with the fully supervised (green line) linear evaluation baseline for SEED. For the points whose Teacher’s number of parameters is at 0, we show the semi-supervised linear evaluation results of MoCo-V2 without any distillation. The Student models tend to perform better on the semi-supervised tasks after distillation from larger Teachers.
+
+Table 1 shows the results with various teacher networks and student networks. We list the baseline of contrastive self-supervised pre-training using MoCo-V2 (Chen et al., 2020c) in the first row for each student architecture. We can see clearly that smaller networks perform rather worse. For example, MobileNet-V3 can only reach $3 6 . 3 \%$ . This aligns well with previous conclusions from (Chen et al., 2020a;b) that bigger models are desired to perform better in contrastive-based self-supervised pretraining. We conjecture that this is mainly caused by the inability of smaller network to discriminate instances in a large-scale dataset. The results also clearly demonstrate that the distillation from a larger network helps boosting the performances of small networks, and show obvious improvement. For instance, with MoCo-V2 pre-trained ResNet-152 (for 400 epochs) as the teacher network, the Top-1 accuracy of MobileNet-V3-Large can be significantly improved from $3 6 . 3 \%$ to $6 1 . 4 \%$ . Furthermore, we use ResNet- $5 0 \times 2$ (provided in Caron et al. (2020)) as the teacher network and adopt the multi-crop trick (see A.2 for details). The accuracy can be further improved to $6 8 . 2 \%$ (last row of Table 1) for MobileNet-V3-Large with 800 epochs of distillation. We note that the gain benefited from distillation becomes more distinct on smaller architectures and we further study the effect of various teacher models in ablations.
+
+Semi-Supervised Evaluation on ImageNet. Following (Oord et al., 2018; Kornblith et al., 2019; Kolesnikov et al., 2019), we evaluate the representation on the semi-supervised task, where a fixed $1 \%$ or $10 \%$ subsets of ImageNet training data (Chen et al., 2020a) are provided with the annotations. After the self-supervised learning with and without distillation, we also train a classifier on top of the representation. The results are shown in Figure 3, where the baseline without distillation is depicted when teacher parameters are 0. As we can see, the accuracy is also improved remarkably with SEED distillation, and a stronger teacher network with more parameters leads to a better performed student network.
+
+Table 2: Object detection and instance segmentation results using contrastive self-supervised learning and SEED distillation using ResNet-18 as backbone: bounding-box AP $( \mathbf { A P } ^ { b b } )$ and mask AP $( \mathbf { A P } ^ { m k } )$ evaluated on VOC07-val and COCO testing split. More results on different backbones can be found in the Appendix. Subscript in green represents improvement is larger than 0.3.   
+
+<table><tr><td rowspan="2">S</td><td rowspan="2">T</td><td colspan="3">VOC Obj. Det.</td><td colspan="3">COCO Obj. Det.</td><td colspan="3">COCO Inst. Segm.</td></tr><tr><td>Apbb</td><td>AP</td><td>AP</td><td>Apbb</td><td>AP</td><td>APP</td><td>Apmk</td><td>AP</td><td>AP</td></tr><tr><td></td><td>X</td><td>46.1</td><td>74.5</td><td>48.6</td><td>35.0</td><td>53.9</td><td>37.7</td><td>31.0</td><td>51.1</td><td>33.1</td></tr><tr><td></td><td>R-50</td><td>46.1(0.0)</td><td>74.8(+0.3)</td><td>49.1(+0.5)</td><td>35.3(+0.3)</td><td>54.2(+0.3)</td><td>37.8(+0.1)</td><td>31.1(+0.1)</td><td>51.1(0.0)</td><td>33.2(+0.1)</td></tr><tr><td>R-18 R-101</td><td></td><td>46.8(+0.7)</td><td>75.8(+1.3)</td><td>49.3(+0.7)</td><td>35.3(+0.3)</td><td>54.3(+0.4)</td><td>37.9(+0.2)</td><td>31.3(+0.3)</td><td>51.3(+0.2)</td><td>33.4(+0.3)</td></tr><tr><td></td><td>R-152</td><td>46.8(+0.7)</td><td>75.9(+1.4)</td><td>50.2(+1.6)</td><td>35.4(+0.4)</td><td>54.4(+0.5)</td><td>38.0(+0.3)</td><td>31.3(+0.3)</td><td>51.4(+0.3)</td><td>33.4(+0.3)</td></tr></table>
+
+![](images/15d565abe6e76f1be7191527af52d1cfceecfa87f6083e78a4a48b0e6be4ff99.jpg)  
+Figure 4: ImageNet-1k Accuracy $( \% )$ of student network (EfficientNet-B0 and ResNet-18) transferred to other domains (CIFAR-10, CIFAR-100, SUN-397 datasets) with and without distillation from lager architectures (ResNet-50/101/152).
+
+Transferring to Classification. To further study whether the improvement of the learned representations by distillation is confined to ImageNet, we evaluate on additional classification datasets to study the generalization and transferability of the feature representation. We strictly follow the linear evaluation and fine-tuning settings from (Kornblith et al., 2019; Chen et al., 2020a; Grill et al., 2020), that a linear layer is trained on the basis of frozen features. We report Top-1 Accuracy of models before and after distillation from various architectures on CIFAR-10, CIFAR-100 (Krizhevsky et al., 2009), SUN-397 (Xiao et al., 2010) datasets (see Figure 4). More details regarding pre-processing and training can be found in A.1.2. Notably, we observe that our distillation surpasses contrastive self-supervised pre-training consistently on all benchmarks, verifying the effectiveness of SEED. This also proves the generalization ability of the learned representations from distillation to a wide range of data domain and different classes.
+
+Transferring to Detection and Segmentation. We conduct two downstream tasks here. The first is Faster R-CNN (Ren et al., 2015) model for object detection trained on VOC- $^ { 0 7 + 1 2 }$ train $^ +$ val set and evaluated on VOC-07 test split. The second is Mask R-CNN (He et al., 2017) model for the object detection and instance segmentation on COCO 2017 dataset (Lin et al., 2014). The pre-trained model serves as the initial weight and following He et al. (2020), we fine-tune all the layers of the model. More experiment settings can be found in A.2. The results are illustrated in Table 2. As we can see, on VOC, the distilled pre-trained model achieves a large improvement. With ResNet-152 as the teacher network, the Resnet18-based Faster R-CNN model shows $+ 0 . 7$ point improvement on AP, $+ 1 . 4$ improvement on $\mathrm { { A P } _ { 5 0 } }$ and $+ 1 . 6$ on $\mathsf { A P } _ { 7 5 }$ . On COCO, the improvement is relatively minor and the reason could be that COCO training set has ${ \sim } 1 1 8 \mathrm { k }$ training images while VOC has only ${ \sim } 1 6 . 5 \mathrm { k }$ training images. A larger training set with more fine-tuning iterations reduces the importance of the initial weights.
+
+# 4.3 ABLATION STUDY
+
+We now explore the effects of distillation using different Teacher architectures, Teacher Pre-training algorithms, various distillation strategies and hyper-parameters.
+
+Table 3: ImageNet-1k Accuracy $( \% )$ of student network (ResNet-18) distilled from variants of selfsupervised ResNet-50. P-E/D-E represent the pretraining and distillation epochs. T./S.-Top represent testing accuracy of Teacher and Student. ∗ represents distillation using additional small patches. First row is the ResNet-18 SSL baseline using MoCo-v2 trained for 200 epochs.   
+
+<table><tr><td>Teacher</td><td></td><td>P-E D-E T.Top-1 S.Top-1 S.Top-5</td></tr><tr><td></td><td>X X</td><td>X 52.5 77.0</td></tr><tr><td>X</td><td>200</td><td></td></tr><tr><td>MoCo</td><td>200</td><td>60.6 52.1 77.0</td></tr><tr><td>SimCLR</td><td>200 200</td><td>65.6 57.5 81.7</td></tr><tr><td>MoCo-v2 200 800</td><td>200 67.4</td><td>57.9 82.0</td></tr><tr><td>SWAV 800</td><td>200 71.1</td><td>60.5 83.5</td></tr><tr><td></td><td>100 75.3</td><td>61.1 83.8</td></tr><tr><td>800</td><td>200 75.3</td><td>61.7 84.2</td></tr><tr><td>800</td><td>400 75.3</td><td>62.0 84.4</td></tr><tr><td>SWAV* 800</td><td>200 75.3</td><td>62.6 84.8</td></tr></table>
+
+![](images/8cecf45d517b8c5b96207f2fc90806edfe43935c7cfa9552a0ceb80d0db26208.jpg)  
+Figure 5: Accuracy $( \% )$ of student networks (EfficientNet-b0 and ResNet-18) on ImageNet distilled from wider MoCo-v2 pre-trained ResNet (ResNet-50/101/152×2).
+
+Different Teacher Networks. Figure 5 summarizes the accuracy of ResNet-18 and EfficientNet-B0 distilled from wider and deeper ResNet architectures. We see clear performance improvement as depth and width of teacher network increase: compared to ResNet-50, deeper (ResNet-101) and wider (ResNet- ${ 5 0 \times 2 }$ ) substantially improve the accuracy. However, further architectural enlargement has relatively limited effects, and we suspect the accuracy might be limited by the student network capacity in this case.
+
+Different Teacher Pre-training Algorithms. In Table 3, we show the Top-1 accuracy of ResNet-18 distilled from ResNet-50 with different pre-training algorithms, i.e., MoCo-V1 (He et al., 2020), MoCo-V2 (Chen et al., 2020c), SimCLR (Chen et al., 2020a), and SWAV (Caron et al., 2020)). Notably, the aforementioned methods all unanimously adopt contrastive-based pre-training except SWAV, which is based upon online clustering. We find that our SEED is agnostic to pre-training approaches, making it easy to use any self-supervised models (including clustering-based approach like SWAV) in self-supervised distillation. In addition, we observe that more training epochs for both teacher $S S L$ and distillation epochs can bring beneficial gain.
+
+Other Distillation Strategies. We explore several alternative distillation strategies. l2-Distance: where the $l 2$ -distance of teacher & student’s embeddings are minimized, motivated by Romero et al. (2014). $K$ -Means: we exploit $K$ -Means clustering to assign a pseudo-label based on the teacher network’s representation. Online Clustering: we continuously update the clustering centers during distillation for pseudo-label generation. Binary Contrastive Loss: we adopt an Info-NCE alike loss for contrastive distillation (Tian et al., 2019a). We provide details for other strategies in A.4. Table 4 shows the results for each method on ResNet-18 (student) distilled from ResNet-50. From the results, the simple $l 2$ -distance minimizing approach can achieve a decent accuracy, which demonstrates the effectiveness of applying the distillation idea to the self-supervised learning. Beyond that, we study the effect of the original SSL (MoCo-V2) supervision as supplementary loss to SEED and find it does not bring additional benefits to distillation. We find close results from these two strategies (Top-1 linear Acc.), SEED achieves $5 7 . 9 \%$ , while $\mathbf { S E E D + M o C o - V } 2$ achieves $5 7 . 6 \%$ . This implies that the loss of SEED can to a large extent cover the original $S S L$ loss, and it is not necessary to conduct SSL any further during distillation. Meanwhile, our proposed SEED outperforms these alternatives with highest accuracy, which shows the superiority of aligning the student towards the teacher and contrasting with the irrelevant samples.
+
+Other Hyper-Parameters. Table 5 summarizes the distillation performances on multiple datasets using different temperature $\tau ^ { T }$ . We observe a better performance when decreasing $\tau ^ { T }$ to 0.01 for ImageNet-1k and CIFAR-10 dataset, and to 1e-3 for CIFAR-100 datasets. When $\tau$ is large, the softmax-normalized similarity score of $p _ { j } ^ { T }$ between ${ \mathbf z } _ { i } ^ { T }$ and instance ${ \bf d } _ { j }$ in the queue $\mathbf { D } ^ { + }$ also becomes large, which means the student’s feature should be less discriminative with the features of other images to some extent. When $\tau ^ { T }$ is $_ 0$ , the teacher model will generate a one-hot vector, which only treats ${ \mathbf z } _ { i } ^ { T }$ as a positive instance and all others in the queue as negative. Thus, the best $\tau$ is a trade-off depending on the data distribution. We further compare effect of different hyper-parameters in A.8.
+
+Table 4: Top-1/5 accuracy of linear classification results on ImageNet using different distillation strategies on ResNet-18 (student) and ResNet-50 (teacher) architectures.   
+
+<table><tr><td>Method</td><td colspan="2">Top-1 Acc. Top-5 Acc.</td></tr><tr><td>l2-Distance</td><td>55.3</td><td>80.3</td></tr><tr><td>K-Means</td><td>51.0</td><td>75.8</td></tr><tr><td>Online Clustering</td><td>56.4</td><td>81.2</td></tr><tr><td>Binary Contr. Loss</td><td>57.4</td><td>81.5</td></tr><tr><td>SEED +MoCo-V2</td><td>57.6</td><td>81.8</td></tr><tr><td>SEED</td><td>57.9</td><td>82.0</td></tr></table>
+
+Table 5: Effect of $\tau ^ { T }$ for the distillation of ResNet-18 (student), ResNet-50 (teacher) on multiple datasets.   
+
+<table><tr><td rowspan="2">YT</td><td>ImageNet</td><td>CIFAR-10</td><td>CIFAR-100</td></tr><tr><td>Top-1 Top-5</td><td>Top-1</td><td>Top-1</td></tr><tr><td>0.3</td><td>54.8 80.0</td><td>78.7</td><td>46.6</td></tr><tr><td>0.1</td><td>54.9 80.1</td><td>83.0</td><td>50.1</td></tr><tr><td>0.05</td><td>56.5 81.3</td><td>84.4</td><td>56.2</td></tr><tr><td>0.01</td><td>57.9 82.0</td><td>87.5 </td><td>60.6</td></tr><tr><td>1e-3</td><td>57.6 81.8</td><td>86.9</td><td>60.8</td></tr></table>
+
+# 5 CONCLUSIONS
+
+Self-Supervised Learning is acknowledged for its remarkable ability in learning from unlabeled, and large scale data. However, a critical impedance for the SSL pre-training on smaller architecture comes from its low capacity of discriminating enormous number of instances. Instead of directly learning from unlabeled data, we proposed SEED as a novel self-supervised learning paradigm, which learns representation by self-supervised distillation from a bigger SSL pre-trained model. We show in extensive experiments that SEED effectively addresses the weakness of self-supervised learning for small models and achieves state-of-the-art results on various benchmarks of small architectures.
+
+# REFERENCES
+
+Soroush Abbasi Koohpayegani, Ajinkya Tejankar, and Hamed Pirsiavash. Compress: Self-supervised learning by compressing representations. Advances in Neural Information Processing Systems, 33, 2020.
+
+Sungsoo Ahn, Shell Xu Hu, Andreas Damianou, Neil D Lawrence, and Zhenwen Dai. Variational information distillation for knowledge transfer. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 9163–9171, 2019.
+
+Cristian Bucilua, Rich Caruana, and Alexandru Niculescu-Mizil. Model compression. In ˇ Proceedings of the 12th ACM SIGKDD international conference on Knowledge discovery and data mining, pp. 535–541, 2006.
+
+Mathilde Caron, Piotr Bojanowski, Armand Joulin, and Matthijs Douze. Deep clustering for unsupervised learning of visual features. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 132–149, 2018.
+
+Mathilde Caron, Ishan Misra, Julien Mairal, Priya Goyal, Piotr Bojanowski, and Armand Joulin. Unsupervised learning of visual features by contrasting cluster assignments. arXiv preprint arXiv:2006.09882, 2020.
+
+Guobin Chen, Wongun Choi, Xiang Yu, Tony Han, and Manmohan Chandraker. Learning efficient object detection models with knowledge distillation. In Advances in Neural Information Processing Systems, pp. 742–751, 2017.
+
+Ting Chen, Simon Kornblith, Mohammad Norouzi, and Geoffrey Hinton. A simple framework for contrastive learning of visual representations. arXiv preprint arXiv:2002.05709, 2020a.
+
+Ting Chen, Simon Kornblith, Kevin Swersky, Mohammad Norouzi, and Geoffrey Hinton. Big self-supervised models are strong semi-supervised learners. arXiv preprint arXiv:2006.10029, 2020b.
+
+Xinlei Chen, Haoqi Fan, Ross Girshick, and Kaiming He. Improved baselines with momentum contrastive learning. arXiv preprint arXiv:2003.04297, 2020c.
+
+Jang Hyun Cho and Bharath Hariharan. On the efficacy of knowledge distillation. In Proceedings of the IEEE International Conference on Computer Vision, pp. 4794–4802, 2019.
+
+Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In 2009 IEEE conference on computer vision and pattern recognition, pp. 248–255. Ieee, 2009.
+
+M. Everingham, L. Van Gool, C. K. I. Williams, J. Winn, and A. Zisserman. The PASCAL Visual Object Classes Challenge 2007 (VOC2007) Results. http://www.pascalnetwork.org/challenges/VOC/voc2007/workshop/index.html.
+
+Zeyu Feng, Chang Xu, and Dacheng Tao. Self-supervised representation learning by rotation feature decoupling. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 10364–10374, 2019.
+
+Spyros Gidaris, Praveer Singh, and Nikos Komodakis. Unsupervised representation learning by predicting image rotations. arXiv preprint arXiv:1803.07728, 2018.
+
+Jean-Bastien Grill, Florian Strub, Florent Altché, Corentin Tallec, Pierre H Richemond, Elena Buchatskaya, Carl Doersch, Bernardo Avila Pires, Zhaohan Daniel Guo, Mohammad Gheshlaghi Azar, et al. Bootstrap your own latent: A new approach to self-supervised learning. arXiv preprint arXiv:2006.07733, 2020.
+
+Yandong Guo, Lei Zhang, Yuxiao Hu, Xiaodong He, and Jianfeng Gao. Ms-celeb-1m: A dataset and benchmark for large-scale face recognition. In European conference on computer vision, pp. 87–102. Springer, 2016.
+
+Michael Gutmann and Aapo Hyvärinen. Noise-contrastive estimation: A new estimation principle for unnormalized statistical models. In Proceedings of the Thirteenth International Conference on Artificial Intelligence and Statistics, pp. 297–304, 2010.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016.
+
+Kaiming He, Georgia Gkioxari, Piotr Dollár, and Ross Girshick. Mask r-cnn. In Proceedings of the IEEE international conference on computer vision, pp. 2961–2969, 2017.
+
+Kaiming He, Haoqi Fan, Yuxin Wu, Saining Xie, and Ross Girshick. Momentum contrast for unsupervised visual representation learning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 9729–9738, 2020.
+
+Olivier J Hénaff, Aravind Srinivas, Jeffrey De Fauw, Ali Razavi, Carl Doersch, SM Eslami, and Aaron van den Oord. Data-efficient image recognition with contrastive predictive coding. arXiv preprint arXiv:1905.09272, 2019.
+
+Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. arXiv preprint arXiv:1503.02531, 2015.
+
+Andrew Howard, Mark Sandler, Grace Chu, Liang-Chieh Chen, Bo Chen, Mingxing Tan, Weijun Wang, Yukun Zhu, Ruoming Pang, Vijay Vasudevan, et al. Searching for mobilenetv3. In Proceedings of the IEEE International Conference on Computer Vision, pp. 1314–1324, 2019.
+
+Andrew G Howard, Menglong Zhu, Bo Chen, Dmitry Kalenichenko, Weijun Wang, Tobias Weyand, Marco Andreetto, and Hartwig Adam. Mobilenets: Efficient convolutional neural networks for mobile vision applications. arXiv preprint arXiv:1704.04861, 2017.
+
+Zehao Huang and Naiyan Wang. Like what you like: Knowledge distill via neuron selectivity transfer. arXiv preprint arXiv:1707.01219, 2017.
+
+Xiaoqi Jiao, Yichun Yin, Lifeng Shang, Xin Jiang, Xiao Chen, Linlin Li, Fang Wang, and Qun Liu. Tinybert: Distilling bert for natural language understanding. arXiv preprint arXiv:1909.10351, 2019.
+
+Alexander Kolesnikov, Xiaohua Zhai, and Lucas Beyer. Revisiting self-supervised visual representation learning. In Proceedings of the IEEE conference on Computer Vision and Pattern Recognition, pp. 1920–1929, 2019.
+
+Animesh Koratana, Daniel Kang, Peter Bailis, and Matei Zaharia. Lit: Learned intermediate representation training for model compression. In International Conference on Machine Learning, pp. 3509–3518, 2019.
+
+Simon Kornblith, Jonathon Shlens, and Quoc V Le. Do better imagenet models transfer better? In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 2661–2671, 2019.
+
+Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. 2009.
+
+Junnan Li, Pan Zhou, Caiming Xiong, Richard Socher, and Steven CH Hoi. Prototypical contrastive learning of unsupervised representations. arXiv preprint arXiv:2005.04966, 2020.
+
+Tsung-Yi Lin, Michael Maire, Serge Belongie, James Hays, Pietro Perona, Deva Ramanan, Piotr Dollár, and C Lawrence Zitnick. Microsoft coco: Common objects in context. In European conference on computer vision, pp. 740–755. Springer, 2014.
+
+Yifan Liu, Ke Chen, Chris Liu, Zengchang Qin, Zhenbo Luo, and Jingdong Wang. Structured knowledge distillation for semantic segmentation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2604–2613, 2019.
+
+Asit Mishra and Debbie Marr. Apprentice: Using knowledge distillation techniques to improve low-precision network accuracy. arXiv preprint arXiv:1711.05852, 2017.
+
+Ishan Misra and Laurens van der Maaten. Self-supervised learning of pretext-invariant representations. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 6707–6717, 2020.
+
+Vinod Nair and Geoffrey E Hinton. Rectified linear units improve restricted boltzmann machines. In ICML, 2010.
+
+Mehdi Noroozi and Paolo Favaro. Unsupervised learning of visual representations by solving jigsaw puzzles. In European Conference on Computer Vision, pp. 69–84. Springer, 2016.
+
+Aaron van den Oord, Yazhe Li, and Oriol Vinyals. Representation learning with contrastive predictive coding. arXiv preprint arXiv:1807.03748, 2018.
+
+Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, et al. Pytorch: An imperative style, high-performance deep learning library. In Advances in neural information processing systems, pp. 8026–8037, 2019.
+
+Antonio Polino, Razvan Pascanu, and Dan Alistarh. Model compression via distillation and quantization. arXiv preprint arXiv:1802.05668, 2018.
+
+Shaoqing Ren, Kaiming He, Ross Girshick, and Jian Sun. Faster r-cnn: Towards real-time object detection with region proposal networks. In Advances in neural information processing systems, pp. 91–99, 2015.
+
+Adriana Romero, Nicolas Ballas, Samira Ebrahimi Kahou, Antoine Chassang, Carlo Gatta, and Yoshua Bengio. Fitnets: Hints for thin deep nets. 2014.
+
+Mark Sandler, Andrew Howard, Menglong Zhu, Andrey Zhmoginov, and Liang-Chieh Chen. Mobilenetv2: Inverted residuals and linear bottlenecks. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 4510–4520, 2018.
+
+Victor Sanh, Lysandre Debut, Julien Chaumond, and Thomas Wolf. Distilbert, a distilled version of bert: smaller, faster, cheaper and lighter. arXiv preprint arXiv:1910.01108, 2019.
+
+Zhiqiang Shen and Marios Savvides. Meal v2: Boosting vanilla resnet-50 to $80 \text{‰}$ top-1 accuracy on imagenet without tricks. arXiv preprint arXiv:2009.08453, 2020.
+
+Siqi Sun, Yu Cheng, Zhe Gan, and Jingjing Liu. Patient knowledge distillation for bert model compression. arXiv preprint arXiv:1908.09355, 2019.
+
+Zhiqing Sun, Hongkun Yu, Xiaodan Song, Renjie Liu, Yiming Yang, and Denny Zhou. Mobilebert: a compact task-agnostic bert for resource-limited devices. arXiv preprint arXiv:2004.02984, 2020.
+
+Mingxing Tan and Quoc V Le. Efficientnet: Rethinking model scaling for convolutional neural networks. arXiv preprint arXiv:1905.11946, 2019.
+
+Yonglong Tian, Dilip Krishnan, and Phillip Isola. Contrastive representation distillation. In International Conference on Learning Representations, 2019a.
+
+Yonglong Tian, Dilip Krishnan, and Phillip Isola. Contrastive multiview coding. arXiv preprint arXiv:1906.05849, 2019b.
+
+Iulia Turc, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Well-read students learn better: On the importance of pre-training compact models. arXiv preprint arXiv:1908.08962, 2019.
+
+Tongzhou Wang and Phillip Isola. Understanding contrastive representation learning through alignment and uniformity on the hypersphere. arXiv preprint arXiv:2005.10242, 2020.
+
+Yuxin Wu, Alexander Kirillov, Francisco Massa, Wan-Yen Lo, and Ross Girshick. Detectron2, 2019.
+
+Zhirong Wu, Yuanjun Xiong, Stella X Yu, and Dahua Lin. Unsupervised feature learning via nonparametric instance discrimination. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3733–3742, 2018.
+
+Jianxiong Xiao, James Hays, Krista A Ehinger, Aude Oliva, and Antonio Torralba. Sun database: Large-scale scene recognition from abbey to zoo. In 2010 IEEE computer society conference on computer vision and pattern recognition, pp. 3485–3492. IEEE, 2010.
+
+Jianwei Yang, Devi Parikh, and Dhruv Batra. Joint unsupervised learning of deep representations and image clusters. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 5147–5156, 2016.
+
+Sergey Zagoruyko and Nikos Komodakis. Paying more attention to attention: Improving the performance of convolutional neural networks via attention transfer. arXiv preprint arXiv:1612.03928, 2016.
+
+Xiaohua Zhai, Avital Oliver, Alexander Kolesnikov, and Lucas Beyer. S4l: Self-supervised semisupervised learning. In Proceedings of the IEEE international conference on computer vision, pp. 1476–1485, 2019.
+
+Liheng Zhang, Guo-Jun Qi, Liqiang Wang, and Jiebo Luo. Aet vs. aed: Unsupervised representation learning by auto-encoding transformations rather than data. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2547–2555, 2019.
+
+Richard Zhang, Phillip Isola, and Alexei A Efros. Colorful image colorization. In European conference on computer vision, pp. 649–666. Springer, 2016.
+
+Xiao Zhang, Zhiyuan Fang, Yandong Wen, Zhifeng Li, and Yu Qiao. Range loss for deep face recognition with long-tailed training data. In Proceedings of the IEEE International Conference on Computer Vision, pp. 5409–5418, 2017.
+
+# A APPENDIX
+
+We discuss more details and different hyperparameters for SEED during distillation.
+
+A.1 PSEUDO-IMPLEMENTATIONS
+
+We provide pseudo-code of the SEED distillation in PyTorch Paszke et al. (2019) style:
+
+‘‘‘Q: maintaining queue of previous representations: (N X D)   
+2 T: Cumbersome encoder as Teacher.   
+3 S: Target encoder as Student.   
+4 temp_T, temp_S: temperatures of the Teacher & Student.   
+11   
+6   
+7 # activate evaluation mode for Teacher to freeze BN and updation.   
+8 T.eval()   
+9   
+10 for images in enumerate(loader): # Enumerate single crop-view   
+11   
+12 # augment image to get one identical view   
+13 images $=$ aug(images)   
+14   
+15 # Batch-size   
+16 $\begin{array} { r l } { \mathrm { B } } & { { } = } \end{array}$ images.shape[0]   
+17   
+18 # extract embedding from S: 1 X D   
+19 $\mathrm { ~ \cal ~ X ~ \_ ~ S ~ ~ } =$ S(images)   
+20 $\mathrm { ~ \cal ~ X ~ \_ ~ S ~ ~ } =$ torch.norm(X_S, $\mathrm { p } { = } 2$ , dim $^ { = 1 }$ )   
+21   
+22 # use the gradient-free mode   
+23 with torch.no_grad():   
+24 X_T $=$ T(image) # embedding from T: 1 X D   
+25 $\mathrm { ~ X ~ \_ ~ T ~ } =$ torch.norm(X_T, $\mathrm { p } { = } 2$ , dim $^ { = 1 }$ )   
+26   
+27 # insert the current batch embedding from T   
+28 enqueue(Q, X_T)   
+29   
+30 # probability scores distribution for T, S: B X (N + 1)   
+31 S_Dist $=$ torch.einsum(’bd, dn -> bn’, [X_S], Q.t().clone().detach())   
+32 T_Dist $=$ torch.einsum(’bd, dn -> bn’, [X_T], Q.t().clone().detach())   
+33   
+34 # Apply temperatures for soft-labels   
+35 S_Dist / $=$ temp_S   
+36 T_Dist $=$ SoftMax(T_Dist/temp_T, dim $^ { = 1 }$ )   
+37   
+38 # loss computation, use log_softmax for stable computation   
+39 loss $=$ -torch.mul(T_Dist, Log_SoftMax(S_Dist, dim $^ { 1 = 1 }$ )).sum()/B   
+40   
+41 # update the random sample queue   
+42 dequeue(Q, B) # pop-out earliest B instances   
+43   
+44 # SGD updation   
+45 loss.backward()   
+46 update(S.params)
+
+# A.1.1 DATA AUGMENTATIONS
+
+Both our teacher pre-training and distillation adopt the data augmentations as follows:
+
+Random Resized Crop: The image is randomly resized with a scale of {0.2, 1.0}, then cropped to the size of $2 2 4 \times 2 2 4$ .
+
+Random Color Jittering: with brightness to be {0.4, 0.4, 0.4, 0.1} with probability at 0.8.
+
+Random Gray Scale transformation: with probability at 0.2.
+
+Random Gaussian Blur transformation: with $\sigma = \{ 0 . 1 , 0 . 2 \}$ and probability at 0.5.
+
+Horizontal Flip: Horizontal flip is applied with probability at 0.5
+
+# A.1.2 PRE-TRAINING AND DISTILLATION ON MOBILENET AND EFFICIENTNET
+
+MobileNet (Howard et al., 2017) and EfficientNet (Tan & Le, 2019) have been considered as the smaller counterparts with larger models, i.e., ResNet-50 (with supervised training, EfficientNetB0 hits $7 7 . 2 \%$ Top-1 Acc., and MobileNet-V3-large reaches $7 2 . 2 \%$ on ImageNet testing split). Nevertheless, un-matched performances are observed in the task of self-supervised contrastive pretraining: i.e., Self-Supervised Learning (MoCo-V2) on MobileNet-V3 only yields $3 6 . 3 \%$ Top-1 Acc. on ImageNet. We conjecture that several reasons might lead to this dilemma:
+
+1. The inability of models with less parameters for handling large volume of categories and data, which exists also in other domains, i.e., face recognition (Guo et al., 2016; Zhang et al., 2017).   
+2. Less possibility for optimum parameters to be chosen when transferring to downstream tasks: models with more parameters after pre-training might produce a plenty cornucopia of optimum parameters for fine-tuning.
+
+To narrow the dramatic performance gap between smaller architectures using contrastive SSL with the larger, we explore with architectural manipulations and training hyper-parameters. In specific, we find that by adding a deeper projection head largely improves the representation quality, a.k.a., better performances on linear evaluation. We experiment with adding one additional linear projection head on the top of convolutional backbones.
+
+Similarly, we also expand the MLP projection head on EfficientNet-b0. Though recent work shows that fine-tuning from a middle layer of the projection head can produce a largely different result (Chen et al., 2020b), we consistently just use the representations from convolutional trunk without adding extra layers during the phase of linear evaluation. As shown in Table 6, pre-training with a deeper projection head dramatically helps the improvement on linear evaluations, adding $17 \%$ Top-1. Acc. for Mobile-v3-large, and we report the improved baselines in the main paper (see the first row in Table 1 of the main paper). We keep most of the hyper-parameters as the distillation on ResNet except reducing the weight-decay of them to 1e-5, following (Tan & Le, 2019; Sandler et al., 2018).
+
+Table 6: Linear evaluations on ImageNet of EfficientNet and MobileNet pre-trained using MoCo-v2. A deeper projection head largely boosts the linear evaluation performances on smaller architectures.   
+
+<table><tr><td>Model</td><td>Deeper MLPs</td><td>Top-1 Acc. Top-5 Acc.</td><td></td></tr><tr><td>EfficientNet-b0</td><td></td><td>39.1</td><td>64.6</td></tr><tr><td>EfficientNet-b0</td><td>×</td><td>42.2</td><td>68.5</td></tr><tr><td>Mobile-v3-large</td><td>X</td><td>19.0</td><td>41.3</td></tr><tr><td>Mobile-v3-large</td><td>√</td><td>36.3</td><td>62.2</td></tr></table>
+
+# A.2 ADDITIONAL DETAILS OF EVALUATIONS
+
+We list additional details regarding our evaluation experiments in this section.
+
+ImageNet-1k Semi-Supervised Linear Evaluation. Following Zhai et al. (2019); Chen et al. (2020a), we train the FC layers on the basis of our student encoder after distillation using a fraction of labeled ImageNet-1k dataset ( $1 \%$ and $10 \%$ ), and evaluate it on the whole test split. The fraction of labeled dataset is constructed in a class-balanced way, with roughly 12 and 128 images per class∗. We use SGD optimizer and set initial learning rate to be 30 with a multiplier $=$ BatchSize/256 without weight decaying for 100 epochs. We use the step-wise scheduler for the learning rate updating with 5 warm-up epochs, and the learning rate is reduced by 10 at 60 and 80 epochs. On smaller architectures like EfficientNet and MobileNet, we reduce the initial learning rate to 3. During training, the image is center-cropped to the size of $2 2 4 \times 2 2 4$ with just Random Horizontal Flip as the data augmentation. For testing, we first resize the image to $2 5 6 \times 2 5 6$ and use the center cropped $2 2 4 \times 2 2 4$ for pre-processing. In Table 8, we show the distillation results on a larger encoder (ResNet-550) when using different teacher networks.
+
+Table 7: Before and after distillation Top-1/5 test accuracy $( \% )$ on ImageNet of EfficientNet-b0 and MobileNetlarge without deeper MLPs.   
+
+<table><tr><td>Student</td><td>Teacher</td><td>Top-1</td><td>Top-5</td></tr><tr><td rowspan="3">EfficientNet-b0</td><td>X</td><td>39.1</td><td>64.6</td></tr><tr><td>ResNet-50</td><td>59.2</td><td>81.2</td></tr><tr><td>ResNet-101</td><td>62.8</td><td>84.7</td></tr><tr><td></td><td>ResNet-152</td><td>63.3</td><td>85.6</td></tr><tr><td rowspan="3">MobileNet-v3</td><td>X ResNet-50</td><td>19.0 50.9</td><td>41.3 77.7</td></tr><tr><td>ResNet-101</td><td>57.6</td><td>82.6</td></tr><tr><td>ResNet-152</td><td>58.3</td><td>82.9</td></tr></table>
+
+Table 8: ImageNet-1k test accuracy $( \% )$ under KNN and linear classification on ResNet-50 encoder with deeper, MoCo-V2/SWAV pre-trained teacher architectures. $\pmb { \chi }$ denotes MoCo-V2 self-supervised learning baselines before distillation. \* indicates using a stronger teacher encoder pre-trained by SWAV with additional small-patches during distillation.   
+
+<table><tr><td></td><td>Stud.</td><td></td><td>ResNet-50</td><td></td></tr><tr><td>Teac.</td><td>Epoch</td><td>KNN</td><td>Top-1</td><td>Top-5</td></tr><tr><td>X ResNet-50</td><td>200</td><td>46.1 46.1</td><td>67.4 67.5</td><td>87.8 87.8</td></tr><tr><td>△ ResNet-101</td><td>200</td><td>+0.0 52.3</td><td>+0.1</td><td>+0.0</td></tr><tr><td>△</td><td>200</td><td>+6.2</td><td>69.1 +1.7</td><td>88.7 +0.9</td></tr><tr><td>ResNet-152 △</td><td>200</td><td>53.2 +7.1</td><td>70.4 +3.0</td><td>90.5 +2.7</td></tr><tr><td>ResNet-50×2* △</td><td>800</td><td>59.0 +12.9</td><td>74.3 +6.9</td><td>92.2 +4.4</td></tr></table>
+
+Transfer Learning. We test the transferability of the representations learned from self-supervised distillation by conducting the linear evaluations using offline features on several other datasets. Specifically, a single layer logistic classifier is trained following (Chen et al., 2020a; Grill et al., 2020) using SGD optimizer without weight decay and momentum parameter at 0.9. We use CIFAR-10, CIFAR-100 (Krizhevsky et al., 2009) and SUN-397 (Xiao et al., 2010) as our testing beds.
+
+CIFAR: As the size for CIFAR dataset is $3 2 \times 3 2$ , we resize all images to $2 2 4 \times 2 2 4$ pixels along the shorter side using bicubic resampling method, followed by a center crop operation. We set the learning rate at 1e-3 constantly and train it for 120 epochs. The hyper-parameters are searched using 10 fold cross-validation on the train split and report its final top-1 accuracy on the test split.
+
+Table 9: Object detection and instance segmentation fine-tuned on VOC07: bounding-box AP $( \mathsf { A P } ^ { b b } )$ ) and mask AP $( \mathbf { A } \mathbf { P } ^ { m k } )$ ) evaluated on VOC07-val. The first row shows the baseline from MoCo-v2 backbones without distillation.   
+
+<table><tr><td rowspan="2">Student</td><td rowspan="2">Teacher</td><td colspan="3">VOC Object Detection</td></tr><tr><td>APbb</td><td>AP</td><td>AP</td></tr><tr><td rowspan="3">ResNet-34</td><td>X</td><td>53.6</td><td>79.1</td><td>58.7</td></tr><tr><td>ResNet-50</td><td>53.7 (+0.1)</td><td>79.4 (+0.3)</td><td>59.2 (+0.5)</td></tr><tr><td>ResNet-101 ResNet-152</td><td>54.1 (+0.5) 54.4 (+0.8)</td><td>79.8 (+0.7) 80.1 (+1.0)</td><td>59.1 (+0.4) ） 59.9 (+1.2)</td></tr><tr><td rowspan="2">ResNet-50</td><td>X</td><td>57.0</td><td>82.4</td><td>63.6</td></tr><tr><td>ResNet-50 ResNet-101</td><td>57.0 (+0.0) 57.1 (+0.1)</td><td>82.4 (+0.0) 82.8 (+0.4)</td><td>63.6 (+0.0) 63.8 (+0.2)</td></tr></table>
+
+Table 10: Object detection and instance segmentation fine-tuned on COCO: bounding-box AP $( \mathbf { A P } ^ { b b } )$ and mask AP $( \mathbf { A } \mathbf { P } ^ { m k } )$ evaluated on COCO-val2017. The first several rows show the baselines from unsupervised backbones without distillation.   
+
+<table><tr><td rowspan="2">Student</td><td rowspan="2">Teacher</td><td colspan="3">Object Detection</td><td colspan="3">Instance Segmentation</td></tr><tr><td>Apbb</td><td>AP</td><td>APP</td><td>Apmk</td><td>AP</td><td>AP</td></tr><tr><td rowspan="4">ResNet34</td><td>X</td><td>38.1</td><td>56.8</td><td>40.7</td><td>33.0</td><td>53.2</td><td>35.3</td></tr><tr><td>ResNet50</td><td>38.4 (+0.3)</td><td>57.0 (+0.2)</td><td>41.0 (+0.3)</td><td>33.3 (+0.3)</td><td>53.6 (+0.4)</td><td>35.4 (+0.1)</td></tr><tr><td>ResNet101</td><td>38.5 (+0.4)</td><td>57.3 (+0.5)</td><td>41.4 (+0.7)</td><td>33.6 (+0.6)</td><td>54.1 (+0.9)</td><td>35.6 (+0.3)</td></tr><tr><td>ResNet152</td><td>38.4 (+0.3)</td><td>57.0 (+0.2)</td><td>41.0 (+0.3)</td><td>33.3 (+0.3)</td><td>53.7 (+0.5)</td><td>35.3 (+0.0)</td></tr></table>
+
+SUN-397: We further extend our transferring evaluation to the scene dataset SUN-397 for a more diverse testing. The official dataset specifies 10 different train/test splits, with each contains 50 images per category covering 397 different scenes. We follow (Chen et al., 2020a; Grill et al., 2020) and use the first train/test split. For the validation set, we randomly pick 10 images (yielding $20 \%$ of the dataset), with identical optimizer parameters as CIFAR.
+
+Object Detection and Instance Segmentation. As indicated by (He et al., 2020), features produced by self-supervised pre-training have divergent distributions in downstream tasks, thus resulting the supervised pre-training picked hyper-parameters not applicable. To relieve this, He et al. (2020) uses feature normalization during the fine-tuning phase and train the BN layers. Different from previous transferring and linear evaluations where we exploit only offline features, model for detection and segmentation is trained with all parameters tuned. For this reason, annotations on COCO for segmentation gives much higher influence for the backbone model than the VOC dataset (see Table 9), and gives an offset to the pre-training difference (see Table 10). Thus, this makes the performance boosting by pre-training less obvious, and leads to trivial AP differences before and after distillation.
+
+Object Detection on PASCAL VOC-07: We train a C4 (He et al., 2017) based Faster R-CNN (Ren et al., 2015) as the detector with different ResNet architectures (ResNet-18, ResNet-34 and ResNet-50) for evaluating the transferability of features for object detection tasks. We use Detectron2 (Wu et al., 2019) for the implementations. We train our detector for 48k iterations with a batch size of 32 (8 images per GPU). The base learning rate is set to 0.01 with 200 warm-up iterations. We set the scale of images for training as [400, 800] and 800 at inference.
+
+Object Detection and Segmentation on COCO: We use Mask R-CNN (He et al., 2017) with the C4 backbone for the object detection and instance segmentation task on COCO dataset, with $2 \times$ schedule. Similar to the VOC detection, we tune the BN layers and all parameters. The model is trained for $1 8 0 \mathrm { k }$ iterations with initial learning rate set to 0.02. We set the scale of images for training as [600, 800] and 800 at inference.
+
+Table 11: Linear evaluations on ImageNet of ResNet-18 after distillation from the SWAV pre-trained ResNet-50 using either single view, cross-views, or small patch views.   
+
+<table><tr><td>Method</td><td>Multi-View(s)</td><td>Top-1 Acc.</td><td>Top-5 Acc.</td></tr><tr><td>Identical-View</td><td>1×224</td><td>61.7</td><td>84.2</td></tr><tr><td>Cross-Views</td><td>2×224</td><td>58.2</td><td>81.7</td></tr><tr><td>Multi-Crops + Cross-Views</td><td>1×224 + 6×96×96</td><td>61.9</td><td>84.4</td></tr><tr><td>Multi-Crops + Identical-View </td><td>1×224 +6×96×96</td><td>62.6</td><td>84.8</td></tr></table>
+
+![](images/0863ba5174cfabf1f7a4f95ce0b77df7bdbf71b58813b9c855df14a8e571182a.jpg)  
+Figure 6: We experiment with different strategies of using views during distillation, which include: (a). Identical view for distillation. (b). Cross view distillation. (c). Large-small cross view distillation. (d). Large-small identical view distillation.
+
+# A.3 SINGLE CROP V.S. MULTI-CROPS VIEW(S) FOR DISTILLATION
+
+In contrary with most contrastive SSL methods where two different augmented views of an image are utilized as the positive samples (see Figure 6-a), SEED uses an identical view for each image (see Figure 6-b) during distillation and yields better performances, as is shown in Table. 11. In addition, we have also experimented with two strategies of using small patches. To be specific, we follow the set-up in SWAV (Caron et al., 2020), that 6 small patches of the size $9 6 \times 9 6$ are sampled at the scale of (0.05, 0.14). Then, we apply the same augmentations as introduced previously as data pre-processing. Figure. 6-c shows the way that is similar in SWAV for small-patch learning, where both large and 6 small patches are fed into the student encoder, with the learning target $( \mathbf { z } ^ { T } )$ to be the embedding of large view from the teacher encoder. Figure. 6-d is the strategy we use during distillation, that both views are fed into student and teacher to produce the embeddings for small-views $( \mathbf { z } _ { s } ^ { S } , \mathbf { z } _ { s } ^ { T } )$ and large views $( \mathbf { z } _ { l } ^ { S } , \mathbf { z } _ { l } ^ { T } )$ . Based on that, the distillation is formulated separately on the small and large views. Notably, we maintain two independent queues for storing historical data samples for the large and small views.
+
+# A.4 STRATEGIES FOR OTHER DISTILLATION METHODS
+
+We compare the effect of distillation using different strategies with SEED.
+
+$\mathbf { \xi } _ { l 2 }$ -Distance: We train the student encoder by minimizing the squared $l 2$ -distance of representations from student $( \mathbf { z } _ { i } ^ { S } )$ and teacher $( \mathbf { z } _ { i } ^ { T } )$ for an identical view $\mathbf { x } _ { i }$ .
+
+$\pmb { K }$ -Means: We experiment with the $K$ -Means clustering method to retrieve pseudo class labels for distillation. Specifically, we first extract offline image features using the $S S L$ pre-trained Teacher network without any image augmentations. Based on this, we conduct our $K$ -Means clustering with $4 \mathrm { k }$ and $1 6 \mathrm { k }$ unique centroids. Then the final centroids are used to produce pseudo labels for unlabelled instances. With that, we carry out the distillation by training the model on a classification task using the produced labels as the ground-truth. To avoid trivial solutions that the majority of images are assigned to a few clusters, we sample images based on a uniform distribution over pseudo-labels as clustering proceeds. We observe very close results when adjusting numbers of centroids.
+
+Online-Clustering: With $K$ -Means for pseudo-label generation training, it does not lead to satisfying results $( 5 1 . 0 \%$ on ResNet-18 with ResNet-50 as Teacher) as instances might have not been accurately categorized by limited frozen centroids. Similar to (Caron et al., 2018; Li et al., 2020), we resort to the “in-batch” and dynamical clustering to substitute the frozen $K$ -Means method. We conduct
+
+$K$ -Means clustering within a batch and continuously update the centroid based on the teacher feature representation as distillation goes on. This alleviates the above problems and yields a substantial performance improvement on ResNet-18 to $5 6 . 4 \%$ .
+
+Binary Contrastive Loss: We resort to CRD (Tian et al., 2019a) and adopt an info-NCE loss-alike training objective in unsupervised distillation tasks. Specifically, we treat representation features from Teacher and Student for instance $\mathbf { x } _ { i }$ as positive pairs, and random instances from $\mathbf { D }$ as negative samples:
+
+$$
+\hat { \theta } _ { S } = \underset { \theta _ { S } } { \arg \operatorname* { m i n } } \sum _ { i } ^ { N } \log h ( \mathbf { z } _ { i } ^ { S } , \mathbf { z } _ { i } ^ { T } ) + K \cdot [ \log h ( 1 - h ( \mathbf { z } _ { i } ^ { S } , \mathbf { d } _ { j } ^ { T } ) ) ] ,
+$$
+
+where $\mathbf { d } _ { j } ^ { T } \in \mathbf { D } , h ( \cdot )$ is any family of functions that satisfy $h$ : $\{ { \bf z } , { \bf d } \}  [ 0 , 1 ]$ , e.g., cosine similarity.
+
+# A.5 DISCUSSIONS ON SEED
+
+Our proposed learning objective for SEED is composed of two goals, that is to align the encoding $\mathbf { z } ^ { S }$ by the student model with $\mathbf { z } ^ { T }$ produced by the teacher model; meanwhile, $\mathbf { z } ^ { S }$ also softly contrasts with random samples maintained in the $\mathbf { D }$ . This can be formulated more directly as minimizing the $l 2$ distance of ${ \mathbf z } ^ { T } , { \mathbf z } ^ { S }$ , together with the cross-entropy computed using $\mathbf { D }$ :
+
+$$
+\begin{array} { l } { \displaystyle \mathcal { L } = \frac { 1 } { N } \sum _ { i } ^ { N } \bigg \{ \lambda _ { a } \cdot \bigg \vert \bigg \vert \mathbf { z } _ { i } ^ { T } - \mathbf { z } _ { i } ^ { S } \bigg \vert \bigg \vert _ { 2 } - \lambda _ { b } \cdot \mathbf { p } ^ { T } ( \mathbf { x } _ { i } ; \boldsymbol { \theta } _ { T } , \mathbf { D } ) \cdot \log \mathbf { p } ^ { S } ( \mathbf { x } _ { i } ; \boldsymbol { \theta } _ { S } , \mathbf { D } ) \bigg \} } \\ { \displaystyle \quad = \sum _ { i } ^ { N } \bigg \{ - \lambda _ { a } \cdot \mathbf { z } _ { i } ^ { T } \cdot \mathbf { z } _ { i } ^ { S } - \lambda _ { b } \cdot \sum _ { j } ^ { K } \frac { \exp ( \mathbf { z } _ { i } ^ { T } \cdot \mathbf { d } _ { j } / \tau ^ { T } ) } { \sum _ { \mathbf { d } \setminus \mathbf { D } } \exp ( \mathbf { z } _ { i } ^ { T } \cdot \mathbf { d } / \tau ^ { T } ) } \cdot \log \frac { \exp ( \mathbf { z } _ { i } ^ { S } \cdot \mathbf { d } _ { j } / \tau ^ { S } ) } { \sum _ { \mathbf { d } \setminus \mathbf { D } } \exp ( \mathbf { z } _ { i } ^ { S } \cdot \mathbf { d } / \tau ^ { S } ) } \bigg \} , } \end{array}
+$$
+
+Directly optimizing Eq. 7 can lead to apparent difficulty in searching optimal hyper-parameters $( \lambda _ { a } , \lambda _ { b } , \bar { \tau } ^ { T }$ and $\tau ^ { S }$ ). Our proposed objective on $\mathbf { D } ^ { + }$ indeed is an approximated upper-bound of the above objectiveness however much simplified:
+
+$$
+\begin{array} { r l } & { \mathcal { L } _ { \mathrm { S E E D } } = \displaystyle \frac { 1 } { N } \sum _ { i } ^ { N } - \mathbf { p } ^ { T } ( \mathbf { x } _ { i } ; \boldsymbol { \theta } _ { T } , \mathbf { D } ^ { + } ) \cdot \log \mathbf { p } ^ { S } ( \mathbf { x } _ { i } ; \boldsymbol { \theta } _ { S } , \mathbf { D } ^ { + } ) } \\ & { \qquad = \displaystyle \sum _ { i } ^ { N } \sum _ { j } ^ { K + 1 } - \underbrace { \frac { \exp \left( \mathbf { z } _ { i } ^ { T } \cdot \mathbf { d } _ { j } / \tau ^ { T } \right) } { \sum _ { \mathbf { d } \sim \mathbf { D } ^ { + } } \exp \left( \mathbf { z } _ { i } ^ { T } \cdot \mathbf { d } / \tau ^ { T } \right) } } _ { \mathbf { w } _ { j } ^ { i } } \cdot \log \frac { \exp \left( \mathbf { z } _ { i } ^ { S } \cdot \mathbf { d } _ { j } / \tau ^ { S } \right) } { \sum _ { \mathbf { d } \sim \mathbf { D } ^ { + } } \exp \left( \mathbf { z } _ { i } ^ { S } \cdot \mathbf { d } / \tau ^ { S } \right) } , } \end{array}
+$$
+
+where we let $\mathbf { w } _ { j } ^ { i }$ denote the weighting term regulated under $\tau ^ { T }$ . Since the $( K + 1 )$ th element in $\mathbf { D } ^ { + }$ is our supplemented vector ${ \mathbf z } _ { i } ^ { T }$ , the above objective can be expanded into:
+
+$$
+\begin{array} { r l } & { \mathcal { L } _ { \mathrm { S E E D } } = \displaystyle \frac { 1 } { N } \sum _ { i } ^ { N } \Big \{ { \bf w } _ { K + 1 } ^ { i } \cdot \big ( - { \bf z } _ { i } ^ { S } \cdot { \bf z } _ { i } ^ { T } / \tau ^ { S } + \log \sum _ { \bf d \sim D ^ { + } } \exp ( { \bf z } _ { i } ^ { S } \cdot { \bf d } / \tau ^ { S } ) \big ) } \\ & { \qquad + \displaystyle \sum _ { j = 1 } ^ { K } { \bf w } _ { j } ^ { i } \cdot \big ( - { \bf z } _ { i } ^ { S } \cdot { \bf d } _ { j } / \tau ^ { S } + \log \sum _ { \bf d \sim D ^ { + } } \exp ( { \bf z } _ { i } ^ { S } \cdot { \bf d } / \tau ^ { S } ) \big ) \Big \} } \end{array}
+$$
+
+Note that the LSE term in the first line is strictly non-negative as the range of inner product for $\mathbf { z } ^ { S }$ and $\mathbf { d }$ lies between $\left[ - 1 , + 1 \right]$ :
+
+$$
+\mathrm { L S E } ( \mathbf { D } ^ { + } , \mathbf { z } _ { i } ^ { S } ) \geq \log \big ( M \cdot \exp ( - 1 / \tau ^ { S } ) \big ) = \log \big ( M \cdot \exp ( - 5 ) \big ) > 0 ,
+$$
+
+where $M$ denotes the cardinality of the maintained queue $\mathbf { D } ^ { + }$ and is set to 65,536 in our experiment with $\tau ^ { S } = 0 . 2$ constantly. Meanwhile, the LSE term in the second line satisfies the following inequality:
+
+$$
+\mathrm { L S E } ( \mathbf { D } ^ { + } , \mathbf { z } _ { i } ^ { S } ) \geq \mathrm { L S E } ( \mathbf { D } , \mathbf { z } _ { i } ^ { S } ) .
+$$
+
+Thus, this demonstrates that the objective for SEED as Eq. 8 is equivalent to minimizing a weakened upper-bound of e.q. 7:
+
+$$
+\begin{array} { l } { { \mathcal { L } _ { \mathrm { S E E D } } = \displaystyle \frac { 1 } { N } \sum _ { i } ^ { N } - { \bf p } ^ { T } ( { \bf x } _ { i } ; \boldsymbol { \theta } _ { T } , { \bf D } ^ { + } ) \cdot \log { \bf p } ^ { S } ( { \bf x } _ { i } ; \boldsymbol { \theta } _ { S } , { \bf D } ^ { + } ) } \ ~ } \\ { { \displaystyle \geq \frac { 1 } { N } \sum _ { i } ^ { N } \left\{ { \bf w } _ { K + 1 } ^ { i } \cdot ( - { \bf z } _ { i } ^ { S } \cdot { \bf z } _ { i } ^ { T } / \tau ^ { S } ) + \sum _ { j = 1 } ^ { K } { \bf w } _ { j } ^ { i } \cdot \left( - { \bf z } _ { i } ^ { S } \cdot { \bf d } _ { j } / \tau ^ { S } + \log \sum _ { \bf d \times D } ^ { C } \exp ( { \bf z } _ { i } ^ { S } \cdot { \bf d } / \tau ^ { S } ) \right) \right\} } \ ~ } \\ { { \displaystyle = \frac { 1 } { N } \sum _ { i } ^ { N } \Bigg \{ - \frac { { \bf w } _ { K + 1 } ^ { i } } { \tau ^ { S } } \cdot { \bf z } _ { i } ^ { S } \cdot { \bf z } _ { i } ^ { T } - { \bf p } ^ { T } ( { \bf x } _ { i } ; \boldsymbol { \theta } _ { T } , { \bf D } ) \cdot \log { \bf p } ^ { S } ( { \bf x } _ { i } ; \boldsymbol { \theta } _ { S } , { \bf D } ) \Bigg \} } \ ~ } \end{array}
+$$
+
+This proves that our $\mathcal { L } _ { \mathrm { S E E D } }$ directly relates to a more intuitive distillation formulation as Eq. 7 $( l 2 +$ cross entropy loss), and it implicitly contains the objective of aligning and contrasting. However, our training objective is much simplified. During practice, we find by regulating $\tau ^ { T }$ , both training losses produce equal results.
+
+# A.6 DISCUSSION ON THE RELATIONSHIP OF SEED WITH INFO-NCE
+
+The objective of distillation can be considered as a soft version of Info-NCE (Oord et al., 2018), with the only difference to be that SEED learns from the negative samples with probabilities instead of treating them all strictly as negative samples. To be more specific, following Info-NCE, the “hard” style contrastive distillation can be expressed as aligning with representations from the Teacher encoder and contrasting with all random instances:
+
+$$
+\hat { \theta } _ { S } = \underset { \theta _ { S } } { \arg \operatorname* { m i n } } \ : \mathcal { L } _ { N C E } = \underset { \theta _ { S } } { \arg \operatorname* { m i n } } \sum _ { i } ^ { N } - \log \frac { \exp ( \mathbf { z } _ { i } ^ { T } \cdot \mathbf { z } _ { i } ^ { S } / \tau ) } { \sum _ { \mathbf { d } \sim \mathbf { D } } \exp ( \mathbf { z } _ { i } ^ { S } \cdot \mathbf { d } / \tau ) }
+$$
+
+which can be further deduced with two sub-terms consisting of positive sample alignment and contrasting with negative instances:
+
+$$
+\mathcal { L } _ { N C E } = \sum _ { i } ^ { N } \Big \{ \underbrace { - \mathbf { z } _ { i } ^ { S } \cdot \mathbf { z } _ { i } ^ { T } / \tau } _ { a l i g n m e n t } + \underbrace { \log \sum _ { \mathbf { d } \sim \mathbf { D } } \exp ( \mathbf { z } _ { i } ^ { S } \cdot \mathbf { d } / \tau ) } _ { c o n t r a s t i n g } \Big \} .
+$$
+
+Similarly, the objective of SEED can be dissembled into the weighted form of alignment and contrasting terms:
+
+$$
+\begin{array} { r l } & { \mathcal { L } _ { \mathrm { S E E D } } = \displaystyle \frac { 1 } { N * M } \sum _ { i } ^ { N } \sum _ { j } ^ { K + 1 } - \frac { \exp ( { \bf z } _ { i } ^ { T } \cdot { \bf d } _ { j } / \tau ^ { T } ) } { \sum _ { \bf d } \sim \mathrm { D } ^ { + } } \cdot \log \Big \frac { \exp ( { \bf z } _ { i } ^ { S } \cdot { \bf d } _ { j } / \tau ^ { S } ) } { \sum _ { \bf d } \sim \mathrm { D } ^ { + } } } \\ & { \quad \quad \quad \quad = \frac { 1 } { N * M } \sum _ { i } ^ { N } \displaystyle \sum _ { j } ^ { K + 1 } \underbrace { \frac { \exp ( { \bf z } _ { i } ^ { T } \cdot { \bf d } _ { j } / \tau ^ { T } ) } { \sum _ { \bf d } \sim \mathrm { D } ^ { + } } } _ { { \bf w } _ { j } ^ { \bf d } } \cdot \underbrace { ( - { \bf z } _ { i } ^ { S } \cdot { \bf z } _ { i } ^ { T } / \tau ^ { S } ) } _ { a l i g n m e n t } \cdot \underbrace { ( \frac { \log \sum _ { i } ^ { S } \cdot { \bf d } _ { i } / \tau ^ { S } ) } { c \mathrm { o } n t r a s t i n g } } _ { c o n t r a s t i n g } ) , } \end{array}
+$$
+
+where the normalization term can be considered as soft labels, $\mathbf { W } ^ { i } = \left[ \mathbf { w } _ { 1 } ^ { i } \ldots \mathbf { w } _ { K + 1 } ^ { i } \right]$ , which can weight the above loss as:
+
+$$
+\mathcal { L } _ { \mathrm { S E E D } } = \frac { 1 } { N * M } \sum _ { i } ^ { N } \sum _ { j } ^ { K + 1 } \mathbf { w } _ { j } ^ { i } \cdot \Big \{ - \mathbf { z } _ { i } ^ { S } \cdot \mathbf { z } _ { i } ^ { T } / \tau ^ { S } + \log \sum _ { \mathbf { d } \sim \mathbf { D } } \exp ( \mathbf { z } _ { i } ^ { S } \cdot \mathbf { d } / \tau ^ { S } ) ) \Big \} ,
+$$
+
+When tuning hyper-parameter $\tau ^ { T }$ towards 0, $\mathbf { W } ^ { i }$ can be altered into the format of one-hot vector with $\mathbf { w } _ { K + 1 } ^ { i } = \dot { 1 }$ , which is then degraded to the case of contrastive distillation as in equation 14. In practice, the choice of an optimal $\tau ^ { T }$ can be dataset-specific. We show that the higher $\tau ^ { T }$ (with labels be more ‘soft’) can actually yield better results on other datasets, e.g., CIFAR-10 (Krizhevsky et al., 2009).
+
+# A.7 COMPATIBILITY WITH SUPERVISED DISTILLATION
+
+SEED conducts self-supervised distillation at the pre-training phase for the representation learning. However, we verify that SEED is compatible with traditional supervised distillation that happened during fine-tuning phrase at downstream, and can even produce better results. We begin with the SSL pre-training on a larger architecture (ResNet-152) using MoCo-V2 and train it for 200 epochs as the teacher network. As images in CIFAR-100 are in the size of $3 2 \times 3 2$ , we modify the first conv layer in ResNet with kernel size $= 3$ and stride $= 1$ .
+
+We then compare the Top-1 accuracy of a smaller ResNet-18 on CIFAR-100 when using different distillation strategies when all parameters are trainable. First, we use SEED to pre-train ResNet-18 with Res-152 as the teacher model, and then evaluate in on the test split of CIFAR-100 using linear fine-tuning task. As we keep all parameters trainable during the fine-tuning phase, distillation on the pre-training only yields a trivial boost: $7 5 . 4 \%$ v.s. $7 5 . 2 \%$ . Then, we adopt the traditional distillation method, e.g., (Hinton et al., 2015), to first fine-tune the ResNet-152 model, and then use its output class probability to facilitate the linear classification task on ResNet-18 in the fine-tuning phrase. This improves the linear classification accuracy on ResNet-18 to $7 6 . 0 \%$ . At the end, we initialize the ResNet-18 with our SEED pre-trained ResNet-18, and equip it with the supervised classification distillation during fine-tuning. With that, we find that the performance of ResNet-18 is further boosted to $7 8 . 1 \%$ . We can conclude that our SEED is compatible with traditional supervised distillation that mostly happened at downstream for specific tasks, e.g., classification, object detection.
+
+Table 12: CIFAR-100 Top-1 Accuracy $( \% )$ of ResNet-18 with (or without) distillation at different phase: selfsupervised pre-training stage, and supervised classification fine-tuning. All backbone parameters of ResNet-18 are trainable in experiments.   
+
+<table><tr><td colspan="3">Pre-training Distill. Fine-tuning Distill. Top-1 Acc</td></tr><tr><td>X</td><td>X</td><td>75.2</td></tr><tr><td>√</td><td>×</td><td>75.4</td></tr><tr><td>×</td><td>√</td><td>76.0</td></tr><tr><td>√</td><td>√</td><td>78.1</td></tr></table>
+
+![](images/d2dbbfad613f736ba1bbdacdf0d815fdcec0dd5cde93e27f656664f449c6e7cd.jpg)  
+Figure 7: Linear evaluation accuracy $( \% )$ of distillation between ResNet-18 (as the Student) and ResNet-50 (as the Teacher) using different size of queue when $\mathrm { L R } { = } 0 . 0 3$ and weight decay=1e-6. Note the axis is the log(·) value of queue lengths.
+
+# A.8 ADDITIONAL ABLATION STUDIES
+
+We study effects of different hyper-parameters to distillation using a ResNet-18 (as Student) and a SWAV pre-trained ResNet-50 (as Teacher) with small patch views. In specific, we list the Top-1 Acc. on validation split of ImageNet-1k using different lengths of queue $K { = } 1 2 8$ , 512, 1,024, 4,096, 8,192, 16,384, 65,536) in Figure. 7. With the increasing of random data samples, the distillation boosts the accuracy of learned representations, however within a limited range: $+ 1 . 5$ when the queue size is
+
+Table 13: Linear evaluation accuracy $( \% )$ of distillation between ResNet-18 (as the Student) and ResNet-50 (as the Teacher) using different learning rates when the queue size is 65,536 and weight decay=1e-6.   
+
+<table><tr><td>LR</td><td>Top-1 Acc. Top-5 Acc.</td><td></td></tr><tr><td>1</td><td>58.9</td><td>83.1</td></tr><tr><td>0.1</td><td>62.9</td><td>85.3</td></tr><tr><td>0.03</td><td>63.3</td><td>85.4</td></tr><tr><td>0.01</td><td>62.6</td><td>85.0</td></tr></table>
+
+Table 14: Linear evaluation accuracy $( \% )$ of distillation between ResNet-18 (as the Student) and ResNet-50 (as the Teacher) using different weight decays when the queue size is 65,536 and $\mathrm { L R } { = } 0 . 0 3$ .   
+
+<table><tr><td>WD</td><td>Top-1 Acc. Top-5 Acc.</td><td></td></tr><tr><td>1e-2</td><td>11.8</td><td>27.7</td></tr><tr><td>1e-3</td><td>62.3</td><td>84.7</td></tr><tr><td>1e-4</td><td>61.9</td><td>84.4</td></tr><tr><td>1e-5</td><td>61.6</td><td>84.2</td></tr><tr><td>1e-6</td><td>63.3</td><td>85.4</td></tr></table>
+
+65,536 compared with 256. Furthermore, Table. 13 and 14 summarize the linear evaluation accuracy under different learning rates and weight decays.

parse/train/B17JTOe0-/B17JTOe0-.md

@@ -0,0 +1,308 @@
+# EMERGENCE OF GRID-LIKE REPRESENTATIONS BYTRAINING RECURRENT NEURAL NETWORKS TOPERFORM SPATIAL LOCALIZATION
+
+Christopher J. Cueva∗, Xue-Xin Wei∗ Columbia University New York, NY 10027, USA {ccueva,weixxpku}@gmail.com
+
+# ABSTRACT
+
+Decades of research on the neural code underlying spatial navigation have revealed a diverse set of neural response properties. The Entorhinal Cortex (EC) of the mammalian brain contains a rich set of spatial correlates, including grid cells which encode space using tessellating patterns. However, the mechanisms and functional significance of these spatial representations remain largely mysterious. As a new way to understand these neural representations, we trained recurrent neural networks (RNNs) to perform navigation tasks in 2D arenas based on velocity inputs. Surprisingly, we find that grid-like spatial response patterns emerge in trained networks, along with units that exhibit other spatial correlates, including border cells and band-like cells. All these different functional types of neurons have been observed experimentally. The order of the emergence of grid-like and border cells is also consistent with observations from developmental studies. Together, our results suggest that grid cells, border cells and others as observed in EC may be a natural solution for representing space efficiently given the predominant recurrent connections in the neural circuits.
+
+# 1 INTRODUCTION
+
+Understanding the neural code in the brain has long been driven by studying feed-forward architectures, starting from Hubel and Wiesel’s famous proposal on the origin of orientation selectivity in primary visual cortex (Hubel & Wiesel, 1962). Inspired by the recent development in deep learning (Krizhevsky et al., 2012; LeCun et al., 2015; Hochreiter & Schmidhuber, 1997; Mnih et al., 2015), there has been a burst of interest in applying deep feedforward models, in particular convolutional neural networks (CNN) (LeCun et al., 1998), to study the sensory systems, which hierarchically extract useful features from sensory inputs (see e.g., Yamins et al. (2014); Kriegeskorte (2015); Kietzmann et al. (2017); Yamins & DiCarlo (2016)).
+
+For more cognitive tasks, neural systems often need to maintain certain internal representations of relevant variables in the absence of external stimuli- a process that requires more than feature extraction. We will focus on spatial navigation, which typically requires the brain to maintain a representation of self-location and update it according to the animal’s movements and landmarks of the environment. Physiological studies done in rodents and other mammals (including humans, non-human primates and bats) have revealed a variety of neural correlates of space in Hippocampus and Entorhinal Cortex (EC), including place cells (O’Keefe, 1976), grid cells (Fyhn et al., 2004; Hafting et al., 2005; Fyhn et al., 2008; Yartsev et al., 2011; Killian et al., 2012; Jacobs et al., 2013), along with border cells (Solstad et al., 2008), band-like cells (Krupic et al., 2012) and others (see Figure 1a). In particular, each grid cell only fires when the animal occupies a distinct set of physical locations, and strikingly these locations lie on a lattice. The study of the neural underpinning of spatial cognition has provided an important window into how high-level cognitive functions are supported in the brain (Moser et al., 2008; Aronov et al., 2017).
+
+How might the spatial navigation task be solved using a network of neurons? Recurrent neural networks (RNNs) (Hochreiter & Schmidhuber, 1997; Graves et al., 2013; Oord et al., 2016; Theis & Bethge, 2015; Gregor et al., 2015; Sussillo et al., 2015) seem particularly useful for these tasks. Indeed, recurrent-based continuous attractor networks have been one popular type of models proposed for the formation of grid cells (McNaughton et al., 2006; Burak & Fiete, 2009; Couey et al., 2013) and place cells (Samsonovich & McNaughton, 1997). Such models have provided valuable insights into one set of possible mechanisms that could support the formation of the grids. However, these models typically rely on fine-tuned connectivity patterns, in particular the models need a subtle yet systematic asymmetry in the connectivity pattern to move the attractor state according to the animal’s own movement. The existence of such a specific 2D connectivity in rodent EC remains unclear. Additionally, previous models have mainly focused on grid cells, while other types of responses that co-exist in the Entorhinal Cortex have been largely ignored. It would be useful to have a unified model that can simultaneously explain different types of neural responses in EC.
+
+Motivated by these considerations, here we present an alternative modeling approach for understanding the representation of space in the neural system. Specifically, we trained a RNN to perform some spatial navigation tasks. By leveraging the recent development in RNN training and knowledge of the navigation system in the brain, we show that training a RNN with biologically relevant constraints naturally gives rise to a variety of spatial response profiles as observed in EC, including grid-like responses. To our knowledge, this is the first study to show that grid-like responses could emerge from training a RNN to perform navigation. Our result implies that the neural representation in EC may be seen as a natural way for the brain to solve the navigation task efficiently (Wei et al., 2015). More generally, it suggests that RNNs can be a powerful tool for understanding the neural mechanisms of certain high-level cognitive functions.
+
+![](images/8e6f9cf7feba198b2a18d2ed284d372bf5324606db8951624994c943f119c937.jpg)  
+Figure 1: a) Example neural data showing different kinds of neural correlates underlying spatial navigation in EC. All figures are replotted from previous publications. From left to right: a “grid cell” recorded when an animal navigates in a square environment, replotted from Krupic et al. (2012), with the heat map representing the firing rate of this neuron as a function of the animal’s location (red corresponds to high firing rate); a “band-like” cell from Krupic et al. (2012); a border cell from Solstad et al. (2008); an irregular spatially tuned cell from Diehl et al. (2017); a “speed cell” from Kropff et al. (2015), which exhibits roughly linear dependence on the rodent’s running speed; a “heading direction cell” from Sargolini et al. (2006), which shows systematic change of firing rate depending on animal’s heading direction. b) The network consists of $N = 1 0 0$ recurrently connected units (or neurons) which receive two external inputs, representing the animal’s speed and heading direction. The two outputs linearly weight the neurons in the RNN. The goal of training is to make the responses of the two output neurons accurately represent the animal’s physical location. c) Typical trajectory after training. As shown, the output of the RNN can accurately, though not perfectly, track the animal’s location during navigation.
+
+# 2 MODEL
+
+# 2.1 MODEL DESCRIPTION
+
+Our network model consists of a set of recurrently connected units $N = 1 0 0$ ). The dynamics of each unit in the network $u _ { i } ( t )$ is governed by the standard continuous-time RNN equation:
+
+$$
+\tau \frac { d x _ { i } ( t ) } { d t } = - x _ { i } ( t ) + \sum _ { j = 1 } ^ { N } W _ { i j } ^ { \mathrm { r e c } } u _ { j } ( t ) + \sum _ { k = 1 } ^ { N _ { \mathrm { i n } } } W _ { i k } ^ { \mathrm { i n } } I _ { k } ( t ) + b _ { i } + \xi _ { i } ( t )
+$$
+
+for $i = 1 , \ldots , N$ . The activity of each unit, $u _ { i } ( t )$ , is related to the activation of that unit, $x _ { i } ( t )$ , through a nonlinearity which in this study we take to be $u _ { i } ( t ) = \operatorname { t a n h } ( x _ { i } ( t ) )$ . Each unit receives input from other units through the recurrent weight matrix $W ^ { \mathrm { r e c } }$ and also receives external input, $I ( t )$ , that enters the network through the weight matrix $W ^ { \mathrm { i n } }$ . Each unit has two sources of bias, $b _ { i }$ which is learned and $\xi _ { i } ( t )$ which represents noise intrinsic to the network and is taken to be Gaussian with zero mean and constant variance. The network was simulated using the Euler method for $T = 5 0 0$ timesteps of duration $\tau / 1 0$ .
+
+To perform a 2D navigation task with the RNN, we linearly combine the firing rates of units in the network to estimate the current location of the animal. The responses of the two linear readout neurons, $y _ { 1 } ( t )$ and $y _ { 2 } ( t )$ , are given by the following equation:
+
+$$
+y _ { j } ( t ) = \sum _ { i = 1 } ^ { N } W _ { j i } ^ { \mathrm { o u t } } u _ { i } ( t )
+$$
+
+# 2.2 INPUT TO THE NETWORK
+
+The network inputs and outputs were inspired by simple spatial navigation tasks in 2D open environments. The task resembles dead-reckoning (sometimes referred to as path integration), which is ethologically relevant for many animal species (Darwin, 1873; Mittelstaedt & Mittelstaedt, 1980; Etienne & Jeffery, 2004; McNaughton et al., 2006). To be more specific, the inputs to the network were the animal’s speed and direction at each time step. Experimentally, it has been shown that the velocity signals exist in EC (Sargolini et al., 2006; Kropff et al., 2015; Hinman et al., 2016), and there is also evidence that such signals are necessary for grid formation (Winter et al., 2015a;b).
+
+Throughout the paper, we adopt the common assumption that the head direction of the animal coincides with the actual moving direction. The outputs were the x- and y-coordinates of the integrated position. The direction of the animal is modeled by modified Brownian motion to increase the probability of straight-runs, in order to be consistent with the typical rodent’s behavior in an open environment. The usage of such simple movement statistics has the advantage of having full control of the simulated trajectories. However, for future work it would be very interesting to test the model using different animals’ real movement trajectories to see how the results might change.
+
+Special care is taken when the animal is close to the boundary. The boundary of the environment will affect the statistics of the movement, as the animal cannot cross the boundary. This fact was reflected in the model by re-sampling the angular input variable until the input angle did not lead the animal outside the boundary. In the simulations shown below, the animal always starts from the center of the arena, but we verified that the results are insensitive to the starting locations.
+
+# 2.3 TRAINING
+
+We optimized the network parameters $W ^ { \mathrm { r e c } } , W ^ { \mathrm { i n } } ,$ , $b$ and $W ^ { \mathrm { o u t } }$ to minimize the squared error in equation (3) between target $\mathbf { X } ^ { - }$ and $_ \textrm { y }$ -coordinates from a two dimensional navigation task (performed in rectangular, hexagonal, and triangular arenas) and the network outputs generated according to equation (2).
+
+$$
+E = \frac { 1 } { M T N _ { \mathrm { o u t } } } \sum _ { m , t , j = 1 } ^ { M , T , N _ { \mathrm { o u t } } } ( y _ { j } ( t , m ) - y _ { j } ^ { \mathrm { t a r g e t } } ( t , m ) ) ^ { 2 }
+$$
+
+Parameters were updated with the Hessian-free algorithm (Martens & Sutskever, 2011) using minibatches of size $M = 5 0 0$ trials. In addition to minimizing the error function in equation (3) we regularized the input and output weights according to equation (4) and the squared firing rates of the units (referred to as metabolic cost) according to equation (5). In sum, the training aims to minimize a loss function, that consists of the error of the animal, the metabolic cost, and a penalty for large network parameters.
+
+$$
+\begin{array} { l } { { \displaystyle R _ { L 2 } = \frac { 1 } { N N _ { \mathrm { i n } } } \sum _ { i , j = 1 } ^ { N , N _ { \mathrm { i n } } } ( W _ { i j } ^ { \mathrm { i n } } ) ^ { 2 } + \frac { 1 } { N N _ { \mathrm { o u t } } } \sum _ { i , j = 1 } ^ { N _ { \mathrm { o u t } } , N } ( W _ { i j } ^ { \mathrm { o u t } } ) ^ { 2 } } } \\ { { \displaystyle R _ { F R } = \frac { 1 } { N T M } \sum _ { i , t , m = 1 } ^ { N , T , M } u _ { i } ( t , m ) ^ { 2 } } } \end{array}
+$$
+
+We find that the results are qualitatively insensitive to the initialization schemes used for the recurrent weight matrix $W ^ { \mathrm { r e c } }$ . For the results presented in this paper, simulations in the hexagonal environment were obtained by initializing the elements of $W ^ { \mathrm { r e c } }$ to be zero mean Gaussian random variables with variance $1 . 5 ^ { 2 } \dot { / } N$ , and simulations in the square and triangular environments were initialized with an orthogonal $W ^ { \mathrm { r e c } }$ (Saxe et al., 2014). We initialized the bias $b$ and output weights $W ^ { \mathrm { o u t } }$ to be zero. The elements of $W ^ { \mathrm { i n } }$ were zero mean Gaussian variables with variance $1 / N _ { \mathrm { i n } }$ .
+
+![](images/7cde4a241b1b10ed008d3d0dbd8d11d439e41445d8cafe267c621ecd7571dd08.jpg)  
+Figure 2: Different types of spatial selective responses of units in the trained RNN. Example simulation results for three different environments (square, triangular, hexagon) are presented. Blue (yellow) represents low (high) activity. a) Grid-like responses. b) Band-like responses; c) Borderrelated responses; d) Spatially irregular responses. These responses can be spatially selective but they do not form a regular pattern defined in the conventional sense.
+
+# 3 RESULTS
+
+We run simulation experiments in arenas with different boundary shapes, including square, triangular and hexagonal. Figure 1c shows a typical example of the model performance after training; the network (red trace) accurately tracks the animal’s actual path (black).
+
+# 3.1 TUNING PROPERTIES OF THE MODEL NEURONS
+
+We are mostly interested in what kind of representation the RNN has learned to solve this navigation task, and whether such a representation resembles the response properties of neurons in EC (Moser et al., 2008).
+
+# 3.1.1 SPATIAL TUNING
+
+To test whether the trained RNN developed location-selective representations, we plot individual neurons’ mean activity level as a function of the animal’s location during spatial exploration. Note that these average response profiles should not be confused with the linear filters typically shown in feedforward networks. Surprisingly, we find neurons in the trained RNN show a range of interesting spatial response profiles. Examination of these response profiles suggests they can be classified into distinct functional types. Importantly, as we will show, these distinct spatial response profiles can be mapped naturally to known physiology in EC. The spatial responses of all units in trained networks are shown in the Appendix.
+
+Grid-like responses Most interestingly, we find some of the units in the RNN exhibit clear grid-like responses (Figure 2a). These firing patterns typically exhibit multiple firing fields, with each firing field exhibiting roughly circular symmetric or ellipse shape. Furthermore, the firing fields are highly structured, i.e., when combined, are arranged on a regular lattice. Furthermore, the structure of the response lattice depends on the shape of the boundary. In particular, training the network to perform self-localization in a square environment tends to give rectangular grids. In hexagonal and triangular environments, the grids are closer to triangular.
+
+Experimentally, it is shown that (medial) EC contains so-called grid cells which exhibit multiple firing fields that lie on a regular grid (Fyhn et al., 2004; Hafting et al., 2005). The grid-like firing patterns in our simulation are reminiscent of the grid cells in rodents and other mammals. However, we also notice that the the grid-like model responses typically exhibit few periods, not as many as experimental data (see Figure 1a). It is possible that using a larger network might reveal finer grid-patterns in our model. Nonetheless, it is surprising that the gird-like spatial representations can develop in our model, given there is no periodicity in the input. Another potential concern is that, experimentally it is reported that the grids are often on the corners of a triangular lattice (Hafting et al., 2005) even in square environments (see Figure 1a), though the grids are somewhat influenced by the shape of the environment. However, the rats in these experiments presumable had spatial experience in other environments with various boundary shapes. Experimentally, it would be interesting to see if grid cells would lie on a square lattice instead if the rats are raised in a single square environment - a situation we are simulating here.
+
+Border responses Many neurons in the RNN exhibit selectivity to the boundary (Figure 2c). Typically, they only encode a portion of the boundary, e.g. one piece of wall in a square shaped environment. Such properties are similar to the border cells discovered in rodent EC (Solstad et al., 2008; Savelli et al., 2008; Lever et al., 2009). Experimentally, border cells mainly fire along one piece of wall, although some have been observed to fire along multiple borders or along the whole boundary of the environment; interestingly, these multi-border responses were also observed in some RNN models. Currently, it is unclear how the boundary-like response profiles emerge (Solstad et al., 2008; Savelli et al., 2008; Lever et al., 2009). Our model points to the possibility that the border cells may emerge without the presence of tactile cues. Furthermore, it suggests that border cell formation may be related to the movement statistics of the animals, i.e. due to the asymmetry of the movement statistics along the boundary.
+
+Band-like responses Interestingly, some neurons in the RNN exhibit band-like responses (Figure 2b). In most of our simulations, these bands tend to be parallel to one of the boundaries. For some of the units, one of the bands overlaps the boundary, but for others, that is not the case. Experimentally, neurons with periodic-like firing patterns have been recently reported in rodent EC. In one study, it has been reported that a substantial portion of cells in EC exhibit band-like firing characteristics (Krupic et al., 2012). However, we note that based on the reported data in Krupic et al. (2012), the band pattern is not as clear as in our model.
+
+Spatially-stable but non-regular responses Besides the units described above, most of the remaining units also exhibit stable spatial responses, but they do not belong to the above categories. These response profiles can exhibit either one large irregular firing field; or multiple circular firing fields, but these firing fields do not show a regular pattern. Experimentally these types of cells have also been observed. In fact, it is recently reported that the non-grid spatial cells constitute a large portion of the neurons in Layer II and III of rodent EC (Diehl et al., 2017).
+
+# 3.1.2 SPEED TUNING AND HEAD DIRECTION TUNING
+
+Speed tuning We next ask how neurons in the RNN are tuned to the inputs. Many of the model neurons exhibit linear responses to the running speed of the animal, while some neurons show no selectivity to speed, as suggested by the near-flat response functions. Example response profiles are shown in Figure 3. Interestingly, we observe that the model border cells tend to have almost zero speed-tuning (e.g., see Figure 3g,h).
+
+![](images/318a67b1eb08bdf270e30eebad468380d0e5a80e744e9f80d58a5d693f3a94ed.jpg)  
+Figure 3: Direction tuning and speed tuning for nine example units in an RNN trained in a triangular arena. For each unit, we show the spatial tuning, (head) directional tuning, speed tuning respectively, from left to right. a,b,c) The three model neurons show strong directional tuning, but the spatial tuning is weak and irregular. The three neurons also exhibit linear speed tuning. d,e,f) The three neurons exhibit grid-like firing patterns, and clear speed tuning. The strength of their direction tuning differ. ${ \bf g } , { \bf h } )$ Border cells exhibit weak and a bit complex directional tuning and almost no speed tuning. i) This band cell shows weak directional tuning, but strong speed tuning.
+
+Head direction tuning A substantial portion of the model neurons show direction tuning. There are a diversity of direction tuning profiles, both in terms of the strength of the tuning and their preferred direction. Example tuning curves are shown in Figure 3, and the direction tuning curves of a complete population are shown in the Appendix. Interestingly, in general model neurons which show the strongest head direction tuning do not show a clear spatial firing pattern (see Figure 3a,b,c). This suggests that there are a group of neurons which are mostly responsible for encoding the direction. We also notice that neurons with clear grid-like firing can exhibit a variety of direction tuning strengths, from weak to strong (Figure 3d,e,f). In the Appendix, we quantify the relation between these different tuning properties at the whole population level, which show somewhat complex dependence.
+
+Experimentally, the heading direction tuning in EC is well-known, e.g., Sargolini et al. (2006). Both the grid and non-grid cells in EC exhibit head direction tuning (Sargolini et al., 2006). Furthermore, the linear speed dependence of the model neurons is similar to the properties of speed cells reported recently in EC (Kropff et al., 2015). Our result is also consistent with another recent study reporting that the majority of neurons in EC exhibit some amount of speed tuning (Hinman et al., 2016). It remains an open question experimentally, at a population level, how different types of tuning characteristics in EC relate to each other.
+
+# 3.1.3 DEVELOPMENT OF THE TUNING PROPERTIES
+
+We next investigate how the spatial response profiles evolve as learning/training progresses. We report two main observations. First, neurons that fire selectively along the boundary typically emerge first. Second, the grid-like responses with finer spatial tuning patterns only emerge later in training. For visualization, we perform dimensionality reduction using the t-SNE algorithm (Maaten & Hinton, 2008). This algorithm embeds 100 model neurons during three phases of training (early, intermediate, and late) into a two-dimensional space according to the similarity of their temporal responses. Here the similarity metric is taken to be firing rate correlation. In this 2D space as shown in Figure 4a, border cell representations appear early and stably persist through the end of training. Furthermore, early during training all responses are similar to the border related responses. In contrast, grid-like cells typically undergo a substantial change in firing pattern during training before settling into their final grid-like representation (Figure 4b).
+
+The developmental time line of the grid-like cells and border cells is roughly consistent with developmental studies in rodents. Experimentally, it is known that border cells emerge earlier in development, and they exist at about 2 weeks after the rat is born (Bjerknes et al., 2014). The grid cells mature only at about 4 weeks after birth (Langston et al., 2010; Wills et al., 2010; Bjerknes et al., 2014). Furthermore, our simulations suggest the reason why border cells emerge earlier in development may be that computationally it is easier to wire-up a network that gives rise to border cell responses.
+
+![](images/9c19816ea23656a00f78df190e6e407bf4c84fe0856a9d69293f60f5972dfa0a.jpg)  
+Figure 4: Development of border cells and grid-like cells. Early during training all responses are similar to the border related responses, and only as training continues do the grid-like cells emerge. We perform dimensionality reduction using the t-SNE algorithm on the firing rates of the neurons. Each dot represents one neuron $N = 1 0 0$ ), and the color represents different training stages (early/intermediate/late shown in blue/cyan/yellow). Each line shows the trajectory of a single highlighted neuron as its firing responses evolve during training. In panel a), we highlight the border representation. It appears there are four clusters of border cells, each responding to one wall of a square environment (spatial responses from four of these border cells are inset). These cells’ response profiles appear early and stably persist through training, illustrated by the short distance they travel in this space. In b), we show that the neurons which eventually become grid cells initially have tuning profiles similar to the border cells but then change their tuning substantially during learning. As a natural consequence, they need to travel a long distance in this space between the early and late phase of the training. Spatial responses are shown for four of these grid-like cells during the late phase of training.
+
+# 3.2 THE IMPORTANCE OF REGULARIZATION
+
+We find appropriate regularizations of the RNN to be crucial for the emergence of grid-like representations. We only observed grid-like representations when the network was encouraged to store information while perturbed by noise. This was accomplished by setting the speed input to zero, e.g. zero speed $90 \%$ of the time, and adding Gaussian noise to the network $\xi _ { i } ( t )$ in equation (1)); the precise method for setting the speed input to zero and the value of the noise variance is not crucial for our simulations to develop grid-like representations. The cost function which aims to capture the penalization on the metabolic cost of the neural activity also acts as an important regularization. Our simulations show that the grid-like representation did not emerge without this metabolic cost. In Figure 5, we show typical simulation results for a square environment, with and without proper metabolic regularization. In the Appendix, we illustrate the effect of regularization further, in particular the role of injecting noise into the RNN units.
+
+Our results are consistent with the general notion on the importance of incorporating proper constraint for learning useful representations in neural networks (Bengio et al., 2013). Furthermore, it suggests that, to learn a model with response properties similar to neural systems it may be necessary to incorporate the relevant constraints, e.g., noise and metabolic cost.
+
+# 3.3 ERROR CORRECTION AROUND THE BOUNDARY
+
+One natural question is whether the trained RNNs are able to perform localization when the path length exceeds the typical length used during training (500 steps), in particular given that noise in the network would gradually accumulate, leading to a decrease in localization performance. We test this by simulating paths that are several orders of magnitude longer. Somewhat surprisingly, we find the RNNs still perform well (Figure 6b). In fact, the squared error (averaged over every 10000 steps) is stable. The spatial response profiles of individual units also remain stable. This implies that the RNNs have acquired intrinsic error-correction mechanisms during training.
+
+![](images/476435913a7b64388291eece485ed2e49a2bc8befbf4d07d7b0df7b3c97e20d4.jpg)  
+Figure 5: Complete set of spatial response profiles for 100 neurons in a RNN trained in a square environment. a) Without proper regularization, complex and periodic spatial response patterns do not emerge. b) With proper regularization, a rich set of periodic response patterns emerge, including grid-like responses. Regularization can also be adjusted to achieve spatial profiles intermediate between these two examples.
+
+![](images/1313022c4e140eff6c754917cddc7b20c35899670d67ff7b351c56f3f49df4d8.jpg)  
+Figure 6: Error-correction happens at the boundary and the error is stable over time. At the boundary, the direction is resampled to avoid input velocities that lead to a path extending beyond the boundary of the environment. These changing input statistics at the boundary, termed a boundary interaction, are the only cue the RNN receives about the boundary. We find that the RNN uses the boundary interactions to correct the accumulated error between the true integrated input and its prediction based on the linear readout of equation (2). Panel a), the mean squared error increases when there are no boundary interactions, but then decreases after a boundary interaction, with more boundary interactions leading to greater error reduction. In the absence of further boundary interaction, the squared error would gradually increase again (blue curve) at roughly a constant rate. b) The network was trained using mini-batches of 500 timesteps but has stable error over a duration at least four orders of magnitude larger. The error of the RNN output (mean and standard deviation shown in black, computed based on 10000 timesteps) is compared to the error that would be achieved by an RNN outputting the best constant values (red).
+
+As shown earlier, during training some of the RNN units develop boundary-related firing (Figure 2c), presumably by exploiting the change of input statistics around the boundary. We hypothesize that boundary interactions may enable error-correction through signals based on these boundary-related activities. Indeed, we find that boundary interactions can dramatically reduce the accumulated error (Figure 6a). Figure 6a shows that, without boundary interactions, on average the squared error grows roughly linearly as expected, however, interactions with the boundaries substantially reduce the error, and more frequent boundary interactions can reduce the error further. Error-correction on grid cells via boundary interactions has been proposed (Hardcastle et al., 2015; Pollock et al., 2017), however, we emphasize that the model proposed here develops the grid-like responses, boundary responses and the error-correction mechanisms all within the same neural network, thus potentially providing a unifying account of a diverse set of phenomena.
+
+# 4 DISCUSSION
+
+In this paper, we trained RNNs to perform path integration (dead-reckoning) in 2D arenas. We found that after training RNNs with appropriate regularization, the model neurons exhibit a variety of spatial and velocity tuning profiles that match neurophysiology in EC. What’s more, there is also similarity in terms of when these distinct neuron types emerge during training/development. The EC has long been thought to be involved in path integration and localization of the animal’s location (Moser et al., 2008). The general agreement between the different response properties in our model and the neurophysiology provide strong evidence supporting the hypothesis that the neural population in EC may provide an efficient code for representation self-locations based on the velocity input.
+
+Recently, there has been increased interest in using complex neural network models to understand the neural code. But the focus has been on using feedforward architectures, in particular CNNs (LeCun et al., 1998). Given the abundant recurrent connections in the brain, it seems a particularly fruitful avenue to take advantage of the recent development in RNNs to help with neuroscience questions (Mante et al., 2013; Song et al., 2016; Miconi, 2017; Sussillo et al., 2015). Here, we only show one instance following this approach. However, the insight from this work could be general, and potentially useful for other cognitive functions as well.
+
+The finding that metabolic constraints lead to the emergence of grid-like responses may be seen as conceptually related to the efficient coding hypothesis in visual processing (Barlow, 1961), in particular the seminal work on the emergence of the V1-like Gabor filters in a sparse coding model by Olshausen & Field (1996). Indeed, our work is partly inspired by these results. While there are conceptual similarities, however, we should also note there are differences between the sparse coding work and ours. First, the sparsity constraint in sparse coding can be naturally viewed as a particular prior while in the context of the recurrent network, it is difficult to interpret that way. Second, the grid-like responses are not the most sparse solution one could imagine. In fact, they are still quite dense compared to a more spatially localized representation. Third, the grid-like patterns that emerged in our network are not filters based on the raw input, rather the velocity inputs need to be integrated first in order to encode spatial locations. Our work is also inspired by recent work using the efficient coding idea to explain the functional architecture of the grid cells (Wei et al., 2015). It has been shown that efficient coding considerations could explain the particular set of grid scales observed in rodents (Stensola et al., 2012). However, in that work, the firing patterns of the neurons are assumed to have a lattice structure to start with. Furthermore, our work is related to the study by Sussillo and others (Sussillo et al., 2015), in which they show that regularization of RNN models are important for generating solutions that are similar to the neural activity observed in motor cortex. In Sussillo et al., a smoothness constraint together with others lead to simple oscillatory neural dynamics that well matches the neural data. We have not incorporated a smoothness constraint into our network.
+
+Additionally, we note that there are a few recent studies which use place cells as the input to generate grid cells (Dordek et al., 2016; Stachenfeld et al., 2016), which are fundamentally different from our work. In these feedforward network models, the grid cells essentially perform dimensionality reduction based on the spatial input from place cells. However, the main issue with these models is that, it is unclear how place cells acquire spatial tuning in the first place. To the contrary, our model takes the animal’s velocity as the input, and addresses the question of how the spatial tuning can be generated from such input, which are known to exist in EC (Sargolini et al., 2006; Kropff et al., 2015). In another related study (Kanitscheider & Fiete, 2016), the authors train a RNN with
+
+LSTM units (Hochreiter & Schmidhuber, 1997) to perform different navigation tasks. However, no grid-like spatial firing patterns are reported.
+
+Although our model shows a qualitative match to the neural responses observed in the EC, nonetheless it has several major limitations, with each offering interesting future research directions. First, the learning rule we use seems to be biologically implausible. We are interested in exploring how a more biologically plausible learning rule could give rise to similar results (Lillicrap et al., 2016; Miconi, 2017; Guerguiev et al., 2017). Second, the simulation results do not show a variety of spatial scales in grid-like cells. Experimentally, it is known that grid cells have multiple spatial scales, that scale geometrically with a ratio 1.4 (Stensola et al., 2012), and this particular scale ratio is predicted by efficient coding of space (Wei et al., 2015). We are investigating how to modify the model to get a hierarchy of spatial scales, perhaps by incorporating more neurons or modifying the regularization. Last but not least, we have focused on the representation produced by the trained RNN. An equally important set of questions concern how the networks actually support the generation of such a representation. As a preliminary effort, we have examined the connectivity patterns of the trained network, and they do not seem to resemble the connectivity patterns required by standard attractor network models. Maybe this should not be seen as too surprising. After all, the trained networks can produce a diverse set of neural responses, while the previous models only led to grid responses. It would be interesting for future work to systematically examine the questions related to the underlying mechanisms.
+
+# 5 ACKNOWLEDGEMENTS
+
+We thank members of the Center for Theoretical Neuroscience at Columbia University for useful discussions and three anonymous reviewers for constructive feedback. Research supported by NSF NeuroNex Award DBI-1707398 and NIH training grant 5T32NS064929 (CJC).
+
+# REFERENCES
+
+Dmitriy Aronov, Rhino Nevers, and David W Tank. Mapping of a non-spatial dimension by the hippocampalentorhinal circuit. Nature, 2017.
+
+Horace B Barlow. Possible principles underlying the transformation of sensory messages. Sensory communication, pp. 217–234, 1961.
+
+Yoshua Bengio, Aaron Courville, and Pascal Vincent. Representation learning: A review and new perspectives. IEEE transactions on pattern analysis and machine intelligence, 35(8):1798–1828, 2013.
+
+Tale L Bjerknes, Edvard I Moser, and May-Britt Moser. Representation of geometric borders in the developing rat. Neuron, 82(1):71–78, 2014.
+
+Yoram Burak and Ila R Fiete. Accurate path integration in continuous attractor network models of grid cells. PLoS computational biology, 5(2):e1000291, 2009.
+
+Jonathan J Couey, Aree Witoelar, Sheng-Jia Zhang, Kang Zheng, Jing Ye, Benjamin Dunn, Rafal Czajkowski, May-Britt Moser, Edvard I Moser, Yasser Roudi, et al. Recurrent inhibitory circuitry as a mechanism for grid formation. Nature neuroscience, 16(3):318–324, 2013.
+
+Charles Darwin. Origin of certain instincts. Nature, 7:417–418, 1873.
+
+Geoffrey W Diehl, Olivia J Hon, Stefan Leutgeb, and Jill K Leutgeb. Grid and nongrid cells in medial entorhinal cortex represent spatial location and environmental features with complementary coding schemes. Neuron, 94(1):83–92, 2017.
+
+Yedidyah Dordek, Daniel Soudry, Ron Meir, and Dori Derdikman. Extracting grid cell characteristics from place cell inputs using non-negative principal component analysis. eLife, 5:e10094, 2016.
+
+Ariane S Etienne and Kathryn J Jeffery. Path integration in mammals. Hippocampus, 14(2):180– 192, 2004.
+
+Marianne Fyhn, Sturla Molden, Menno P Witter, Edvard I Moser, and May-Britt Moser. Spatial representation in the entorhinal cortex. Science, 305(5688):1258–1264, 2004.
+
+Marianne Fyhn, Torkel Hafting, Menno P Witter, Edvard I Moser, and May-Britt Moser. Grid cells in mice. Hippocampus, 18(12):1230–1238, 2008.
+
+Alex Graves, Abdel-Rahman Mohamed, and Geoffrey Hinton. Speech recognition with deep recurrent neural networks. In Acoustics, speech and signal processing (icassp), 2013 ieee international conference on, pp. 6645–6649. IEEE, 2013.
+
+Karol Gregor, Ivo Danihelka, Alex Graves, Danilo Jimenez Rezende, and Daan Wierstra. Draw: A recurrent neural network for image generation. arXiv preprint arXiv:1502.04623, 2015.
+
+Jordan Guerguiev, Timothy P Lillicrap, and Blake A Richards. Towards deep learning with segregated dendrites. eLife, 6, 2017.
+
+Torkel Hafting, Marianne Fyhn, Sturla Molden, May-Britt Moser, and Edvard I Moser. Microstructure of a spatial map in the entorhinal cortex. Nature, 436(7052):801–806, 2005.
+
+Kiah Hardcastle, Surya Ganguli, and Lisa M Giocomo. Environmental boundaries as an error correction mechanism for grid cells. Neuron, 86(3):827–839, 2015.
+
+James R Hinman, Mark P Brandon, Jason R Climer, G William Chapman, and Michael E Hasselmo. Multiple running speed signals in medial entorhinal cortex. Neuron, 91(3):666–679, 2016.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997.
+
+David H Hubel and Torsten N Wiesel. Receptive fields, binocular interaction and functional architecture in the cat’s visual cortex. The Journal of physiology, 160(1):106–154, 1962.
+
+Joshua Jacobs, Christoph T Weidemann, Jonathan F Miller, Alec Solway, John F Burke, Xue-Xin Wei, Nanthia Suthana, Michael R Sperling, Ashwini D Sharan, Itzhak Fried, et al. Direct recordings of grid-like neuronal activity in human spatial navigation. Nature neuroscience, 16(9):1188– 1190, 2013.
+
+Ingmar Kanitscheider and Ila Fiete. Training recurrent networks to generate hypotheses about how the brain solves hard navigation problems. arXiv preprint arXiv:1609.09059, 2016.
+
+Tim Christian Kietzmann, Patrick McClure, and Nikolaus Kriegeskorte. Deep neural networks in computational neuroscience. bioRxiv, pp. 133504, 2017.
+
+Nathaniel J Killian, Michael J Jutras, and Elizabeth A Buffalo. A map of visual space in the primate entorhinal cortex. Nature, 491(7426):761–764, 2012.
+
+Nikolaus Kriegeskorte. Deep neural networks: a new framework for modeling biological vision and brain information processing. Annual Review of Vision Science, 1:417–446, 2015.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In Advances in neural information processing systems, pp. 1097–1105, 2012.
+
+Emilio Kropff, James E Carmichael, May-Britt Moser, and Edvard I Moser. Speed cells in the medial entorhinal cortex. Nature, 523(7561):419–424, 2015.
+
+Julija Krupic, Neil Burgess, and John O?Keefe. Neural representations of location composed of spatially periodic bands. Science, 337(6096):853–857, 2012.
+
+Rosamund F Langston, James A Ainge, Jonathan J Couey, Cathrin B Canto, Tale L Bjerknes, Menno P Witter, Edvard I Moser, and May-Britt Moser. Development of the spatial representation system in the rat. Science, 328(5985):1576–1580, 2010.
+
+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–444, 2015.
+
+Colin Lever, Stephen Burton, Ali Jeewajee, John O’Keefe, and Neil Burgess. Boundary vector cells in the subiculum of the hippocampal formation. The journal of neuroscience, 29(31):9771–9777, 2009.
+
+Timothy P Lillicrap, Daniel Cownden, Douglas B Tweed, and Colin J Akerman. Random synaptic feedback weights support error backpropagation for deep learning. Nature communications, 7, 2016.
+
+Laurens van der Maaten and Geoffrey Hinton. Visualizing data using t-sne. Journal of Machine Learning Research, 9(Nov):2579–2605, 2008.
+
+Valerio Mante, David Sussillo, Krishna V Shenoy, and William T Newsome. Context-dependent computation by recurrent dynamics in prefrontal cortex. Nature, 503(7474):78–84, 2013.
+
+James Martens and Ilya Sutskever. Learning recurrent neural networks with hessian-free optimization. pp. 10331040, 2011.
+
+Bruce L McNaughton, Francesco P Battaglia, Ole Jensen, Edvard I Moser, and May-Britt Moser. Path integration and the neural basis of the ’cognitive map’. Nature Reviews Neuroscience, 7(8): 663–678, 2006.
+
+Thomas Miconi. Biologically plausible learning in recurrent neural networks reproduces neural dynamics observed during cognitive tasks. eLife, 6:e20899, 2017.
+
+M-L Mittelstaedt and H Mittelstaedt. Homing by path integration in a mammal. Naturwissenschaften, 67(11):566–567, 1980.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, 2015.
+
+Edvard I Moser, Emilio Kropff, and May-Britt Moser. Place cells, grid cells, and the brain’s spatial representation system. Annu. Rev. Neurosci., 31:69–89, 2008.
+
+John O’Keefe. Place units in the hippocampus of the freely moving rat. Experimental neurology, 51 (1):78–109, 1976.
+
+Bruno A Olshausen and David J Field. Emergence of simple-cell receptive field properties by learning a sparse code for natural images. Nature, 381(6583):607, 1996.
+
+Aaron van den Oord, Nal Kalchbrenner, and Koray Kavukcuoglu. Pixel recurrent neural networks. arXiv preprint arXiv:1601.06759, 2016.
+
+Eli Pollock, Niral Desai, Xue-Xin Wei, and Vijay B Balasubramanian. A mechanism for selforganized error-correction of grid cells by border cells. CoSyNe abstract, 2017.
+
+Alexei Samsonovich and Bruce L McNaughton. Path integration and cognitive mapping in a continuous attractor neural network model. Journal of Neuroscience, 17(15):5900–5920, 1997.
+
+Francesca Sargolini, Marianne Fyhn, Torkel Hafting, Bruce L McNaughton, Menno P Witter, MayBritt Moser, and Edvard I Moser. Conjunctive representation of position, direction, and velocity in entorhinal cortex. Science, 312(5774):758–762, 2006.
+
+Francesco Savelli, D Yoganarasimha, and James J Knierim. Influence of boundary removal on the spatial representations of the medial entorhinal cortex. Hippocampus, 18(12):1270, 2008.
+
+Andrew M Saxe, James L McClelland, and Surya Ganguli. Exact solutions to the nonlinear dynamics of learning in deep linear neural networks. 2014.
+
+Trygve Solstad, Charlotte N Boccara, Emilio Kropff, May-Britt Moser, and Edvard I Moser. Representation of geometric borders in the entorhinal cortex. Science, 322(5909):1865–1868, 2008.
+
+H Francis Song, Guangyu R Yang, and Xiao-Jing Wang. Training excitatory-inhibitory recurrent neural networks for cognitive tasks: A simple and flexible framework. PLoS Comput Biol, 12(2): e1004792, 2016.
+
+Kimberly Lauren Stachenfeld, Matthew M Botvinick, and Samuel J Gershman. The hippocampus as a predictive map. bioRxiv, pp. 097170, 2016.
+
+Hanne Stensola, Tor Stensola, Trygve Solstad, Kristian Frøland, May-Britt Moser, and Edvard I Moser. The entorhinal grid map is discretized. Nature, 492(7427):72–78, 2012.
+
+David Sussillo, Mark M Churchland, Matthew T Kaufman, and Krishna V Shenoy. A neural network that finds a naturalistic solution for the production of muscle activity. Nature neuroscience, 18(7): 1025–1033, 2015.
+
+Lucas Theis and Matthias Bethge. Generative image modeling using spatial lstms. In Advances in Neural Information Processing Systems, pp. 1927–1935, 2015.
+
+Xue-Xin Wei, Jason Prentice, and Vijay Balasubramanian. A principle of economy predicts the functional architecture of grid cells. Elife, 4:e08362, 2015.
+
+B Willmore and DJ Tolhurst. Characterizing the sparseness of neural codes. Network, 12:255–270, 2001.
+
+Tom J Wills, Francesca Cacucci, Neil Burgess, and John O’keefe. Development of the hippocampal cognitive map in preweanling rats. Science, 328(5985):1573–1576, 2010.
+
+Shawn S. Winter, Benjamin J. Clark, and Jeffrey S. Taube. Disruption of the head direction cell network impairs the parahippocampal grid cell signal. Science, 347(6224):870–874, 2015a.
+
+Shawn S. Winter, Max L. Mehlman, Benjamin J. Clark, and Jeffrey S. Taube. Passive transport disrupts grid signals in the parahippocampal cortex. Current Biology, 25:2493–2502, 2015b.
+
+Daniel LK Yamins and James J DiCarlo. Using goal-driven deep learning models to understand sensory cortex. Nature neuroscience, 19(3):356–365, 2016.
+
+Daniel LK Yamins, Ha Hong, Charles F Cadieu, Ethan A Solomon, Darren Seibert, and James J DiCarlo. Performance-optimized hierarchical models predict neural responses in higher visual cortex. Proceedings of the National Academy of Sciences, 111(23):8619–8624, 2014.
+
+Michael M Yartsev, Menno P Witter, and Nachum Ulanovsky. Grid cells without theta oscillations in the entorhinal cortex of bats. Nature, 479(7371):103–107, 2011.
+
+# A TRIANGULAR ENVIRONMENT
+
+![](images/9fec0b40f547311967f788a5e33c37ca83be210239a76a72034b231f75f6b016.jpg)
+
+![](images/76d7068d3c86954df82911a198a111d047595eeb46564b8603a26da4acf15c38.jpg)
+
+Noise and metabolic cost are important for grid-like representations. The figure on the left shows the spatial responses for a network trained with noise and no metabolic cost. The figure on the right shows the spatial responses for a network trained with no noise and the metabolic cost.
+
+![](images/ace176f80461890db9b194a0b86e5c7936f97026efec6348b0297c43783b3061.jpg)
+
+# B RECTANGULAR ENVIRONMENT
+
+![](images/fad2d973408af95191597a5e409766654c8b3a9862f0ad4f2a8de04f639ad5ee.jpg)![](images/97fb3c206da8fbace0f4d8eeba7efe4308290448d5d9e2cba584838472b30abd.jpg)
+
+Speed	input
+
+# C HEXAGONAL ENVIRONMENT
+
+![](images/d7c955da2b4d05471ca42b23f6a780ea605e2aed77c7b520059872b81c33fead.jpg)
+
+![](images/64fe9f96b9155e2bd1b22d7a344f3085ff647a473ca40df4a123eb8758cf0801.jpg)
+
+Angular	input	(0	to	360	degrees)
+
+Speed	tuning
+
+![](images/7eb735c5ab485558870c8b0720dd627699e69018e8cbacfa58c8d343cfc8a2d1.jpg)  
+Speed	input
+
+To quantify the speed selectivity of each unit we first fit a line to the tuning curve of unit activity as a function of speed. The speed selectivity is the absolute value of the slope. If the unit activity is not modulated by speed then the speed selectivity is 0. To quantify the direction selectivity of each unit we calculated the average unit activity as a function of direction input and then took the maximum minus minimum of this tuning curve. If the unit activity is not modulated by direction then the direction selectivity is 0. To quantify the spatial selectivity we used lifetime sparseness (Willmore & Tolhurst, 2001). If the unit activity is not modulated by spatial location then the spatial selectivity is 0. Each dot in the figures below show the selectivity for a single unit.
+
+![](images/7d81c0e39724fab8f48b0863c121f5336b8e91d07c652f62dff58ab0d2f8945e.jpg)
+
+# E ADDITIONAL TRAINING DETAILS
+
+During training we tried to balance all three terms we were minimizing $( E , R _ { L 2 }$ , and $R _ { F R }$ ) so no single term was neglected or dominated. At the beginning of training we weighted the regularization term $R _ { L 2 }$ to be equal to the error function $E$ and then decreased the weighting on $R _ { L 2 }$ according to the schedule used by Martens & Sutskever (2011). We adaptively adjusted the weighting on $R _ { F R }$ , starting from an initial value of $E / 1 0$ and enforcing an upper bound of $E / 3$ as training progressed. We found this training procedure improved training performance and led to more interesting representations.

parse/train/B17JTOe0-/B17JTOe0-_content_list.json

@@ -0,0 +1,1760 @@
+[
+    {
+        "type": "text",
+        "text": "EMERGENCE OF GRID-LIKE REPRESENTATIONS BYTRAINING RECURRENT NEURAL NETWORKS TOPERFORM SPATIAL LOCALIZATION",
+        "text_level": 1,
+        "bbox": [
+            174,
+            99,
+            821,
+            171
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Christopher J. Cueva∗, Xue-Xin Wei∗ Columbia University New York, NY 10027, USA {ccueva,weixxpku}@gmail.com ",
+        "bbox": [
+            183,
+            194,
+            446,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            287,
+            544,
+            303
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Decades of research on the neural code underlying spatial navigation have revealed a diverse set of neural response properties. The Entorhinal Cortex (EC) of the mammalian brain contains a rich set of spatial correlates, including grid cells which encode space using tessellating patterns. However, the mechanisms and functional significance of these spatial representations remain largely mysterious. As a new way to understand these neural representations, we trained recurrent neural networks (RNNs) to perform navigation tasks in 2D arenas based on velocity inputs. Surprisingly, we find that grid-like spatial response patterns emerge in trained networks, along with units that exhibit other spatial correlates, including border cells and band-like cells. All these different functional types of neurons have been observed experimentally. The order of the emergence of grid-like and border cells is also consistent with observations from developmental studies. Together, our results suggest that grid cells, border cells and others as observed in EC may be a natural solution for representing space efficiently given the predominant recurrent connections in the neural circuits. ",
+        "bbox": [
+            233,
+            321,
+            766,
+            529
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            563,
+            336,
+            579
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Understanding the neural code in the brain has long been driven by studying feed-forward architectures, starting from Hubel and Wiesel’s famous proposal on the origin of orientation selectivity in primary visual cortex (Hubel & Wiesel, 1962). Inspired by the recent development in deep learning (Krizhevsky et al., 2012; LeCun et al., 2015; Hochreiter & Schmidhuber, 1997; Mnih et al., 2015), there has been a burst of interest in applying deep feedforward models, in particular convolutional neural networks (CNN) (LeCun et al., 1998), to study the sensory systems, which hierarchically extract useful features from sensory inputs (see e.g., Yamins et al. (2014); Kriegeskorte (2015); Kietzmann et al. (2017); Yamins & DiCarlo (2016)). ",
+        "bbox": [
+            174,
+            595,
+            825,
+            708
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "For more cognitive tasks, neural systems often need to maintain certain internal representations of relevant variables in the absence of external stimuli- a process that requires more than feature extraction. We will focus on spatial navigation, which typically requires the brain to maintain a representation of self-location and update it according to the animal’s movements and landmarks of the environment. Physiological studies done in rodents and other mammals (including humans, non-human primates and bats) have revealed a variety of neural correlates of space in Hippocampus and Entorhinal Cortex (EC), including place cells (O’Keefe, 1976), grid cells (Fyhn et al., 2004; Hafting et al., 2005; Fyhn et al., 2008; Yartsev et al., 2011; Killian et al., 2012; Jacobs et al., 2013), along with border cells (Solstad et al., 2008), band-like cells (Krupic et al., 2012) and others (see Figure 1a). In particular, each grid cell only fires when the animal occupies a distinct set of physical locations, and strikingly these locations lie on a lattice. The study of the neural underpinning of spatial cognition has provided an important window into how high-level cognitive functions are supported in the brain (Moser et al., 2008; Aronov et al., 2017). ",
+        "bbox": [
+            174,
+            715,
+            825,
+            893
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "How might the spatial navigation task be solved using a network of neurons? Recurrent neural networks (RNNs) (Hochreiter & Schmidhuber, 1997; Graves et al., 2013; Oord et al., 2016; Theis & Bethge, 2015; Gregor et al., 2015; Sussillo et al., 2015) seem particularly useful for these tasks. Indeed, recurrent-based continuous attractor networks have been one popular type of models proposed for the formation of grid cells (McNaughton et al., 2006; Burak & Fiete, 2009; Couey et al., 2013) and place cells (Samsonovich & McNaughton, 1997). Such models have provided valuable insights into one set of possible mechanisms that could support the formation of the grids. However, these models typically rely on fine-tuned connectivity patterns, in particular the models need a subtle yet systematic asymmetry in the connectivity pattern to move the attractor state according to the animal’s own movement. The existence of such a specific 2D connectivity in rodent EC remains unclear. Additionally, previous models have mainly focused on grid cells, while other types of responses that co-exist in the Entorhinal Cortex have been largely ignored. It would be useful to have a unified model that can simultaneously explain different types of neural responses in EC. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            284
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Motivated by these considerations, here we present an alternative modeling approach for understanding the representation of space in the neural system. Specifically, we trained a RNN to perform some spatial navigation tasks. By leveraging the recent development in RNN training and knowledge of the navigation system in the brain, we show that training a RNN with biologically relevant constraints naturally gives rise to a variety of spatial response profiles as observed in EC, including grid-like responses. To our knowledge, this is the first study to show that grid-like responses could emerge from training a RNN to perform navigation. Our result implies that the neural representation in EC may be seen as a natural way for the brain to solve the navigation task efficiently (Wei et al., 2015). More generally, it suggests that RNNs can be a powerful tool for understanding the neural mechanisms of certain high-level cognitive functions. ",
+        "bbox": [
+            173,
+            291,
+            825,
+            430
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/8e6f9cf7feba198b2a18d2ed284d372bf5324606db8951624994c943f119c937.jpg",
+        "image_caption": [
+            "Figure 1: a) Example neural data showing different kinds of neural correlates underlying spatial navigation in EC. All figures are replotted from previous publications. From left to right: a “grid cell” recorded when an animal navigates in a square environment, replotted from Krupic et al. (2012), with the heat map representing the firing rate of this neuron as a function of the animal’s location (red corresponds to high firing rate); a “band-like” cell from Krupic et al. (2012); a border cell from Solstad et al. (2008); an irregular spatially tuned cell from Diehl et al. (2017); a “speed cell” from Kropff et al. (2015), which exhibits roughly linear dependence on the rodent’s running speed; a “heading direction cell” from Sargolini et al. (2006), which shows systematic change of firing rate depending on animal’s heading direction. b) The network consists of $N = 1 0 0$ recurrently connected units (or neurons) which receive two external inputs, representing the animal’s speed and heading direction. The two outputs linearly weight the neurons in the RNN. The goal of training is to make the responses of the two output neurons accurately represent the animal’s physical location. c) Typical trajectory after training. As shown, the output of the RNN can accurately, though not perfectly, track the animal’s location during navigation. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            238,
+            470,
+            751,
+            681
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 MODEL ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            269,
+            118
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 MODEL DESCRIPTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            132,
+            366,
+            147
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our network model consists of a set of recurrently connected units $N = 1 0 0$ ). The dynamics of each unit in the network $u _ { i } ( t )$ is governed by the standard continuous-time RNN equation: ",
+        "bbox": [
+            173,
+            159,
+            826,
+            188
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/73f5fb1e1639b7bb2d07858a8bd6b7b8e2b6dc0350eb54f951fc46c74a662eee.jpg",
+        "text": "$$\n\\tau \\frac { d x _ { i } ( t ) } { d t } = - x _ { i } ( t ) + \\sum _ { j = 1 } ^ { N } W _ { i j } ^ { \\mathrm { r e c } } u _ { j } ( t ) + \\sum _ { k = 1 } ^ { N _ { \\mathrm { i n } } } W _ { i k } ^ { \\mathrm { i n } } I _ { k } ( t ) + b _ { i } + \\xi _ { i } ( t )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            281,
+            190,
+            717,
+            236
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "for $i = 1 , \\ldots , N$ . The activity of each unit, $u _ { i } ( t )$ , is related to the activation of that unit, $x _ { i } ( t )$ , through a nonlinearity which in this study we take to be $u _ { i } ( t ) = \\operatorname { t a n h } ( x _ { i } ( t ) )$ . Each unit receives input from other units through the recurrent weight matrix $W ^ { \\mathrm { r e c } }$ and also receives external input, $I ( t )$ , that enters the network through the weight matrix $W ^ { \\mathrm { i n } }$ . Each unit has two sources of bias, $b _ { i }$ which is learned and $\\xi _ { i } ( t )$ which represents noise intrinsic to the network and is taken to be Gaussian with zero mean and constant variance. The network was simulated using the Euler method for $T = 5 0 0$ timesteps of duration $\\tau / 1 0$ . ",
+        "bbox": [
+            173,
+            239,
+            825,
+            338
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To perform a 2D navigation task with the RNN, we linearly combine the firing rates of units in the network to estimate the current location of the animal. The responses of the two linear readout neurons, $y _ { 1 } ( t )$ and $y _ { 2 } ( t )$ , are given by the following equation: ",
+        "bbox": [
+            174,
+            344,
+            825,
+            387
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d64453343a45b8133e59ab95038edf8c7ca7e2bd28bd901cacdd4eff0e7578b4.jpg",
+        "text": "$$\ny _ { j } ( t ) = \\sum _ { i = 1 } ^ { N } W _ { j i } ^ { \\mathrm { o u t } } u _ { i } ( t )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            419,
+            390,
+            576,
+            434
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 INPUT TO THE NETWORK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            449,
+            387,
+            463
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The network inputs and outputs were inspired by simple spatial navigation tasks in 2D open environments. The task resembles dead-reckoning (sometimes referred to as path integration), which is ethologically relevant for many animal species (Darwin, 1873; Mittelstaedt & Mittelstaedt, 1980; Etienne & Jeffery, 2004; McNaughton et al., 2006). To be more specific, the inputs to the network were the animal’s speed and direction at each time step. Experimentally, it has been shown that the velocity signals exist in EC (Sargolini et al., 2006; Kropff et al., 2015; Hinman et al., 2016), and there is also evidence that such signals are necessary for grid formation (Winter et al., 2015a;b). ",
+        "bbox": [
+            173,
+            473,
+            825,
+            571
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Throughout the paper, we adopt the common assumption that the head direction of the animal coincides with the actual moving direction. The outputs were the x- and y-coordinates of the integrated position. The direction of the animal is modeled by modified Brownian motion to increase the probability of straight-runs, in order to be consistent with the typical rodent’s behavior in an open environment. The usage of such simple movement statistics has the advantage of having full control of the simulated trajectories. However, for future work it would be very interesting to test the model using different animals’ real movement trajectories to see how the results might change. ",
+        "bbox": [
+            173,
+            578,
+            825,
+            676
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Special care is taken when the animal is close to the boundary. The boundary of the environment will affect the statistics of the movement, as the animal cannot cross the boundary. This fact was reflected in the model by re-sampling the angular input variable until the input angle did not lead the animal outside the boundary. In the simulations shown below, the animal always starts from the center of the arena, but we verified that the results are insensitive to the starting locations. ",
+        "bbox": [
+            173,
+            683,
+            825,
+            753
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.3 TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            768,
+            287,
+            784
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We optimized the network parameters $W ^ { \\mathrm { r e c } } , W ^ { \\mathrm { i n } } ,$ , $b$ and $W ^ { \\mathrm { o u t } }$ to minimize the squared error in equation (3) between target $\\mathbf { X } ^ { - }$ and $_ \\textrm { y }$ -coordinates from a two dimensional navigation task (performed in rectangular, hexagonal, and triangular arenas) and the network outputs generated according to equation (2). ",
+        "bbox": [
+            173,
+            794,
+            825,
+            851
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c0586e3c42e764d474fb5fc1894e2ed9f63e5c96ba0d3cd1f2199ef9a9b3a013.jpg",
+        "text": "$$\nE = \\frac { 1 } { M T N _ { \\mathrm { o u t } } } \\sum _ { m , t , j = 1 } ^ { M , T , N _ { \\mathrm { o u t } } } ( y _ { j } ( t , m ) - y _ { j } ^ { \\mathrm { t a r g e t } } ( t , m ) ) ^ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            326,
+            849,
+            669,
+            895
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Parameters were updated with the Hessian-free algorithm (Martens & Sutskever, 2011) using minibatches of size $M = 5 0 0$ trials. In addition to minimizing the error function in equation (3) we regularized the input and output weights according to equation (4) and the squared firing rates of the units (referred to as metabolic cost) according to equation (5). In sum, the training aims to minimize a loss function, that consists of the error of the animal, the metabolic cost, and a penalty for large network parameters. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e960c0e70ffb072304b7abf5d77743a5b44399b4e093a5b22d41b568af796bb4.jpg",
+        "text": "$$\n\\begin{array} { l } { { \\displaystyle R _ { L 2 } = \\frac { 1 } { N N _ { \\mathrm { i n } } } \\sum _ { i , j = 1 } ^ { N , N _ { \\mathrm { i n } } } ( W _ { i j } ^ { \\mathrm { i n } } ) ^ { 2 } + \\frac { 1 } { N N _ { \\mathrm { o u t } } } \\sum _ { i , j = 1 } ^ { N _ { \\mathrm { o u t } } , N } ( W _ { i j } ^ { \\mathrm { o u t } } ) ^ { 2 } } } \\\\ { { \\displaystyle R _ { F R } = \\frac { 1 } { N T M } \\sum _ { i , t , m = 1 } ^ { N , T , M } u _ { i } ( t , m ) ^ { 2 } } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            320,
+            180,
+            678,
+            273
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We find that the results are qualitatively insensitive to the initialization schemes used for the recurrent weight matrix $W ^ { \\mathrm { r e c } }$ . For the results presented in this paper, simulations in the hexagonal environment were obtained by initializing the elements of $W ^ { \\mathrm { r e c } }$ to be zero mean Gaussian random variables with variance $1 . 5 ^ { 2 } \\dot { / } N$ , and simulations in the square and triangular environments were initialized with an orthogonal $W ^ { \\mathrm { r e c } }$ (Saxe et al., 2014). We initialized the bias $b$ and output weights $W ^ { \\mathrm { o u t } }$ to be zero. The elements of $W ^ { \\mathrm { i n } }$ were zero mean Gaussian variables with variance $1 / N _ { \\mathrm { i n } }$ . ",
+        "bbox": [
+            174,
+            281,
+            825,
+            366
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/7cde4a241b1b10ed008d3d0dbd8d11d439e41445d8cafe267c621ecd7571dd08.jpg",
+        "image_caption": [
+            "Figure 2: Different types of spatial selective responses of units in the trained RNN. Example simulation results for three different environments (square, triangular, hexagon) are presented. Blue (yellow) represents low (high) activity. a) Grid-like responses. b) Band-like responses; c) Borderrelated responses; d) Spatially irregular responses. These responses can be spatially selective but they do not form a regular pattern defined in the conventional sense. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            378,
+            790,
+            589
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            699,
+            281,
+            715
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We run simulation experiments in arenas with different boundary shapes, including square, triangular and hexagonal. Figure 1c shows a typical example of the model performance after training; the network (red trace) accurately tracks the animal’s actual path (black). ",
+        "bbox": [
+            174,
+            729,
+            825,
+            772
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 TUNING PROPERTIES OF THE MODEL NEURONS",
+        "text_level": 1,
+        "bbox": [
+            174,
+            789,
+            539,
+            803
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We are mostly interested in what kind of representation the RNN has learned to solve this navigation task, and whether such a representation resembles the response properties of neurons in EC (Moser et al., 2008). ",
+        "bbox": [
+            176,
+            814,
+            825,
+            857
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1.1 SPATIAL TUNING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            871,
+            346,
+            886
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To test whether the trained RNN developed location-selective representations, we plot individual neurons’ mean activity level as a function of the animal’s location during spatial exploration. Note that these average response profiles should not be confused with the linear filters typically shown in feedforward networks. Surprisingly, we find neurons in the trained RNN show a range of interesting spatial response profiles. Examination of these response profiles suggests they can be classified into distinct functional types. Importantly, as we will show, these distinct spatial response profiles can be mapped naturally to known physiology in EC. The spatial responses of all units in trained networks are shown in the Appendix. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Grid-like responses Most interestingly, we find some of the units in the RNN exhibit clear grid-like responses (Figure 2a). These firing patterns typically exhibit multiple firing fields, with each firing field exhibiting roughly circular symmetric or ellipse shape. Furthermore, the firing fields are highly structured, i.e., when combined, are arranged on a regular lattice. Furthermore, the structure of the response lattice depends on the shape of the boundary. In particular, training the network to perform self-localization in a square environment tends to give rectangular grids. In hexagonal and triangular environments, the grids are closer to triangular. ",
+        "bbox": [
+            174,
+            194,
+            825,
+            291
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Experimentally, it is shown that (medial) EC contains so-called grid cells which exhibit multiple firing fields that lie on a regular grid (Fyhn et al., 2004; Hafting et al., 2005). The grid-like firing patterns in our simulation are reminiscent of the grid cells in rodents and other mammals. However, we also notice that the the grid-like model responses typically exhibit few periods, not as many as experimental data (see Figure 1a). It is possible that using a larger network might reveal finer grid-patterns in our model. Nonetheless, it is surprising that the gird-like spatial representations can develop in our model, given there is no periodicity in the input. Another potential concern is that, experimentally it is reported that the grids are often on the corners of a triangular lattice (Hafting et al., 2005) even in square environments (see Figure 1a), though the grids are somewhat influenced by the shape of the environment. However, the rats in these experiments presumable had spatial experience in other environments with various boundary shapes. Experimentally, it would be interesting to see if grid cells would lie on a square lattice instead if the rats are raised in a single square environment - a situation we are simulating here. ",
+        "bbox": [
+            174,
+            299,
+            825,
+            478
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Border responses Many neurons in the RNN exhibit selectivity to the boundary (Figure 2c). Typically, they only encode a portion of the boundary, e.g. one piece of wall in a square shaped environment. Such properties are similar to the border cells discovered in rodent EC (Solstad et al., 2008; Savelli et al., 2008; Lever et al., 2009). Experimentally, border cells mainly fire along one piece of wall, although some have been observed to fire along multiple borders or along the whole boundary of the environment; interestingly, these multi-border responses were also observed in some RNN models. Currently, it is unclear how the boundary-like response profiles emerge (Solstad et al., 2008; Savelli et al., 2008; Lever et al., 2009). Our model points to the possibility that the border cells may emerge without the presence of tactile cues. Furthermore, it suggests that border cell formation may be related to the movement statistics of the animals, i.e. due to the asymmetry of the movement statistics along the boundary. ",
+        "bbox": [
+            174,
+            486,
+            825,
+            638
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Band-like responses Interestingly, some neurons in the RNN exhibit band-like responses (Figure 2b). In most of our simulations, these bands tend to be parallel to one of the boundaries. For some of the units, one of the bands overlaps the boundary, but for others, that is not the case. Experimentally, neurons with periodic-like firing patterns have been recently reported in rodent EC. In one study, it has been reported that a substantial portion of cells in EC exhibit band-like firing characteristics (Krupic et al., 2012). However, we note that based on the reported data in Krupic et al. (2012), the band pattern is not as clear as in our model. ",
+        "bbox": [
+            173,
+            645,
+            825,
+            743
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Spatially-stable but non-regular responses Besides the units described above, most of the remaining units also exhibit stable spatial responses, but they do not belong to the above categories. These response profiles can exhibit either one large irregular firing field; or multiple circular firing fields, but these firing fields do not show a regular pattern. Experimentally these types of cells have also been observed. In fact, it is recently reported that the non-grid spatial cells constitute a large portion of the neurons in Layer II and III of rodent EC (Diehl et al., 2017). ",
+        "bbox": [
+            174,
+            751,
+            825,
+            834
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1.2 SPEED TUNING AND HEAD DIRECTION TUNING",
+        "text_level": 1,
+        "bbox": [
+            174,
+            856,
+            552,
+            869
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Speed tuning We next ask how neurons in the RNN are tuned to the inputs. Many of the model neurons exhibit linear responses to the running speed of the animal, while some neurons show no selectivity to speed, as suggested by the near-flat response functions. Example response profiles are shown in Figure 3. Interestingly, we observe that the model border cells tend to have almost zero speed-tuning (e.g., see Figure 3g,h). ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/318a67b1eb08bdf270e30eebad468380d0e5a80e744e9f80d58a5d693f3a94ed.jpg",
+        "image_caption": [
+            "Figure 3: Direction tuning and speed tuning for nine example units in an RNN trained in a triangular arena. For each unit, we show the spatial tuning, (head) directional tuning, speed tuning respectively, from left to right. a,b,c) The three model neurons show strong directional tuning, but the spatial tuning is weak and irregular. The three neurons also exhibit linear speed tuning. d,e,f) The three neurons exhibit grid-like firing patterns, and clear speed tuning. The strength of their direction tuning differ. ${ \\bf g } , { \\bf h } )$ Border cells exhibit weak and a bit complex directional tuning and almost no speed tuning. i) This band cell shows weak directional tuning, but strong speed tuning. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            214,
+            104,
+            784,
+            253
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            397,
+            823,
+            426
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Head direction tuning A substantial portion of the model neurons show direction tuning. There are a diversity of direction tuning profiles, both in terms of the strength of the tuning and their preferred direction. Example tuning curves are shown in Figure 3, and the direction tuning curves of a complete population are shown in the Appendix. Interestingly, in general model neurons which show the strongest head direction tuning do not show a clear spatial firing pattern (see Figure 3a,b,c). This suggests that there are a group of neurons which are mostly responsible for encoding the direction. We also notice that neurons with clear grid-like firing can exhibit a variety of direction tuning strengths, from weak to strong (Figure 3d,e,f). In the Appendix, we quantify the relation between these different tuning properties at the whole population level, which show somewhat complex dependence. ",
+        "bbox": [
+            174,
+            433,
+            825,
+            571
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Experimentally, the heading direction tuning in EC is well-known, e.g., Sargolini et al. (2006). Both the grid and non-grid cells in EC exhibit head direction tuning (Sargolini et al., 2006). Furthermore, the linear speed dependence of the model neurons is similar to the properties of speed cells reported recently in EC (Kropff et al., 2015). Our result is also consistent with another recent study reporting that the majority of neurons in EC exhibit some amount of speed tuning (Hinman et al., 2016). It remains an open question experimentally, at a population level, how different types of tuning characteristics in EC relate to each other. ",
+        "bbox": [
+            174,
+            579,
+            825,
+            676
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.1.3 DEVELOPMENT OF THE TUNING PROPERTIES",
+        "text_level": 1,
+        "bbox": [
+            174,
+            696,
+            537,
+            710
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We next investigate how the spatial response profiles evolve as learning/training progresses. We report two main observations. First, neurons that fire selectively along the boundary typically emerge first. Second, the grid-like responses with finer spatial tuning patterns only emerge later in training. For visualization, we perform dimensionality reduction using the t-SNE algorithm (Maaten & Hinton, 2008). This algorithm embeds 100 model neurons during three phases of training (early, intermediate, and late) into a two-dimensional space according to the similarity of their temporal responses. Here the similarity metric is taken to be firing rate correlation. In this 2D space as shown in Figure 4a, border cell representations appear early and stably persist through the end of training. Furthermore, early during training all responses are similar to the border related responses. In contrast, grid-like cells typically undergo a substantial change in firing pattern during training before settling into their final grid-like representation (Figure 4b). ",
+        "bbox": [
+            174,
+            722,
+            825,
+            875
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The developmental time line of the grid-like cells and border cells is roughly consistent with developmental studies in rodents. Experimentally, it is known that border cells emerge earlier in development, and they exist at about 2 weeks after the rat is born (Bjerknes et al., 2014). The grid cells mature only at about 4 weeks after birth (Langston et al., 2010; Wills et al., 2010; Bjerknes et al., 2014). Furthermore, our simulations suggest the reason why border cells emerge earlier in development may be that computationally it is easier to wire-up a network that gives rise to border cell responses. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/9c19816ea23656a00f78df190e6e407bf4c84fe0856a9d69293f60f5972dfa0a.jpg",
+        "image_caption": [
+            "Figure 4: Development of border cells and grid-like cells. Early during training all responses are similar to the border related responses, and only as training continues do the grid-like cells emerge. We perform dimensionality reduction using the t-SNE algorithm on the firing rates of the neurons. Each dot represents one neuron $N = 1 0 0$ ), and the color represents different training stages (early/intermediate/late shown in blue/cyan/yellow). Each line shows the trajectory of a single highlighted neuron as its firing responses evolve during training. In panel a), we highlight the border representation. It appears there are four clusters of border cells, each responding to one wall of a square environment (spatial responses from four of these border cells are inset). These cells’ response profiles appear early and stably persist through training, illustrated by the short distance they travel in this space. In b), we show that the neurons which eventually become grid cells initially have tuning profiles similar to the border cells but then change their tuning substantially during learning. As a natural consequence, they need to travel a long distance in this space between the early and late phase of the training. Spatial responses are shown for four of these grid-like cells during the late phase of training. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            176,
+            797,
+            366
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.2 THE IMPORTANCE OF REGULARIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            611,
+            488,
+            625
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We find appropriate regularizations of the RNN to be crucial for the emergence of grid-like representations. We only observed grid-like representations when the network was encouraged to store information while perturbed by noise. This was accomplished by setting the speed input to zero, e.g. zero speed $90 \\%$ of the time, and adding Gaussian noise to the network $\\xi _ { i } ( t )$ in equation (1)); the precise method for setting the speed input to zero and the value of the noise variance is not crucial for our simulations to develop grid-like representations. The cost function which aims to capture the penalization on the metabolic cost of the neural activity also acts as an important regularization. Our simulations show that the grid-like representation did not emerge without this metabolic cost. In Figure 5, we show typical simulation results for a square environment, with and without proper metabolic regularization. In the Appendix, we illustrate the effect of regularization further, in particular the role of injecting noise into the RNN units. ",
+        "bbox": [
+            174,
+            637,
+            825,
+            790
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Our results are consistent with the general notion on the importance of incorporating proper constraint for learning useful representations in neural networks (Bengio et al., 2013). Furthermore, it suggests that, to learn a model with response properties similar to neural systems it may be necessary to incorporate the relevant constraints, e.g., noise and metabolic cost. ",
+        "bbox": [
+            174,
+            797,
+            825,
+            853
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.3 ERROR CORRECTION AROUND THE BOUNDARY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            871,
+            537,
+            883
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "One natural question is whether the trained RNNs are able to perform localization when the path length exceeds the typical length used during training (500 steps), in particular given that noise in the network would gradually accumulate, leading to a decrease in localization performance. We test this by simulating paths that are several orders of magnitude longer. Somewhat surprisingly, we find the RNNs still perform well (Figure 6b). In fact, the squared error (averaged over every 10000 steps) is stable. The spatial response profiles of individual units also remain stable. This implies that the RNNs have acquired intrinsic error-correction mechanisms during training. ",
+        "bbox": [
+            176,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/476435913a7b64388291eece485ed2e49a2bc8befbf4d07d7b0df7b3c97e20d4.jpg",
+        "image_caption": [
+            "Figure 5: Complete set of spatial response profiles for 100 neurons in a RNN trained in a square environment. a) Without proper regularization, complex and periodic spatial response patterns do not emerge. b) With proper regularization, a rich set of periodic response patterns emerge, including grid-like responses. Regularization can also be adjusted to achieve spatial profiles intermediate between these two examples. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            99,
+            794,
+            333
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/1313022c4e140eff6c754917cddc7b20c35899670d67ff7b351c56f3f49df4d8.jpg",
+        "image_caption": [
+            "Figure 6: Error-correction happens at the boundary and the error is stable over time. At the boundary, the direction is resampled to avoid input velocities that lead to a path extending beyond the boundary of the environment. These changing input statistics at the boundary, termed a boundary interaction, are the only cue the RNN receives about the boundary. We find that the RNN uses the boundary interactions to correct the accumulated error between the true integrated input and its prediction based on the linear readout of equation (2). Panel a), the mean squared error increases when there are no boundary interactions, but then decreases after a boundary interaction, with more boundary interactions leading to greater error reduction. In the absence of further boundary interaction, the squared error would gradually increase again (blue curve) at roughly a constant rate. b) The network was trained using mini-batches of 500 timesteps but has stable error over a duration at least four orders of magnitude larger. The error of the RNN output (mean and standard deviation shown in black, computed based on 10000 timesteps) is compared to the error that would be achieved by an RNN outputting the best constant values (red). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            209,
+            436,
+            785,
+            593
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            819,
+            825,
+            888
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "As shown earlier, during training some of the RNN units develop boundary-related firing (Figure 2c), presumably by exploiting the change of input statistics around the boundary. We hypothesize that boundary interactions may enable error-correction through signals based on these boundary-related activities. Indeed, we find that boundary interactions can dramatically reduce the accumulated error (Figure 6a). Figure 6a shows that, without boundary interactions, on average the squared error grows roughly linearly as expected, however, interactions with the boundaries substantially reduce the error, and more frequent boundary interactions can reduce the error further. Error-correction on grid cells via boundary interactions has been proposed (Hardcastle et al., 2015; Pollock et al., 2017), however, we emphasize that the model proposed here develops the grid-like responses, boundary responses and the error-correction mechanisms all within the same neural network, thus potentially providing a unifying account of a diverse set of phenomena. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            229
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            256,
+            310,
+            272
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we trained RNNs to perform path integration (dead-reckoning) in 2D arenas. We found that after training RNNs with appropriate regularization, the model neurons exhibit a variety of spatial and velocity tuning profiles that match neurophysiology in EC. What’s more, there is also similarity in terms of when these distinct neuron types emerge during training/development. The EC has long been thought to be involved in path integration and localization of the animal’s location (Moser et al., 2008). The general agreement between the different response properties in our model and the neurophysiology provide strong evidence supporting the hypothesis that the neural population in EC may provide an efficient code for representation self-locations based on the velocity input. ",
+        "bbox": [
+            174,
+            291,
+            825,
+            416
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Recently, there has been increased interest in using complex neural network models to understand the neural code. But the focus has been on using feedforward architectures, in particular CNNs (LeCun et al., 1998). Given the abundant recurrent connections in the brain, it seems a particularly fruitful avenue to take advantage of the recent development in RNNs to help with neuroscience questions (Mante et al., 2013; Song et al., 2016; Miconi, 2017; Sussillo et al., 2015). Here, we only show one instance following this approach. However, the insight from this work could be general, and potentially useful for other cognitive functions as well. ",
+        "bbox": [
+            174,
+            424,
+            825,
+            521
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The finding that metabolic constraints lead to the emergence of grid-like responses may be seen as conceptually related to the efficient coding hypothesis in visual processing (Barlow, 1961), in particular the seminal work on the emergence of the V1-like Gabor filters in a sparse coding model by Olshausen & Field (1996). Indeed, our work is partly inspired by these results. While there are conceptual similarities, however, we should also note there are differences between the sparse coding work and ours. First, the sparsity constraint in sparse coding can be naturally viewed as a particular prior while in the context of the recurrent network, it is difficult to interpret that way. Second, the grid-like responses are not the most sparse solution one could imagine. In fact, they are still quite dense compared to a more spatially localized representation. Third, the grid-like patterns that emerged in our network are not filters based on the raw input, rather the velocity inputs need to be integrated first in order to encode spatial locations. Our work is also inspired by recent work using the efficient coding idea to explain the functional architecture of the grid cells (Wei et al., 2015). It has been shown that efficient coding considerations could explain the particular set of grid scales observed in rodents (Stensola et al., 2012). However, in that work, the firing patterns of the neurons are assumed to have a lattice structure to start with. Furthermore, our work is related to the study by Sussillo and others (Sussillo et al., 2015), in which they show that regularization of RNN models are important for generating solutions that are similar to the neural activity observed in motor cortex. In Sussillo et al., a smoothness constraint together with others lead to simple oscillatory neural dynamics that well matches the neural data. We have not incorporated a smoothness constraint into our network. ",
+        "bbox": [
+            174,
+            529,
+            825,
+            804
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Additionally, we note that there are a few recent studies which use place cells as the input to generate grid cells (Dordek et al., 2016; Stachenfeld et al., 2016), which are fundamentally different from our work. In these feedforward network models, the grid cells essentially perform dimensionality reduction based on the spatial input from place cells. However, the main issue with these models is that, it is unclear how place cells acquire spatial tuning in the first place. To the contrary, our model takes the animal’s velocity as the input, and addresses the question of how the spatial tuning can be generated from such input, which are known to exist in EC (Sargolini et al., 2006; Kropff et al., 2015). In another related study (Kanitscheider & Fiete, 2016), the authors train a RNN with ",
+        "bbox": [
+            174,
+            813,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "LSTM units (Hochreiter & Schmidhuber, 1997) to perform different navigation tasks. However, no grid-like spatial firing patterns are reported. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Although our model shows a qualitative match to the neural responses observed in the EC, nonetheless it has several major limitations, with each offering interesting future research directions. First, the learning rule we use seems to be biologically implausible. We are interested in exploring how a more biologically plausible learning rule could give rise to similar results (Lillicrap et al., 2016; Miconi, 2017; Guerguiev et al., 2017). Second, the simulation results do not show a variety of spatial scales in grid-like cells. Experimentally, it is known that grid cells have multiple spatial scales, that scale geometrically with a ratio 1.4 (Stensola et al., 2012), and this particular scale ratio is predicted by efficient coding of space (Wei et al., 2015). We are investigating how to modify the model to get a hierarchy of spatial scales, perhaps by incorporating more neurons or modifying the regularization. Last but not least, we have focused on the representation produced by the trained RNN. An equally important set of questions concern how the networks actually support the generation of such a representation. As a preliminary effort, we have examined the connectivity patterns of the trained network, and they do not seem to resemble the connectivity patterns required by standard attractor network models. Maybe this should not be seen as too surprising. After all, the trained networks can produce a diverse set of neural responses, while the previous models only led to grid responses. It would be interesting for future work to systematically examine the questions related to the underlying mechanisms. ",
+        "bbox": [
+            174,
+            140,
+            825,
+            375
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 ACKNOWLEDGEMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            396,
+            398,
+            411
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We thank members of the Center for Theoretical Neuroscience at Columbia University for useful discussions and three anonymous reviewers for constructive feedback. Research supported by NSF NeuroNex Award DBI-1707398 and NIH training grant 5T32NS064929 (CJC). ",
+        "bbox": [
+            176,
+            426,
+            821,
+            469
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            489,
+            285,
+            505
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dmitriy Aronov, Rhino Nevers, and David W Tank. Mapping of a non-spatial dimension by the hippocampalentorhinal circuit. Nature, 2017. ",
+        "bbox": [
+            174,
+            513,
+            823,
+            541
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Horace B Barlow. Possible principles underlying the transformation of sensory messages. Sensory communication, pp. 217–234, 1961. ",
+        "bbox": [
+            171,
+            551,
+            825,
+            580
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yoshua Bengio, Aaron Courville, and Pascal Vincent. Representation learning: A review and new perspectives. IEEE transactions on pattern analysis and machine intelligence, 35(8):1798–1828, 2013. ",
+        "bbox": [
+            176,
+            588,
+            823,
+            631
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tale L Bjerknes, Edvard I Moser, and May-Britt Moser. Representation of geometric borders in the developing rat. Neuron, 82(1):71–78, 2014. ",
+        "bbox": [
+            173,
+            640,
+            825,
+            670
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yoram Burak and Ila R Fiete. Accurate path integration in continuous attractor network models of grid cells. PLoS computational biology, 5(2):e1000291, 2009. ",
+        "bbox": [
+            174,
+            678,
+            823,
+            708
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jonathan J Couey, Aree Witoelar, Sheng-Jia Zhang, Kang Zheng, Jing Ye, Benjamin Dunn, Rafal Czajkowski, May-Britt Moser, Edvard I Moser, Yasser Roudi, et al. Recurrent inhibitory circuitry as a mechanism for grid formation. Nature neuroscience, 16(3):318–324, 2013. ",
+        "bbox": [
+            178,
+            715,
+            823,
+            758
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Charles Darwin. Origin of certain instincts. Nature, 7:417–418, 1873. ",
+        "bbox": [
+            173,
+            767,
+            632,
+            784
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey W Diehl, Olivia J Hon, Stefan Leutgeb, and Jill K Leutgeb. Grid and nongrid cells in medial entorhinal cortex represent spatial location and environmental features with complementary coding schemes. Neuron, 94(1):83–92, 2017. ",
+        "bbox": [
+            178,
+            791,
+            823,
+            834
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yedidyah Dordek, Daniel Soudry, Ron Meir, and Dori Derdikman. Extracting grid cell characteristics from place cell inputs using non-negative principal component analysis. eLife, 5:e10094, 2016. ",
+        "bbox": [
+            176,
+            843,
+            821,
+            886
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ariane S Etienne and Kathryn J Jeffery. Path integration in mammals. Hippocampus, 14(2):180– 192, 2004. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Marianne Fyhn, Sturla Molden, Menno P Witter, Edvard I Moser, and May-Britt Moser. Spatial representation in the entorhinal cortex. Science, 305(5688):1258–1264, 2004. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Marianne Fyhn, Torkel Hafting, Menno P Witter, Edvard I Moser, and May-Britt Moser. Grid cells in mice. Hippocampus, 18(12):1230–1238, 2008. ",
+        "bbox": [
+            171,
+            141,
+            823,
+            170
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Graves, Abdel-Rahman Mohamed, and Geoffrey Hinton. Speech recognition with deep recurrent neural networks. In Acoustics, speech and signal processing (icassp), 2013 ieee international conference on, pp. 6645–6649. IEEE, 2013. ",
+        "bbox": [
+            176,
+            179,
+            823,
+            222
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Karol Gregor, Ivo Danihelka, Alex Graves, Danilo Jimenez Rezende, and Daan Wierstra. Draw: A recurrent neural network for image generation. arXiv preprint arXiv:1502.04623, 2015. ",
+        "bbox": [
+            173,
+            231,
+            821,
+            261
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jordan Guerguiev, Timothy P Lillicrap, and Blake A Richards. Towards deep learning with segregated dendrites. eLife, 6, 2017. ",
+        "bbox": [
+            174,
+            268,
+            820,
+            299
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Torkel Hafting, Marianne Fyhn, Sturla Molden, May-Britt Moser, and Edvard I Moser. Microstructure of a spatial map in the entorhinal cortex. Nature, 436(7052):801–806, 2005. ",
+        "bbox": [
+            174,
+            306,
+            820,
+            337
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kiah Hardcastle, Surya Ganguli, and Lisa M Giocomo. Environmental boundaries as an error correction mechanism for grid cells. Neuron, 86(3):827–839, 2015. ",
+        "bbox": [
+            176,
+            344,
+            820,
+            375
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "James R Hinman, Mark P Brandon, Jason R Climer, G William Chapman, and Michael E Hasselmo. Multiple running speed signals in medial entorhinal cortex. Neuron, 91(3):666–679, 2016. ",
+        "bbox": [
+            176,
+            382,
+            821,
+            412
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997. ",
+        "bbox": [
+            174,
+            421,
+            823,
+            450
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "David H Hubel and Torsten N Wiesel. Receptive fields, binocular interaction and functional architecture in the cat’s visual cortex. The Journal of physiology, 160(1):106–154, 1962. ",
+        "bbox": [
+            174,
+            459,
+            823,
+            489
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Joshua Jacobs, Christoph T Weidemann, Jonathan F Miller, Alec Solway, John F Burke, Xue-Xin Wei, Nanthia Suthana, Michael R Sperling, Ashwini D Sharan, Itzhak Fried, et al. Direct recordings of grid-like neuronal activity in human spatial navigation. Nature neuroscience, 16(9):1188– 1190, 2013. ",
+        "bbox": [
+            173,
+            497,
+            825,
+            554
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ingmar Kanitscheider and Ila Fiete. Training recurrent networks to generate hypotheses about how the brain solves hard navigation problems. arXiv preprint arXiv:1609.09059, 2016. ",
+        "bbox": [
+            173,
+            563,
+            823,
+            593
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tim Christian Kietzmann, Patrick McClure, and Nikolaus Kriegeskorte. Deep neural networks in computational neuroscience. bioRxiv, pp. 133504, 2017. ",
+        "bbox": [
+            173,
+            601,
+            823,
+            631
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nathaniel J Killian, Michael J Jutras, and Elizabeth A Buffalo. A map of visual space in the primate entorhinal cortex. Nature, 491(7426):761–764, 2012. ",
+        "bbox": [
+            173,
+            638,
+            823,
+            669
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nikolaus Kriegeskorte. Deep neural networks: a new framework for modeling biological vision and brain information processing. Annual Review of Vision Science, 1:417–446, 2015. ",
+        "bbox": [
+            171,
+            678,
+            823,
+            707
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In Advances in neural information processing systems, pp. 1097–1105, 2012. ",
+        "bbox": [
+            176,
+            714,
+            825,
+            757
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Emilio Kropff, James E Carmichael, May-Britt Moser, and Edvard I Moser. Speed cells in the medial entorhinal cortex. Nature, 523(7561):419–424, 2015. ",
+        "bbox": [
+            173,
+            767,
+            823,
+            796
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Julija Krupic, Neil Burgess, and John O?Keefe. Neural representations of location composed of spatially periodic bands. Science, 337(6096):853–857, 2012. ",
+        "bbox": [
+            171,
+            804,
+            823,
+            835
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Rosamund F Langston, James A Ainge, Jonathan J Couey, Cathrin B Canto, Tale L Bjerknes, Menno P Witter, Edvard I Moser, and May-Britt Moser. Development of the spatial representation system in the rat. Science, 328(5985):1576–1580, 2010. ",
+        "bbox": [
+            176,
+            843,
+            821,
+            886
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998. ",
+        "bbox": [
+            176,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Yoshua Bengio, and Geoffrey Hinton. Deep learning. Nature, 521(7553):436–444, 2015. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Colin Lever, Stephen Burton, Ali Jeewajee, John O’Keefe, and Neil Burgess. Boundary vector cells in the subiculum of the hippocampal formation. The journal of neuroscience, 29(31):9771–9777, 2009. ",
+        "bbox": [
+            174,
+            141,
+            823,
+            184
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Timothy P Lillicrap, Daniel Cownden, Douglas B Tweed, and Colin J Akerman. Random synaptic feedback weights support error backpropagation for deep learning. Nature communications, 7, 2016. ",
+        "bbox": [
+            174,
+            193,
+            825,
+            236
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Laurens van der Maaten and Geoffrey Hinton. Visualizing data using t-sne. Journal of Machine Learning Research, 9(Nov):2579–2605, 2008. ",
+        "bbox": [
+            174,
+            244,
+            821,
+            273
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Valerio Mante, David Sussillo, Krishna V Shenoy, and William T Newsome. Context-dependent computation by recurrent dynamics in prefrontal cortex. Nature, 503(7474):78–84, 2013. ",
+        "bbox": [
+            174,
+            282,
+            821,
+            313
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "James Martens and Ilya Sutskever. Learning recurrent neural networks with hessian-free optimization. pp. 10331040, 2011. ",
+        "bbox": [
+            173,
+            320,
+            823,
+            351
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Bruce L McNaughton, Francesco P Battaglia, Ole Jensen, Edvard I Moser, and May-Britt Moser. Path integration and the neural basis of the ’cognitive map’. Nature Reviews Neuroscience, 7(8): 663–678, 2006. ",
+        "bbox": [
+            173,
+            358,
+            825,
+            401
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Thomas Miconi. Biologically plausible learning in recurrent neural networks reproduces neural dynamics observed during cognitive tasks. eLife, 6:e20899, 2017. ",
+        "bbox": [
+            173,
+            411,
+            823,
+            440
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "M-L Mittelstaedt and H Mittelstaedt. Homing by path integration in a mammal. Naturwissenschaften, 67(11):566–567, 1980. ",
+        "bbox": [
+            171,
+            449,
+            823,
+            478
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, 2015. ",
+        "bbox": [
+            173,
+            486,
+            825,
+            530
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Edvard I Moser, Emilio Kropff, and May-Britt Moser. Place cells, grid cells, and the brain’s spatial representation system. Annu. Rev. Neurosci., 31:69–89, 2008. ",
+        "bbox": [
+            171,
+            539,
+            823,
+            568
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "John O’Keefe. Place units in the hippocampus of the freely moving rat. Experimental neurology, 51 (1):78–109, 1976. ",
+        "bbox": [
+            171,
+            577,
+            823,
+            606
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Bruno A Olshausen and David J Field. Emergence of simple-cell receptive field properties by learning a sparse code for natural images. Nature, 381(6583):607, 1996. ",
+        "bbox": [
+            168,
+            614,
+            823,
+            645
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Aaron van den Oord, Nal Kalchbrenner, and Koray Kavukcuoglu. Pixel recurrent neural networks. arXiv preprint arXiv:1601.06759, 2016. ",
+        "bbox": [
+            173,
+            652,
+            823,
+            683
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Eli Pollock, Niral Desai, Xue-Xin Wei, and Vijay B Balasubramanian. A mechanism for selforganized error-correction of grid cells by border cells. CoSyNe abstract, 2017. ",
+        "bbox": [
+            171,
+            690,
+            821,
+            720
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alexei Samsonovich and Bruce L McNaughton. Path integration and cognitive mapping in a continuous attractor neural network model. Journal of Neuroscience, 17(15):5900–5920, 1997. ",
+        "bbox": [
+            171,
+            728,
+            821,
+            758
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Francesca Sargolini, Marianne Fyhn, Torkel Hafting, Bruce L McNaughton, Menno P Witter, MayBritt Moser, and Edvard I Moser. Conjunctive representation of position, direction, and velocity in entorhinal cortex. Science, 312(5774):758–762, 2006. ",
+        "bbox": [
+            174,
+            767,
+            823,
+            810
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Francesco Savelli, D Yoganarasimha, and James J Knierim. Influence of boundary removal on the spatial representations of the medial entorhinal cortex. Hippocampus, 18(12):1270, 2008. ",
+        "bbox": [
+            171,
+            819,
+            823,
+            848
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Andrew M Saxe, James L McClelland, and Surya Ganguli. Exact solutions to the nonlinear dynamics of learning in deep linear neural networks. 2014. ",
+        "bbox": [
+            173,
+            857,
+            821,
+            886
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Trygve Solstad, Charlotte N Boccara, Emilio Kropff, May-Britt Moser, and Edvard I Moser. Representation of geometric borders in the entorhinal cortex. Science, 322(5909):1865–1868, 2008. ",
+        "bbox": [
+            174,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "H Francis Song, Guangyu R Yang, and Xiao-Jing Wang. Training excitatory-inhibitory recurrent neural networks for cognitive tasks: A simple and flexible framework. PLoS Comput Biol, 12(2): e1004792, 2016. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Kimberly Lauren Stachenfeld, Matthew M Botvinick, and Samuel J Gershman. The hippocampus as a predictive map. bioRxiv, pp. 097170, 2016. ",
+        "bbox": [
+            173,
+            155,
+            823,
+            184
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Hanne Stensola, Tor Stensola, Trygve Solstad, Kristian Frøland, May-Britt Moser, and Edvard I Moser. The entorhinal grid map is discretized. Nature, 492(7427):72–78, 2012. ",
+        "bbox": [
+            173,
+            193,
+            823,
+            222
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "David Sussillo, Mark M Churchland, Matthew T Kaufman, and Krishna V Shenoy. A neural network that finds a naturalistic solution for the production of muscle activity. Nature neuroscience, 18(7): 1025–1033, 2015. ",
+        "bbox": [
+            174,
+            231,
+            823,
+            272
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Lucas Theis and Matthias Bethge. Generative image modeling using spatial lstms. In Advances in Neural Information Processing Systems, pp. 1927–1935, 2015. ",
+        "bbox": [
+            174,
+            281,
+            823,
+            311
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Xue-Xin Wei, Jason Prentice, and Vijay Balasubramanian. A principle of economy predicts the functional architecture of grid cells. Elife, 4:e08362, 2015. ",
+        "bbox": [
+            174,
+            319,
+            823,
+            349
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B Willmore and DJ Tolhurst. Characterizing the sparseness of neural codes. Network, 12:255–270, 2001. ",
+        "bbox": [
+            174,
+            357,
+            823,
+            386
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Tom J Wills, Francesca Cacucci, Neil Burgess, and John O’keefe. Development of the hippocampal cognitive map in preweanling rats. Science, 328(5985):1573–1576, 2010. ",
+        "bbox": [
+            174,
+            395,
+            825,
+            424
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Shawn S. Winter, Benjamin J. Clark, and Jeffrey S. Taube. Disruption of the head direction cell network impairs the parahippocampal grid cell signal. Science, 347(6224):870–874, 2015a. ",
+        "bbox": [
+            173,
+            433,
+            823,
+            463
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Shawn S. Winter, Max L. Mehlman, Benjamin J. Clark, and Jeffrey S. Taube. Passive transport disrupts grid signals in the parahippocampal cortex. Current Biology, 25:2493–2502, 2015b. ",
+        "bbox": [
+            173,
+            469,
+            823,
+            501
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Daniel LK Yamins and James J DiCarlo. Using goal-driven deep learning models to understand sensory cortex. Nature neuroscience, 19(3):356–365, 2016. ",
+        "bbox": [
+            173,
+            508,
+            823,
+            537
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Daniel LK Yamins, Ha Hong, Charles F Cadieu, Ethan A Solomon, Darren Seibert, and James J DiCarlo. Performance-optimized hierarchical models predict neural responses in higher visual cortex. Proceedings of the National Academy of Sciences, 111(23):8619–8624, 2014. ",
+        "bbox": [
+            174,
+            546,
+            823,
+            589
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Michael M Yartsev, Menno P Witter, and Nachum Ulanovsky. Grid cells without theta oscillations in the entorhinal cortex of bats. Nature, 479(7371):103–107, 2011. ",
+        "bbox": [
+            174,
+            598,
+            823,
+            627
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A TRIANGULAR ENVIRONMENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            452,
+            117
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/9fec0b40f547311967f788a5e33c37ca83be210239a76a72034b231f75f6b016.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            348,
+            136,
+            648,
+            320
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/76d7068d3c86954df82911a198a111d047595eeb46564b8603a26da4acf15c38.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            383,
+            825,
+            568
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Noise and metabolic cost are important for grid-like representations. The figure on the left shows the spatial responses for a network trained with noise and no metabolic cost. The figure on the right shows the spatial responses for a network trained with no noise and the metabolic cost. ",
+        "bbox": [
+            174,
+            579,
+            825,
+            622
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/ace176f80461890db9b194a0b86e5c7936f97026efec6348b0297c43783b3061.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            313,
+            95,
+            640,
+            559
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "B RECTANGULAR ENVIRONMENT ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            467,
+            117
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/97fb3c206da8fbace0f4d8eeba7efe4308290448d5d9e2cba584838472b30abd.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            321,
+            136,
+            650,
+            580
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "",
+        "image_caption": [
+            "Speed\tinput "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            308,
+            299,
+            643,
+            835
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "C HEXAGONAL ENVIRONMENT ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            446,
+            117
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/d7c955da2b4d05471ca42b23f6a780ea605e2aed77c7b520059872b81c33fead.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            348,
+            136,
+            650,
+            321
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/64fe9f96b9155e2bd1b22d7a344f3085ff647a473ca40df4a123eb8758cf0801.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            348,
+            373,
+            635,
+            553
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "Angular\tinput\t(0\tto\t360\tdegrees) ",
+        "bbox": [
+            424,
+            577,
+            573,
+            587
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "Speed\ttuning ",
+        "bbox": [
+            467,
+            637,
+            529,
+            647
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/7eb735c5ab485558870c8b0720dd627699e69018e8cbacfa58c8d343cfc8a2d1.jpg",
+        "image_caption": [
+            "Speed\tinput "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            338,
+            661,
+            633,
+            830
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "To quantify the speed selectivity of each unit we first fit a line to the tuning curve of unit activity as a function of speed. The speed selectivity is the absolute value of the slope. If the unit activity is not modulated by speed then the speed selectivity is 0. To quantify the direction selectivity of each unit we calculated the average unit activity as a function of direction input and then took the maximum minus minimum of this tuning curve. If the unit activity is not modulated by direction then the direction selectivity is 0. To quantify the spatial selectivity we used lifetime sparseness (Willmore & Tolhurst, 2001). If the unit activity is not modulated by spatial location then the spatial selectivity is 0. Each dot in the figures below show the selectivity for a single unit. ",
+        "bbox": [
+            173,
+            133,
+            825,
+            246
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/7d81c0e39724fab8f48b0863c121f5336b8e91d07c652f62dff58ab0d2f8945e.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            247,
+            828,
+            868
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "E ADDITIONAL TRAINING DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            480,
+            117
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "During training we tried to balance all three terms we were minimizing $( E , R _ { L 2 }$ , and $R _ { F R }$ ) so no single term was neglected or dominated. At the beginning of training we weighted the regularization term $R _ { L 2 }$ to be equal to the error function $E$ and then decreased the weighting on $R _ { L 2 }$ according to the schedule used by Martens & Sutskever (2011). We adaptively adjusted the weighting on $R _ { F R }$ , starting from an initial value of $E / 1 0$ and enforcing an upper bound of $E / 3$ as training progressed. We found this training procedure improved training performance and led to more interesting representations. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            231
+        ],
+        "page_idx": 18
+    }
+]

parse/train/B1em9h4KDS/B1em9h4KDS.md

@@ -0,0 +1,388 @@
+# GENERATIVE IMPUTATION AND STOCHASTIC PREDICTION
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+In many machine learning applications, we are faced with incomplete datasets. In the literature, missing data imputation techniques have been mostly concerned with filling missing values. However, the existence of missing values is synonymous with uncertainties not only over the distribution of missing values but also over target class assignments that require careful consideration. In this paper, we propose a simple and effective method for imputing missing features and estimating the distribution of target assignments given incomplete data. In order to make imputations, we train a simple and effective generator network to generate imputations that a discriminator network is tasked to distinguish. Following this, a predictor network is trained using the imputed samples from the generator network to capture the classification uncertainties and make predictions accordingly. The proposed method is evaluated on CIFAR-10 image dataset as well as three real-world tabular classification datasets, under different missingness rates and structures. Our experimental results show the effectiveness of the proposed method in generating imputations as well as providing estimates for the class uncertainties in a classification task when faced with missing values.
+
+# 1 INTRODUCTION
+
+While a large body of the machine learning literature is built upon the assumption of having access to complete datasets, in many real-world problems only incomplete datasets are available. The existence of missing values can be due to many different causes such as human subjects not adhering to certain questions or features not being collected frequently due to financial or experimental limitations, sensors failures, and so forth. Data imputation techniques have been suggested as a solution to bridge this gap in the literature by replacing missing values with observed values.
+
+Missing data imputation approaches can be categorized into single and multiple imputation methods. Single imputation methods try to replace each missing value with a plausible value that is the best fit given the value of other correlated features and knowledge extracted from the dataset (Hastie et al., 1999; Anderson, 1957). While these methods are easy to implement and use in practice, imputed values may induce bias by eliminating less likely but important values. Also, these methods do not suggest a way to measure to what extent the imputed values are representative of the missing values (Little & Rubin, 2019).
+
+Multiple imputation (MI) techniques, as suggested by the name, try to use multiple imputed values to impute each missing value. The result would be having a set of imputed datasets that enables measuring how consistent and statistically significant are the results of the experiments (Rubin, 1976). While MI offers interesting statistical insights about the reliability of analysis on incomplete data, the insight is imprecise as it is mainly concerned about the population of data samples rather than individual instances. Specifically, MI methods reason about the statistical properties on a limited number of imputed datasets (less than 10 in most practical implementations) on the population of samples within the dataset (Schafer & Graham, 2002; Murray et al., 2018).
+
+The existence of missing values is synonymous with having uncertainty over these values that requires careful consideration. In many real-world applications, we are dealing with supervised problems that demand modeling and prediction based on incomplete data. Take for instance, prediction of class assignments given an image in which a large portion of the frame is missing. In such a scenario, based on observed frame parts, there might be multiple probable class assignments each having a different likelihood. Here, we are not only interested in imputing missing values or measuring how robust our imputations are, but also it is highly desirable to measure the impact of missing values on the prediction outcome for each instance.
+
+In this paper, we propose the idea of Generative Imputation and Stochastic Prediction (GI) as a novel approach to impute missing values and to measure class uncertainties arising from the distribution of missing values. The suggested approach is based on neural networks trained using an adversarial objective function. Additionally, a predictor is trained on the generated samples from the imputer network which is able to reflect the impact of uncertainties over missing values. This enables measuring different prediction outcomes and certainties for each specific instance. We evaluate the effectiveness of the proposed method on different incomplete image and tabular datasets under various missingness structures.
+
+# 2 RELATED WORK
+
+One of the simplest traditional methods for handling missing values includes imputing the occurrences of missing values with constant values such as zeros or using mean values. To enhance the accuracy of such imputations, alternatives such as $\mathbf { k }$ -nearest neighbors (KNN) (Hastie et al., 1999) and maximum likelihood estimation (MLE) (Anderson, 1957) have been suggested to estimate values to be used given an observed context. While these methods are easy to implement and analyze, they often fail to capture the complex feature dependencies as well as structures present in many problems.
+
+Rubin (1976) suggested a categorization for missingness mechanisms: missing completely at random (MCAR), missing at random (MAR), and missing not at random (MNAR). Under the assumption of MAR, the authors suggested multiple imputation (MI) as a stochastic imputation method. Here, instead of imputing missing values using a single value, several values are sampled to represent the distribution over the missing value. MI generates a few imputed complete datasets that are then used independently in statistical modeling (Schafer & Graham, 2002; Little & Rubin, 2019). Usually, the final goal of MI is to measure the robustness of the final statistical analysis amongst the imputed datasets. In other words, it measures the quality of imputations and the statistical significance of analysis on the imputed data. It should be noted that the number of imputations used in MI is usually very limited. Also, often strong simplifying assumptions are made in modeling the data distribution (e.g., multi-variate Gaussian or Student’s t distribution) which limit the applicability of this method (Schafer & Graham, 2002; Murray et al., 2018).
+
+More recently, autoencoder architectures have been suggested as powerful density estimators capable of capturing complex distributions. Perhaps, denoising autoencoders (DAE) (Vincent et al., 2008) are one of the most intuitive approaches in which a neural network is trained to reconstruct and denoise its input. Following a more probabilistic perspective, variational autoencoders (VAE) (Kingma & Welling, 2013) try to learn the data generating distribution via a latent representation. Specifically, conditional variational autoencoders (CVAE) (Sohn et al., 2015) can be used to sample missing values conditioned on observed values. For instance, Mattei & Frellsen (2018) suggested a method based on deep latent variable models and importance sampling that offers a tighter likelihood bound compared to the standard VAE bound. While these methods are powerful generative models applicable to missing data imputation, often samples generated using autoencoders are biased toward the mode of the distribution (e.g., resulting in blurry images, for vision tasks) (Goodfellow et al., 2014; Dumoulin et al., 2016).
+
+Recently, due to the success of generative adversarial networks (GAN), there has been great attention toward applying them to impute missing values. For instance, Yoon et al. (2018) suggested an imputation method based on adversarial and reconstruction loss terms. Li et al. (2019) introduced the idea of using separate generator and discriminator networks to learn the missing data structure and data distribution. These methods have been quite successful and are able to present the state-of-the-art results. Though it should be noted that often the presence of additional loss terms may bias the generated samples toward the mode of the distribution being modeled. Also, these methods are often complicated to be applied in practical setups by practitioners. For instance, Yoon et al. (2018) requires setting hyperparameters to adjust the influence of an MSE loss term as well as the rate of discriminator hint vectors. Also as another example, Li et al. (2019) uses three generators and three discriminators for the final imputer architecture.
+
+![](images/c5713bc074e138a2a20d050db7edf84f541cc471e67603e24e6900e610f80f08.jpg)  
+Figure 1: Block diagram of the proposed adversarial imputation method. $h$ represents the blending function of (1), and $L$ is the adversarial loss function of (2).
+
+From the perspective of supervised analysis, imputation and handling missing values are usually considered as a preprocessing step. A few exceptions exist such as Bayesian models and decision trees that permit direct analysis on incomplete data (Nielsen & Jensen, 2009; Zhang et al., 2005). Note that while certain Bayesian methods such as probabilistic Bayesian networks allow handling of missing values as unobserved variables. However, given an incomplete training dataset and without any known causal structure as a priori, learning such models is a very challenging problem with the complexity of at least NP-complete to learn the network architecture in addition to an iterative EM optimization to learn model parameters (Darwiche, 2009; Neapolitan et al., 2004). We argue that the simplistic approach of imputing missing values as a preprocessing step discards uncertainties that exist in original incomplete data samples. Instead, there is a need for methods that reflect these uncertainties on the final predicted target distribution. This work suggests the idea of training a predictor on different imputed samples to capture the uncertainties over class assignments. Compared to MI, the suggested method interleaves imputation and training a downstream prediction model, enabling to estimate classification uncertainties for each instance.
+
+# 3 PROPOSED METHOD
+
+# 3.1 PROBLEM DEFINITION
+
+In this paper, we make the general assumption of having access to an incomplete dataset $\mathcal { D }$ consisting of a set of feature vector, mask vector, and target class pairs $( { \pmb x } _ { i } , { \pmb k } _ { i } , y _ { i } )$ . For each feature vector, $\pmb { x } _ { i } \in \mathbb { R } ^ { d }$ , only a subset of the features is available. The mask vector $\pmb { k } _ { i } \in \{ 0 , 1 \} ^ { d }$ is used to indicate available features and missing features by ones and zeros, respectively. Here, to represent features as fixed-width vectors, arbitrary (or NaN) values are used to fill missing values. Also, for convenience, we often use $\pmb { x } _ { i } ^ { o b s }$ and $\pmb { x } _ { i } ^ { m i s s }$ to refer to the set of observed and missing features for the feature vector $\mathbf { \Delta } _ { \mathbf { \mathcal { X } } _ { i } }$ .
+
+We define our objective in two steps: $( i )$ Imputing missing values via sampling from the conditional distribution of missing features given observed features i.e., $P ( \pmb { x } _ { i } ^ { m i s s } | \pmb { x } _ { i } ^ { o b s } )$ . $( i i )$ Estimating the distribution of target classes given the observed features and the distribution of missing features i.e., $P ( y | \mathbf { x } _ { i } ^ { o b s } , \mathbf { x } _ { i } ^ { m i s s } )$ . For the first part, we are interested in sampling from the conditional distribution rather than finding the mode of the distribution as the most probable imputation. Similarly, for the second part, we are interested in obtaining a distribution over the possible target assignments and the confidence of each class rather than maximum likelihood class assignments.
+
+# 3.2 GENERATIVE IMPUTATION
+
+To generate samples from the distribution of missing features conditioned on the observed features, we follow the idea first suggested by Yoon et al. (2018). In this paradigm, a generator network is responsible for generating imputations while a discriminator is trying to distinguish imputed features from observed features (see Figure 1).
+
+Specifically, the generator function $G ( \pmb { x } _ { i } , \pmb { k } _ { i } , z ) \in \mathbb { R } ^ { d }$ generates an imputed feature vector, based on observed features, the corresponding mask, and a Gaussian noise vector $( z )$ . Note that, in order to achieve the final imputed vector, $\widehat { \pmb { x } } _ { i }$ , we blend (or, merge) the output of the generator with the input features to replace generated values with the exact values of observed features:
+
+$$
+\begin{array} { r } { \widehat { \pmb { x } } _ { i , j } = \left\{ \begin{array} { l l } { \pmb { x } _ { i , j } } & { \mathrm { i f } ~ \pmb { k } _ { i , j } = 1 } \\ { G ( \pmb { x } _ { i } , \pmb { k } _ { i } , z ) _ { j } } & { \mathrm { i f } ~ \pmb { k } _ { i , j } = 0 } \end{array} \right. , } \end{array}
+$$
+
+where $\mathbf { \delta } _ { \mathbf { x } _ { i , j } }$ refers to $j ^ { : }$ ’th feature of sample $i$ . Also, note that by sampling $_ { z }$ multiple times, we can obtain different imputation samples from the conditional distribution indicated by $\widehat { \pmb { x } } _ { i } ^ { l }$ where $l$ is the sample number.
+
+A discriminator network, $D ( \widehat { \mathbf { x } } _ { i } )$ , is trained to distinguish real and imputed features by generating a predicted softmax mask output, $\widehat { \pmb { k } } _ { i }$ . Here a binary cross-entropy loss per mask element is used as the adversarial objective function:
+
+$$
+\operatorname* { m a x } _ { G } \operatorname* { m i n } _ { D } L ( G , D ) = \mathbb { E } _ { k \sim \mathcal { D } , \widehat { k } \sim D ( G ( x , k , z ) ) } \ [ k ^ { T } \log ( \widehat { k } ) \ + \ ( 1 - k ) ^ { T } \log ( 1 - \widehat { k } ) ] .
+$$
+
+The intuition behind this adversarial loss function is that given a generator function which captures the data distribution successfully, the discriminator would not be able to distinguish the parts of the feature vector that were originally missing.
+
+Compared to Yoon et al. (2018), the objective function of (2) does not have an MSE loss term. Instead, we use recent advances in GAN stabilization and training to improve the training process (see Section 3.4). While it is quite prevalent in the adversarial learning literature to use additional loss terms such as mean squared error (MSE) to enhance the quality of generated samples, we decided to keep our solution as simple as possible. Additionally, in our experiments, we provide supporting evidence that this simple loss function enables us to sample from the conditional distribution and prevents biased inclinations toward distribution modes.
+
+# 3.3 STOCHASTIC PREDICTION
+
+To capture the distribution of target classes given incomplete data, we suggest the idea of stochastic prediction. As indicated in the previous section, the generator can be used to sample from the conditional distribution. Here, a predictor is trained based on the imputed samples to predict class assignments and to calculate the confidence of these assignments. For instance, for a specific test sample at hand, if a certain missing feature is a strong indicator of the target class, we would like to observe the impact of different imputations for that feature on the final hypothesis.
+
+Formally, we are interested in finding the certainty of class assignments given observed features:
+
+$$
+\Psi = P ( y | \mathbf { x } _ { i } ^ { o b s } ) .
+$$
+
+Here, $\Psi$ is a vector where each element is representing a certain class. Rewriting (3) as a marginal we have:
+
+$$
+\Psi = \int P ( \pmb { x } _ { i } ^ { m i s s } ) P ( y | \pmb { x } _ { i } ^ { o b s } , \pmb { x } _ { i } ^ { m i s s } ) d \pmb { x } _ { i } ^ { m i s s } .
+$$
+
+Approximating the integration using a summation, given enough samples, $\Psi$ can be estimated by:
+
+$$
+\Psi \approx \frac { 1 } { N } \sum P ( y | \pmb { x } _ { i } ^ { o b s } , \widehat { \pmb { x } } _ { i } ^ { m i s s } ) ,
+$$
+
+where $\widehat { \pmb { x } } _ { i } ^ { m i s s }$ are samples taken from the conditional distribution of missing features given observed bones. We use the suggested generative imputation method to generate samples required for this approximation. Rewriting (1) using Hadamard product and as function of the noise vector:
+
+$$
+\widehat { \mathbf { x } } _ { i } = \pmb { k } _ { i } \odot \pmb { x } _ { i } + \left( 1 - \pmb { k } _ { i } \right) \odot G ( \pmb { x } _ { i } , \pmb { k } _ { i } , z )
+$$
+
+Assuming that a predictor, $F _ { \theta }$ , is available which predicts class assignments for a complete feature vector, $\Psi$ can be estimated as:
+
+$$
+\Psi = \mathbb { E } _ { \mathbf { z } } [ F _ { \boldsymbol { \theta } } ( \widehat { \mathbf { x } } _ { i } ) ] \approx \frac { 1 } { N } { \sum _ { l = 1 } ^ { N } } F _ { \boldsymbol { \theta } } ( \widehat { \mathbf { x } } _ { i } ^ { l } ) ~ .
+$$
+
+Algorithm 1 presents the suggested algorithm for training the predictor. It consists of taking samples from the incomplete dataset, then imputing them using our generator network, and using the imputed
+
+<table><tr><td>Algorithm1: Training the predictor.</td></tr><tr><td>Input: G (trained imputer), D (dataset) Output: Fθ (trained predictor) foreachTrainingEpoch do foreach(xi,ki,yi) in D do z ~ N(0,I) Xi ←ki①xi+(1-ki)OG(xi,ki,z) loss ← L(yi,yred) Backpropagate loss</td></tr></table>
+
+Algorithm 2: Estimating target distributions.   
+Input: $F _ { \theta }$ (trained predictor), $( x , k )$ (test sample), $\mathbf { N }$ (ensemble samples)   
+Output: $\Psi$ (distribution over target classes)   
+Ψ ← zeros ∈ R#classes   
+foreach Ensemble Sample $^ { l }$ to $N$ do z ∼ N (0, I) $\widehat { \mathbf { x } }  k \odot x + ( 1 - k ) \odot G ( { \pmb { x } } , { \pmb { k } } , z )$ bypred ← Fθ(x) bj ← argmax(ypred) Ψj ← Ψj + 1N
+
+samples to update the predictor. Note that, on each epoch and for each sample, the generator generates a new sample from the conditional distribution. Intuitively, it means that the predictor observes and learns to operate under different imputations for a given sample. This is different from approaches such as multiple imputation where several predictors are trained on different imputed versions of a dataset.
+
+Algorithm 2 presents the suggested algorithm for making predictions and estimating target distributions given a trained predictor model. Here, a sample is imputed $N$ times and inference on this set results in an ensemble of predictions over different imputations. The output of this algorithm can be interpreted as a distribution over the confidence of class assignments given a partially observed test sample. The following claims justify the validity of Algorithm 1and Algorithm 2.
+
+Claim 1. (Generalization of the predictor). If we assume imputed $\widehat { x _ { i } s }$ are samples from the underlying bfeature distribution, then the assigned training set labels can be modeled as labels generated from a noisy labeling process.
+
+Claim 1 permits the analysis of the generalization and convergence for the predictor trained using Algorithm 1 based on current literature in training models with noisy labels (Natarajan et al., 2013; Reed et al., 2014; Chen et al., 2019). From the analysis provided by Chen et al. (2019), test accuracy in asymmetric label noise conditions is a quadratic function of the label noise:
+
+$$
+P ( y _ { i } = \widehat { y _ { i } } ) = ( 1 - \epsilon ) ^ { 2 } + \epsilon ^ { 2 } ,
+$$
+
+where $\widehat { y _ { i } }$ is underlying true label for the imputed feature vector $( \widehat { x _ { i } } )$ , and $y _ { i }$ is the label provided by bthe incomplete dataset. In (8), label noise ratio, $\epsilon$ b, represents the probability of the label transition from a certain target class to another:
+
+$$
+\epsilon = 1 - P ( \widehat { y _ { i } } = j | y _ { i } = j ) .
+$$
+
+In practice, $\epsilon$ is determined by the problem-specific underlying data distribution as well as the distribution of missing values.
+
+Justification for claim 1 is straightforward, assume that $\{ \widehat { y _ { i } } ^ { 1 } \ldots \widehat { y _ { i } } ^ { N } \}$ are underlying true labels for each of $\{ \widehat { x _ { i } } ^ { 1 } \ldots \widehat { x _ { i } } ^ { N } \}$ b b. During training, for any imputed sample in $\{ \widehat { x _ { i } } ^ { 1 } \ldots \widehat { x _ { i } } ^ { N } \}$ , we use the dataset bprovided label, $y$ b b, to calculate the loss and to update model parameters. In the case that any of $\{ \widehat { y _ { i } } ^ { 1 } \ldots \widehat { y _ { i } } ^ { N } \}$ is different from $y$ , the loss term corresponding to that term would be calculated using b ba wrong label. Here, if we consider the average impact on gradients for batches of samples rather than individual cases, the overall impact on training would be very similar to the case of training using noisy labels.
+
+Claim 2. (Approximation of the target distribution). If we assume: (i) imputed $\widehat { x _ { i } s }$ are valid samples from the underlying feature distribution, b(ii) a good predictor can be trained using the incomplete data, (iii) enough samples are used and the Monte Carlo estimator is unbiased, then the target distribution, $\Psi$ , can be estimated accurately.
+
+This claim supports Algorithm 2 that is suggested to estimate the target distribution given a partially observed feature vector.
+
+The first assumption is consistent with the theoretical analysis of generative adversarial networks that they can converge to the true underlying distribution (Arora et al., 2018; Liu et al., 2017). The second assumption is supported by Claim 1. Regarding the last assumption, each sample requires one forward computation of the generator and predictor networks which, based on the scalability of current network architectures, usually permits thousands of samples to be taken at a reasonable computational cost.
+
+# 3.4 IMPLEMENTATION DETAILS
+
+As we conduct experiments on image and tabular datasets, we use different architectures for each. For image datasets, we used a generator and discriminator architectures similar to the ones suggested by Wang et al. (2018). However, we improved these architectures using self-attention layers (Zhang et al., 2018). It should be noted that, while Zhang et al. (2018) suggests using a single self-attention layer in the middle of the network, we observed consistent improvements by inserting multiple self-attention layers before each residual block within the network. Furthermore, as input to the generator, we concatenate input image, mask, and a random $_ z$ frame along the channels dimension and use it as input. For tabular datasets, we use a simple 4 layer network consisting of fully-connected and batch-norm layers. Also, the input to the generator is the concatenation of a feature vector, mask vector, and a $_ { z }$ vector of size $\frac { 1 } { 8 }$ of the input. For all experiments, we use an ensemble size $( N )$ ) equal to 128.
+
+We used Adam (Kingma & Ba, 2014) for model optimization. Two time-scale update rule (TTUR) (Heusel et al., 2017) was used to balance training the generator and discriminator networks. We explored best TTUR learning-rate settings from the set of {0.001, 0.0005, 0.0001, 0.00005}. Here, Adam parameters $\beta _ { 1 }$ and $\beta _ { 2 }$ are set to 0.5 and 0.999, respectively. Also, spectral normalization was used to stabilize both the generator and discriminator network in our experiments with image data (Miyato et al., 2018). For the predictor network, we used the default Adam settings as suggested by Kingma & Ba (2014). In all training procedures, we decay learning rate by a factor of 5 after reaching a plateau. For all experiments, we use a batch size of 64. Based on our experiments, we found that pretraining the discriminator while fixing the generator network for the first $5 \%$ of the training epochs helps the stability of training.
+
+Further detail on exact architectures, experiments, software dependencies, etc. as well as ablation studies is provided in the appendices.
+
+# 4 EXPERIMENTS
+
+# 4.1 DATASETS
+
+To evaluate the proposed method we use CIFAR-10 (Krizhevsky & Hinton, 2009) as an image classification dataset as well as three non-image datasets: UCI Landsat (Dua & Graff, 2017)2, MIT-BIH arrhythmia (Moody & Mark, 2001), and Diabetes classification (Kachuee et al., 2019) 3. CIFAR-10 dataset consists of $6 0 , 0 0 0 \ 3 2 \mathrm { x } \ 3 2$ images from 10 different classes. For this task, we use train and test sets as provided by the dataset. As a preprocessing step, we normalize pixel values to the range of [0,1] and subtract the mean image. The only data augmentation we use for this task is to randomly flip training images for each batch.
+
+UCI Landsat consists of 6435 samples of 36 features from 6 different categories. We follow the same train and test split as provided by the dataset. MIT-BIH dataset consists of annotated heartbeat signals from which we used the preprocessed version available online4 consisting of 92062 samples of 5 different arrhythmia classes. Diabetes dataset is a real-world health dataset of 92,062 samples and 45 features from different categories such as questionnaire, demographics, medical examination, and lab results. The objective is to classify between three different diabetes conditions i.e., normal, pre-diabetes, and diabetes. As MIT-BIH and Diabetes datasets do not provide explicit train and test sets, we randomly select $80 \%$ of samples as a training set and the rest as a test set. To preprocess our tabular datasets, statistical and unity based normalization are used to balance the variance of different features and center them around zero. Also, while different encoding and representation methods are suggested in the literature to handle categorical features (Jang et al., 2016; Nazabal et al., 2018), in this paper, we take the simple approach of encoding categorical variables using one-hot representation and smoothing them by adding Gaussian noise with zero mean and variance equal to $5 \%$ of feature variances. In our experiments, we observed a reasonable performance using the suggested simple smoothing; however, more advanced encoding methods are also applicable in this setup and can be applied to enhance the performances even further.
+
+# 4.2 MISSINGNESS MECHANISMS
+
+In our experiments, we consider MCAR uniform and MCAR rectangular missingness structures. In MCAR uniform, each feature of each sample is missing based on a Bernoulli distribution with a certain missingness probability (i.e., missing rate) independent of other features. In addition to the case of uniform missingness, for image tasks, we use rectangular missingness/observation structure where rectangular regions of dataset images are missing/observed. To control the rate of missingness and decide on the regions that are missing for each case, we use a latent beta distribution that samples rectangular region’s width and height such that the average missing rate is maintained. For missing rates less than $50 \%$ we make the assumption of having a random rectangular region to be missing, whereas for missing rates more than $50 \%$ we assume that only a random rectangular region is observed and the rest of the image is missing.
+
+We would like to note that while the suggested solution in this paper is readily compatible with MAR structures, in our experiments, to simplify the presentation of results and to have a fair comparison with other work that does not support the MAR assumption, we limited the scope of our experiments to MCAR. Furthermore, to simulate incomplete datasets and to make sure the same features are missing without explicitly storing masks, we use hashed feature vectors to seed random number generators used to sample missing features. More detail is provided in Appendix C.
+
+# 4.3 EVALUATION MEASURES
+
+Fréchet inception distance (FID) (Heusel et al., 2017) score is used to measure the quality of missing data imputation in experiments with images5. We also considered using root means squared error (RMSE); however, we decided not to use this measure as we observed an inconsistent behavior using RMSE in our comparisons as RMSE favors methods that show less variance rather than realistic and sharp samples from the distribution. Also, for each dataset and each missingness scenario, we report top-1 classification accuracy based on the majority vote estimated using Algorithm 2. Another measure that we use in this paper is the comparison between the estimated target certainties and average accuracies achieved for each confidence assignment. We run each experiment multiple times: 4 times for CIFAR-10 and 8 times for tabular datasets. We report the mean and standard deviation of results for each case.
+
+We compare our results with MisGAN (Li et al., 2019) and GAIN (Yoon et al., 2018) as the state of the art imputation algorithms based on GANs as well as basic denoising autoencoder (DAE) (Vincent et al., 2008) and multiple imputation by chained equations (MICE) (Buuren & Groothuis-Oudshoorn, 2010) as baselines. For experiments using MisGAN, we used the same architectures and hyperparameters as suggested by the MisGAN authors6. The only modification was to adapt the last generator layer to generate images with resolutions as we use. Regarding GAIN, we used the same network architecture as our implementation of GI and hyper-parameters as used by the GAIN authors7. In the DAE implementation, due to the incomplete data assumption, only observed features appear in the loss function, ignoring reconstruction terms corresponding to missing features. Due to scalability issues, we were only able to use MICE for the smaller non-image datasets. For these methods, to train and evaluate classifiers, we use predictors trained on imputed datasets rather than the stochastic predictor suggested in Algorithm 1.
+
+![](images/7dee5514f122f68c96a6de74132a186a9e0266bbd52176e7a7dd6f46d002cb83.jpg)  
+Figure 2: Comparison of FID scores on CIFAR-10 dataset for (a) uniform and (b) rectangular missingness. Lower FID score is better. In many cases, variance values are very small and only observable by magnifying the figures.
+
+# 4.4 RESULTS
+
+Figure 2 presents the comparison of FID scores on the CIFAR-10 dataset at different missing rates for uniform and rectangular missingness. As it can be inferred from these plots, GI outperforms other alternatives in all cases. Also, it can be seen that GAIN is able to provide more reasonable results for uniform missing data structure compared to MisGAN which is mainly effective in the rectangular missing data structure. One possible explanation for this behavior might be the fact that GAIN has an MSE loss term acting similar to an autoencoder loss smoothing noisy missing pixels. On the other hand, MisGAN tries to explicitly model missingness structure and is more successful in capturing a more structured missingness such as the case of a rectangular structure. Table 1 provides a comparison between the top-1 classification accuracy achieved using each method at different missing rates and structures. From this table, GI outperforms other work by achieving the best results in 5 out of 6 cases8.
+
+Table 2 presents a comparison of classification accuracies for Landsat, MIT-BIH, and Diabetes datasets at different missing rates. In the Landsat benchmark, GI outperforms other work in all cases. Regarding the MIT-BIH experiemts, GI outperforms other work for missing rates more than $30 \%$ while achieving similar accuracies to GAIN for lower missing rates. In the diabetes classification task, GI appears to be most effective imputing missing rates more than $20 \%$ .
+
+Figure 3 shows a comparison of accuracy versus certainty plots for GI, MisGAN, and GAIN on Landsat dataset at the missing rate of $40 \%$ . To generate these figures we trained each imputation method and then used Algorithm 1 to train predictors on imputed samples. Finally, Algorithm 2 used to measure the average accuracy at different prediction confidence levels based on a sample of 128 imputations for each test example. As it can be seen from the plots, GI provides results closest to the ideal case of having average confidence values equal to average accuracies.
+
+# 4.5 VISUALIZATION USING SYNTHESIZED DATA
+
+In order to provide further insight into the operation of GI and how imputations can potentially influence the outcomes of predictions, we conduct experiments on a synthesized dataset. The original underlying data distribution is generated by sampling 5000 samples from 4 Gaussians of standard deviation 0.1 centered on the vertices of a unit square. We assign two different classes to each cluster
+
+Table 1: Top-1 CIFAR-10 classification accuracy for different missing rates and structures.   
+
+<table><tr><td rowspan="2"></td><td colspan="5">Accuracy at Missing Rate (%) MCAR Rect.</td><td rowspan="2"></td></tr><tr><td colspan="2">MCARUniform</td><td colspan="3"></td></tr><tr><td>Method</td><td>20%</td><td>40%</td><td>60%</td><td>20%</td><td>40%</td><td>60%</td></tr><tr><td>GI</td><td>89.5 (±0.45)</td><td>87.1 (±0.54)</td><td>80.3 (±0.26)</td><td>84.0 (±0.03)</td><td>76.9 (±0.03)</td><td>66.1 (±0.16)</td></tr><tr><td>MisGAN</td><td>86.5 (±0.31)</td><td>83.7 (±0.40)</td><td>78.7 (±0.26)</td><td>82.9 (±0.44)</td><td>75.6 (±0.20)</td><td>65.0 (±0.31)</td></tr><tr><td>GAIN</td><td>88.7 (±0.45)</td><td>86.0 (±0.86)</td><td>81.8 (±0.03)</td><td>81.7 (±0.03)</td><td>73.6 (±0.35)</td><td>58.4 (±1.66)</td></tr><tr><td>DAE</td><td>88.0 (±0.22)</td><td>84.0 (±0.50)</td><td>79.8 (±0.71)</td><td>83.3 (±0.64)</td><td>75.5 (±0.44)</td><td>63.8 (±0.24)</td></tr><tr><td>Mean</td><td>85.7 (±0.02)</td><td>83.4 (±0.38)</td><td>79.2 (±0.16)</td><td>82.7 (±0.15)</td><td>75.3 (±0.16)</td><td>64.0 (±0.32)</td></tr></table>
+
+Table 2: Comparison of classification accuracies for Landsat, MIT-BIH, and Diabetes datasets at different missing rates.   
+
+<table><tr><td></td><td></td><td colspan="4"> Accuracy at Missing Rate (%)a</td></tr><tr><td>Dataset</td><td>Method</td><td>10%</td><td>20%</td><td>30%</td><td>40%</td></tr><tr><td rowspan="5">Landsat (Dua &amp; Graff, 2017)</td><td>GI</td><td>89.9 (±0.36)</td><td>89.6 (±0.36)</td><td>89.0 (±0.03)</td><td>88.0 (±0.22)</td></tr><tr><td>MisGAN</td><td>87.2 (±0.01)</td><td>85.7 (±0.19)</td><td>84.0 (±0.61)</td><td>82.9 (±0.75)</td></tr><tr><td>GAIN</td><td>89.7 (±0.42)</td><td>89.4 (±0.56)</td><td>88.4 (±0.71)</td><td>87.7 (±0.10)</td></tr><tr><td>DAE</td><td>89.4 (±0.10)</td><td>88.6 (±0.54)</td><td>87.5 (±0.14)</td><td>86.6 (±0.21)</td></tr><tr><td>MICE</td><td>89.5 (±0.16)</td><td>89.3 (±0.10)</td><td>88.1 (±0.49)</td><td>87.5 (±0.03)</td></tr><tr><td rowspan="5">MIT-BIH(Moody &amp; Mark,2001)</td><td>GI</td><td>98.5 (±0.02)</td><td>98.4 (±0.03)</td><td>98.2 (±0.07)</td><td>97.7 (±0.03)</td></tr><tr><td>MisGAN</td><td>97.8 (±0.13)</td><td>97.4 (±0.07)</td><td>96.7 (±0.07)</td><td>96.2 (±0.09)</td></tr><tr><td>GAIN</td><td>98.5 (±0.02)</td><td>98.4 (±0.06)</td><td>98.0 (±0.09)</td><td>97.5 (±0.18)</td></tr><tr><td>DAE</td><td>98.4 (±0.02)</td><td>98.2 (±0.11)</td><td>97.9 (±0.09)</td><td>97.4 (±0.02)</td></tr><tr><td>MICE</td><td>98.4 (±0.01)</td><td>98.3 (±0.01)</td><td>98.1 (±0.01)</td><td>97.5 (±0.12)</td></tr><tr><td rowspan="5">Diabetes (Kachuee et al., 2019)</td><td>GI</td><td>89.6 (±0.13)</td><td>89.0 (±0.03)</td><td>88.2 (±0.62)</td><td>86.8 (±0.38)</td></tr><tr><td>MisGAN</td><td>89.7 (±0.01)</td><td>88.9 (±0.30)</td><td>87.6 (±0.02)</td><td>86.4 (±0.68)</td></tr><tr><td>GAIN</td><td>89.2 (±0.09)</td><td>88.3 (±0.02)</td><td>86.9 (±0.09)</td><td>83.8 (±1.44)</td></tr><tr><td>DAE</td><td>89.3 (±0.05)</td><td>88.2 (±0.19)</td><td>86.9 (±0.09)</td><td>84.8 (±0.03)</td></tr><tr><td>MICE</td><td>89.8 (±0.08)</td><td>88.8 (±0.01)</td><td>88.0 (±0.08)</td><td>86.1 (±0.02)</td></tr></table>
+
+aBaseline accuracies for complete datasets (zero missing rate) are equal to $9 0 . 9 \%$ , $9 8 . 6 \%$ , and $9 0 . 7 \%$ for Landsat, MIT-BIH and Diabetes, respectively.
+
+such that diagonal vertices are of the same class (see Figure 4a, classes are represented with colors).   
+From this underlying distribution, we make an incomplete dataset with $50 \%$ of values missing.
+
+The incomplete synthesized dataset is used to train GI and other imputation methods. We take a random test sample in which the second feature has a value of about 0.1 and the other feature is missing. Ideally, in the imputation phase, we would like to sample from the condition distribution i.e. $P ( x _ { 1 } | x _ { 2 } = 0 . 1 )$ (see Figure 4b). Here, in the prediction phase, an ideal method would decide on not making a confident classification and report the uncertainty. Note that solely observing the value of 0.1 for the second feature does not provide any useful evidence for the prediction. Figure 4c-f provide samples and classification results for GI, MisGAN, GAIN, and DAE. As it can be inferred from these figures, GI generates reasonable samples from the conditional distribution and also reflects this uncertainty over the prediction. On the other hand MisGAN, probably due to its complexity of using three different generators and discriminator pairs, is suffering from mode collapse and is unable to generate samples from the other class, resulting in over-confident assignments. GAIN, perhaps due to the MSE loss terms, is inclined towards the mean of the conditional distribution at the origin.
+
+![](images/99ff87491c12b80a83f83e95b0f6597c20ef1cd8b2470028e19f5844c61fce0b.jpg)  
+Figure 3: Accuracy versus certainty plots for (a) GI, (b) MisGAN, and (c) GAIN on Landsat dataset at the missing rate of $40 \%$ .
+
+DAE, as expected, due to its MSE loss term, only captures the expected value of the distribution mean hence reducing the MSE error and generates over-smoothed imputations.
+
+![](images/efa63b3362bf0eec014da42a29ee10be1a5bc69514aec9b20546466115db1b16.jpg)  
+Figure 4: Evaluation using synthesized data: (a) samples from the underlying distribution, (b) samples from the conditional underlying distribution, (c-f) samples from the conditional distribution generate by GI, MisGAN, GAIN, and DAE.
+
+# 5 CONCLUSION
+
+In this paper, we proposed a novel method to generate imputations and measure uncertainties over target class assignments based on incomplete feature vectors. We evaluated the effectiveness of the suggested approach on image and tabular data via using different measures such as FID distance, classification accuracy, and confidence versus accuracy plots. According to the experiments, the proposed method not only can generate accurate imputations but also is able to model prediction uncertainties arising from missing values. The proposed method is applicable to many real-world applications where only an incomplete dataset is available, and modeling classification uncertainties is a necessity.
+
+# REFERENCES
+
+Theodore W Anderson. Maximum likelihood estimates for a multivariate normal distribution when some observations are missing. Journal of the american Statistical Association, 52(278):200–203, 1957.
+
+Sanjeev Arora, Andrej Risteski, and Yi Zhang. Do gans learn the distribution? some theory and empirics. 2018.
+
+S van Buuren and Karin Groothuis-Oudshoorn. mice: Multivariate imputation by chained equations in r. Journal of statistical software, pp. 1–68, 2010.
+
+Pengfei Chen, Benben Liao, Guangyong Chen, and Shengyu Zhang. Understanding and utilizing deep neural networks trained with noisy labels. arXiv preprint arXiv:1905.05040, 2019.
+
+Adnan Darwiche. Modeling and reasoning with Bayesian networks. Cambridge university press, 2009.
+
+Dheeru Dua and Casey Graff. UCI machine learning repository, 2017. URL http://archive. ics.uci.edu/ml.
+
+Vincent Dumoulin, Ishmael Belghazi, Ben Poole, Olivier Mastropietro, Alex Lamb, Martin Arjovsky, and Aaron Courville. Adversarially learned inference. arXiv preprint arXiv:1606.00704, 2016.
+
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in neural information processing systems, pp. 2672–2680, 2014.
+
+Trevor Hastie, Robert Tibshirani, Gavin Sherlock, Michael Eisen, Patrick Brown, and David Botstein. Imputing missing data for gene expression arrays, 1999.
+
+Martin Heusel, Hubert Ramsauer, Thomas Unterthiner, Bernhard Nessler, and Sepp Hochreiter. Gans trained by a two time-scale update rule converge to a local nash equilibrium. In Advances in Neural Information Processing Systems, pp. 6626–6637, 2017.
+
+Eric Jang, Shixiang Gu, and Ben Poole. Categorical reparameterization with gumbel-softmax. arXiv preprint arXiv:1611.01144, 2016.
+
+Mohammad Kachuee, Kimmo Karkkainen, Orpaz Goldstein, Davina Zamanzadeh, and Majid Sarrafzadeh. Nutrition and health data for cost-sensitive learning. arXiv preprint arXiv:1902.07102, 2019.
+
+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. arXiv preprint arXiv:1312.6114, 2013.
+
+Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. Technical report, Citeseer, 2009.
+
+Steven Cheng-Xian Li, Bo Jiang, and Benjamin Marlin. Learning from incomplete data with generative adversarial networks. In International Conference on Learning Representations, 2019. URL https://openreview.net/forum?id $=$ S1lDV3RcKm.
+
+Roderick JA Little and Donald B Rubin. Statistical analysis with missing data, volume 793. Wiley, 2019.
+
+Shuang Liu, Olivier Bousquet, and Kamalika Chaudhuri. Approximation and convergence properties of generative adversarial learning. In Advances in Neural Information Processing Systems, pp. 5545–5553, 2017.
+
+Pierre-Alexandre Mattei and Jes Frellsen. missiwae: Deep generative modelling and imputation of incomplete data. arXiv preprint arXiv:1812.02633, 2018.
+
+Takeru Miyato, Toshiki Kataoka, Masanori Koyama, and Yuichi Yoshida. Spectral normalization for generative adversarial networks. arXiv preprint arXiv:1802.05957, 2018.
+
+George B Moody and Roger G Mark. The impact of the mit-bih arrhythmia database. IEEE Engineering in Medicine and Biology Magazine, 20(3):45–50, 2001.
+
+Jared S Murray et al. Multiple imputation: a review of practical and theoretical findings. Statistical Science, 33(2):142–159, 2018.
+
+Nagarajan Natarajan, Inderjit S Dhillon, Pradeep K Ravikumar, and Ambuj Tewari. Learning with noisy labels. In Advances in neural information processing systems, pp. 1196–1204, 2013.
+
+Alfredo Nazabal, Pablo M Olmos, Zoubin Ghahramani, and Isabel Valera. Handling incomplete heterogeneous data using vaes. arXiv preprint arXiv:1807.03653, 2018.
+
+Richard E Neapolitan et al. Learning bayesian networks, volume 38. Pearson Prentice Hall Upper Saddle River, NJ, 2004.
+
+Thomas Dyhre Nielsen and Finn Verner Jensen. Bayesian networks and decision graphs. Springer Science & Business Media, 2009.
+
+Scott Reed, Honglak Lee, Dragomir Anguelov, Christian Szegedy, Dumitru Erhan, and Andrew Rabinovich. Training deep neural networks on noisy labels with bootstrapping. arXiv preprint arXiv:1412.6596, 2014.
+
+Donald B Rubin. Inference and missing data. Biometrika, 63(3):581–592, 1976.
+
+Joseph L Schafer and John W Graham. Missing data: our view of the state of the art. Psychological methods, 7(2):147, 2002.
+
+Kihyuk Sohn, Honglak Lee, and Xinchen Yan. Learning structured output representation using deep conditional generative models. In Advances in neural information processing systems, pp. 3483–3491, 2015.
+
+Pascal Vincent, Hugo Larochelle, Yoshua Bengio, and Pierre-Antoine Manzagol. Extracting and composing robust features with denoising autoencoders. In Proceedings of the 25th international conference on Machine learning, pp. 1096–1103. ACM, 2008.
+
+Ting-Chun Wang, Ming-Yu Liu, Jun-Yan Zhu, Andrew Tao, Jan Kautz, and Bryan Catanzaro. Highresolution image synthesis and semantic manipulation with conditional gans. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 8798–8807, 2018.
+
+Jinsung Yoon, James Jordon, and Mihaela Van Der Schaar. Gain: Missing data imputation using generative adversarial nets. arXiv preprint arXiv:1806.02920, 2018.
+
+Han Zhang, Ian Goodfellow, Dimitris Metaxas, and Augustus Odena. Self-attention generative adversarial networks. arXiv preprint arXiv:1805.08318, 2018.
+
+Shichao Zhang, Zhenxing Qin, Charles X Ling, and Shengli Sheng. " missing is useful": missing values in cost-sensitive decision trees. IEEE transactions on knowledge and data engineering, 17 (12):1689–1693, 2005.
+
+# A IMPLEMENTATION AND EXPERIMENTS
+
+Table 3 presents the list of software dependencies and versions used in our implementation. To produce results related to this paper, we used a workstation with 4 NVIDIA GeForce RTX-2080Ti GPUs, a 12 core Intel Core i9-7920X processor, and 128 GB memory. Each experiment took between about 4 hours to 48 hours, based on the task and method being tested.
+
+Table 3: Software dependencies.   
+
+<table><tr><td>Dependency</td><td>Version</td></tr><tr><td>python</td><td>3.7.1</td></tr><tr><td>pytorch</td><td>1.0.0</td></tr><tr><td>cuda100</td><td>1.0</td></tr><tr><td>ipython</td><td>7.2.0</td></tr><tr><td>jupyter</td><td>1.0.0</td></tr><tr><td>numpy</td><td>1.15.4</td></tr><tr><td>pandas</td><td>0.24.1</td></tr><tr><td>scikit-learn</td><td>0.20.1</td></tr><tr><td>scipy</td><td>1.1.0</td></tr><tr><td>torchvision</td><td>0.2.1</td></tr><tr><td>tqdm</td><td>4.28.1</td></tr><tr><td>matplotlib</td><td>3.0.1</td></tr></table>
+
+# B NETWORK ARCHITECTURES
+
+Table 4 shows the exact architectures used in this paper. To show each layer or block we used the following notation. $\mathtt { C x S y P z - t }$ represents a 2-d convolution layer of kernel size $_ \textrm { x }$ , stride y, padding $_ { \textrm { Z } }$ , and number of output channels $\scriptstyle \pm$ followed by ReLU activation. Attn represents a self-attention layer similar to Zhang et al.9. $_ \mathrm { R - x }$ represents a residual block consisting of two 2-d convolutions with kernel size 3 (padding size 1), batch normalization, and ReLU activation. $\mathsf { C T x S y P z - t }$ is the convolution transpose corresponding to $\mathtt { C x S y P z - t }$ . $\operatorname { F C - x }$ is representing a linear fully-connected layer of $_ \textrm { x }$ output neurons with biases. We use spectral normalization as suggested by Miyato et al.10 for all convolutional layers in both generator and discriminator networks.
+
+Table 4: Network architectures used in our experiments.   
+
+<table><tr><td rowspan=1 colspan=1>Dataset</td><td rowspan=1 colspan=1>Generator/Discriminator Architecture</td><td rowspan=1 colspan=1>Predictor Architecture</td></tr><tr><td rowspan=1 colspan=1>CIFAR-10</td><td rowspan=1 colspan=1>C7S1P3-64，C3S2P1-128，Attn，R-128,Attn，R-128，Attn，R-128，Attn,R-128，CT3S2P1-128，CT7S1P3-3，Tanh/Sigmoid</td><td rowspan=1 colspan=1>ResNet-18 11,12</td></tr><tr><td rowspan=1 colspan=1>Landsat</td><td rowspan=1 colspan=1>FC-64，Sigmoid，BNorm，FC-64，Sigmoid,BNorm,FC-64，Sigmoid，BNorm，FC-36，Tanh/Sigmoid</td><td rowspan=1 colspan=1>FC-64，ReLU，BNorm，FC-64,ReLU，BNorm，FC-6，Softmax</td></tr><tr><td rowspan=1 colspan=1>MIT-BIH</td><td rowspan=1 colspan=1>FC-1860，ReLU，BNorm，FC-1860，ReLU，BNorm,FC-1860，ReLU，BNorm, FC-186,Tanh/Sigmoid</td><td rowspan=1 colspan=1>FC-1860，ReLU，BNorm，FC-1860,ReLU，BNorm，FC-5，Softmax</td></tr><tr><td rowspan=1 colspan=1>Diabetes</td><td rowspan=1 colspan=1>FC-45，ReLU，BNorm，FC-45，ReLU，BNorm,FC-45，ReLU，BNorm，FC-45，Tanh/Sigmoid</td><td rowspan=1 colspan=1>FC-22，ReLU，BNorm，FC-22,ReLU，BNorm，FC-3，Softmax</td></tr></table>
+
+# C MISSING DATA MECHANISMS
+
+In this paper, we conduct experiments on two mechanisms for missing values: MCAR uniform and MCAR rectangular. As in our experiments and comparisons, we consider the case where only an incomplete dataset is available for training. It is crucial to guarantee that each method has only access to a unique incomplete version of each sample. However, it is relatively expensive to load and store feature masks for each sample in the dataset. Instead, we generate missing values during the data load for each batch. A hashing mechanism is used to ensure that the same parts are missing for each sample throughout the training. Note that we set system, python, and external library hash seeds to fixed values to ensure the consistency between different runs.
+
+Algorithm 3 presents the procedure used for generating missing values with uniform structure. This algorithm is sampling independent Bernoulli distributions with probabilities equal to the missing rate. Algorithm 4 shows the outline for the rectangular missing structure used in image experiments. It consists of selecting a random point as the center of the rectangle and then deciding on parameters to be used for the beta distribution based on the missing rate. Finally, the width and height of the rectangular region are sampled from the latent beta distribution. In other words, we generate rectangular regions centered at random locations within the image which have width and height values determined by samples from a latent beta distribution. Here, distribution parameters, $\alpha$ and $\beta$ , are used to control the average missing rate. The outcome would be rectangular regions of different shape at different locations within the frame with the expected portion of missing area equal to the missing rate.
+
+In order to decide on the beta distribution parameters i.e. $\alpha$ and $\beta$ we use numerical simulations. Specifically, we fix one of the parameters to 1 and change the other parameter in the range of [1,10], while measuring the average missing rate caused by each case. Figure 5 shows the missing rates caused by different beta distribution parameters. The first half of Figure 5 (missing rates less than about 0.18) corresponds to setting $\beta$ to 1 and changing $\alpha$ values; and the other half fixing $\alpha$ to 1 and changing $\beta$ values. To generate missing rates more than $50 \%$ we invert our masks and limit the observation to the rectangular region while the rest of the image is missing. Note that missing rates indicate the ratio of features that are missing on the average case. As we are using a latent model for sampling width and height for the rectangles, the actual missing ratios for each specific sample differs between samples. See Table 5 for visual examples of different missing rates and missing structures.
+
+# Algorithm 3: MCAR uniform generation.
+
+Input: $_ { \textbf { \em x } }$ (complete feature), $r$ (missing rate) Output: ${ \pmb x } _ { m }$ (incomplete feature) $\begin{array} { r l } & { s e e d _ { x }  h a s h ( \pmb { x } ) } \\ & { \pmb { k }  1 - B e r n o u l l i ( s e e d _ { x } , s h a p e ( x ) , p r o b = r ) } \\ & { \pmb { x } _ { m }  \pmb { k } \odot \pmb { x } + ( 1 - \pmb { k } ) \odot N a N } \end{array}$
+
+# Algorithm 4: MCAR rect. generation.
+
+Input: $_ { \textbf { \em x } }$ (complete feature), $r$ (missing rate)   
+Output: ${ \pmb x } _ { m }$ (incomplete feature)   
+$s e e d _ { x } \gets h a s h ( { \pmb x } )$   
+n $\iota _ { x } , n _ { y } \gets s h a p e ( { \pmb x } )$   
+$( p _ { x } , \bar { p _ { y } } ) \sim ( u n i f o r m ( 0 , n _ { x } ) , u n i f o r m ( 0 , n _ { y } ) )$   
+α, β ← beta_params(r) // beta_params gives $\alpha , \beta$ for each missing rate based on numerical simulations   
+$\begin{array} { r l } & { ( \boldsymbol { w } , h ) \sim ( B e t a ( \alpha , \beta ) \times n _ { x } ) , B e t a ( \alpha , \beta ) \times n _ { y } ) ) } \\ & { \boldsymbol { k }  r e c t \_ m a s k ( p _ { x } , p _ { y } , w , h ) } \\ & { \mathbf { \boldsymbol { x } } _ { m }  \boldsymbol { k } \odot \mathbf { \boldsymbol { x } } + ( 1 - \boldsymbol { k } ) \odot N a N } \end{array}$
+
+![](images/29b1ccc7a90bf84d0c4b18de35c4df32b98f105fff00abdb71b3fde7ca644a3b.jpg)  
+Figure 5: Simulation results for measuring average missing rate given different beta distribution parameters.
+
+![](images/b85dc27446c318885a97542d42c9e6453ece8284078aca51ca167c500d3ddc30.jpg)
+
+# D ABLATION STUDY
+
+Figure 6 presents a comparison between using (GI W/ Atten.) and not using (GI W/O Atten.) self-attention layers before each residual block in the proposed architecture. We report FID scores on CIFAR-10 with rectangular missingness. As it can be inferred from this comparison, using self-attention achieves a consistent improvement over the baseline. We also examined the case of uniform missingness; however, we did not observe any significant improvement for this case. One possible explanation could be the fact that imputing missing data with a uniform structure can be done by processing local regions and does not require attending to different distant regions across the image.
+
+![](images/555f58484ccab468a30f31b8a1a2e7e6951c3a282f1c5c77ff9c483cf318fc49.jpg)  
+Figure 6: Comparison of FID scores achieved with (GI W/ Atten.) and without (GI W/O Atten.) self-attention layers on CIFAR-10 dataset and rectangular missingness. Lower FID score is better.
+
+Figure 7 shows a comparison of classification accuracies for the Landsat dataset achieved using different ensemble sizes $( N )$ . As it can be seen from this figure, higher values of $N$ result in improved accuracies, especially for higher missing rates. Also, it can be observed that for N values more than 64 the difference is negligible.
+
+![](images/12c219ac2d3a48f6cc52d091728437b57a1e9af830f5bd30babc7198f2bac84e.jpg)  
+Figure 7: Comparison of classification accuracies achieved with different ensemble size $( N )$ .
+
+To study the benefits of the suggested stochastic predictor, we conducted experiments comparing GI with its non-stochastic variation $( \mathrm { N } { = } 1 )$ ). Here, the CIFAR-10 dataset with the rectangular missing structure and missing rates from $20 \%$ to as high as $90 \%$ is used. From Table 6 it can be inferred that as the rate of missingness increases, the benefits of the suggested predictor algorithm increase significantly. We hypothesize that at higher rates of missingness, the conditional distribution of missing features becomes multimodal. In such a scenario, the suggested method captures the uncertainties over the target distribution resulting in the predictor to make more reliable class assignments.
+
+Table 6: Comparison of CIFAR-10 accuracies for the stochastic $\mathrm { ( N = 1 2 8 ) }$ ) and the deterministic $\left( \mathrm { N } { = } 1 \right)$ ) predictor under rectangular missingness.   
+
+<table><tr><td></td><td colspan="6">Accuracy at Missing Rate (%)</td></tr><tr><td>Method</td><td>20%</td><td>40%</td><td>60%</td><td>70%</td><td>80%</td><td>90%</td></tr><tr><td>GI (N=128)</td><td>84.0</td><td>76.9</td><td>66.1</td><td>59.1</td><td>46.0</td><td>32.1</td></tr><tr><td>GI (N=1)</td><td>83.6</td><td>75.7</td><td>65.1</td><td>56.7</td><td>42.8</td><td>29.4</td></tr><tr><td>% difference (normalized)</td><td>0.5</td><td>1.6</td><td>1.5</td><td>4.1</td><td>6.9</td><td>8.4</td></tr></table>
+
+# E VISUAL COMPARISON
+
+Table 7 and 8 provide a visual comparison of GI, MisGAN, and GAIN. For each missingness structure, we compare the best two imputation methods based on FID scores in Figure 2 i.e., GI versus MisGAN for rectangular missingness and GI versus GAIN for uniform missingness. From Table 7 it can be seen that GI is more capable in the reconstruction of fine details such as horse legs, car wheels, or plane wings. Regarding the results provided in Table 8, GI imputed samples are generally sharper and more realistic, which is consistent with our hypothesis about the drawbacks of the MSE term in the GAIN objective function.
+
+![](images/61024c4babfabb7e7dd65df430bff40654a51f9e986c3d422c05dfe4e0963228.jpg)
+
+![](images/3958733293402574782f6e1c021c4a754f6dbed20e2753d3f34209f404938a06.jpg)
+
+# F ANALYSIS OF THE RMSE MEASURE
+
+Table 9 presents the comparison of different imputation methods using the RMSE measure on CIFAR-10 for different missing structures and rates. Generally, RMSE values for the uniform missing structure are lower than their rectangular counterparts. It is consistent with our intuition that imputing uniform missingness is most similar to denoising problems where the RMSE measure is frequently used. Additionally, comparing the performance of different imputation methods using the FID measure (Section 4.4) does not demonstrate a clear correlation to results shown in Table 9. Nonetheless, it is well-known that the FID measure is more suited to measuring the performance of generated images from the underlying distribution (Heusel et al., 2017).
+
+Similarly, in Table 10, we provide RMSE values corresponding to experiments on the tabular datasets. Here, GAIN and DAE provide very similar results that are generally better than GI or MisGAN. This signifies our hypothesis that the MSE loss term may skew generated samples toward the mean of the distribution, resulting in better RMSE values but not necessarily higher final classification accuracies (see Table 2).
+
+Table 9: Comparison of imputation RMSE values for CIFAR-10 at different missing structures and rates.   
+
+<table><tr><td></td><td colspan="5">RMSE at Missing Rate (%)</td><td></td></tr><tr><td></td><td colspan="5">MCAR Uniform</td><td>MCAR Rect.</td></tr><tr><td>Method</td><td>20%</td><td>40%</td><td>60%</td><td>20%</td><td>40%</td><td>60%</td></tr><tr><td>GI</td><td>0.026 (±0.003)</td><td>0.057 (±0.008)</td><td>0.090 (±0.006)</td><td>0.097 (±0.02)</td><td>0.148 (±0.001)</td><td>0.660 (±0.010)</td></tr><tr><td>MisGAN</td><td>0.079 (±0.001)</td><td>0.161 (±0.001)</td><td>0.257 (±0.002)</td><td>0.106 (±0.005)</td><td>0.158 (±0.004)</td><td>0.250 (±0.001)</td></tr><tr><td>GAIN</td><td>0.027 (±0.003)</td><td>0.045 (±0.001)</td><td>0.072 (±0.005)</td><td>0.340 (±0.047)</td><td>0.511 (±0.001)</td><td>0.660 (±0.010)</td></tr><tr><td>DAE</td><td>0.036 (±0.001)</td><td>0.075 (±0.002)</td><td>0.121 (±0.005)</td><td>0.116 (±0.007)</td><td>0.160 (±0.001)</td><td>0.233 (±0.029)</td></tr></table>
+
+Table 10: Comparison of imputation RMSE values for Landsat, MIT-BIH, and Diabetes datasets at different missing rates.   
+
+<table><tr><td colspan="2"></td><td colspan="4">RMSE at Missing Rate (%)</td></tr><tr><td>Dataset</td><td>Method</td><td>10%</td><td>20%</td><td>30%</td><td>40%</td></tr><tr><td rowspan="4">Landsat (Dua &amp; Graff,2017)</td><td>GI</td><td>0.040 (±0.005)</td><td>0.067 (±0.007)</td><td>0.076 (±0.020)</td><td>0.136 (±0.002)</td></tr><tr><td>MisGAN</td><td>0.068 (±0.001)</td><td>0.096 (±0.001)</td><td>0.118 (±0.001)</td><td>0.136 (±0.001)</td></tr><tr><td>GAIN</td><td>0.018 (±0.001)</td><td>0.024 (±0.001)</td><td>0.030 (±0.001)</td><td>0.037 (±0.001)</td></tr><tr><td>DAE</td><td>0.020 (±0.001)</td><td>0.031 (±0.001)</td><td>0.041 (±0.001)</td><td>0.052 (±0.001)</td></tr><tr><td rowspan="4">MIT-BIH(Moody &amp; Mark,2001)</td><td>GI</td><td>0.038 (±0.001)</td><td>0.060 (±0.004)</td><td>0.071 (±0.002)</td><td>0.095 (±0.002)</td></tr><tr><td>MisGAN</td><td>0.073 (±0.007)</td><td>0.092 (±0.002)</td><td>0.115 (±0.003)</td><td>0.111 (±0.001)</td></tr><tr><td>GAIN</td><td>0.032 (±0.008)</td><td>0.046 (±0.001)</td><td>0.055 (±0.004)</td><td>0.067 (±0.007)</td></tr><tr><td>DAE</td><td>0.029 (±0.001)</td><td>0.048 (±0.008)</td><td>0.061 (±0.009)</td><td>0.068 (±0.003)</td></tr><tr><td rowspan="4">Diabetes (Kachuee et al., 2019)</td><td>GI</td><td>0.080 (±0.002)</td><td>0.118 (±0.008)</td><td>0.149 (±0.020)</td><td>0.189 (±0.009)</td></tr><tr><td>MisGAN</td><td>0.082 (±0.004)</td><td>0.111 (±0.002)</td><td>0.133 (±0.001)</td><td>0.151 (±0.001)</td></tr><tr><td>GAIN</td><td>0.064 (±0.001)</td><td>0.092 (±0.001)</td><td>0.119 (±0.001)</td><td>0.140 (±0.001)</td></tr><tr><td>DAE</td><td>0.065 (±0.001)</td><td>0.093 (±0.001)</td><td>0.118 (±0.001)</td><td>0.143 (±0.001)</td></tr></table>
+
+# G IMPACT OF TRAINING NOISE
+
+Addition of noise to input vectors often serves as an input augmentation and results in improved generalization accuracies. In order to verify that the improved GI performance is not merely due to the introduction of noise in the suggested architecture, we conducted an experiment by adding different amounts of Gaussian noise during the training process for GAIN and GI. Specifically, we compared how the CIFAR-10 test accuracies change at different degrees of training noise for uniform and rectangular missingess structures at the average missing rate of $40 \%$ .
+
+According to Table 11, adding small amounts of Gaussian noise (e.g., std=0.0125) improves the generalization under uniform missingness for both GI and GAIN. Even in this case, GI is still outperforming GAIN in terms of final classification performance. It is also interesting to point out that for the case of rectangular missingness adding Gaussian noise results in a consistent reduction in the classification accuracy for both methods.
+
+Table 11: Top-1 CIFAR-10 classification accuracy at $40 \%$ missing rate using added training noise.   
+
+<table><tr><td></td><td colspan="2">Accuracy (%)</td></tr><tr><td>Noise STD</td><td>MCAR Uniform (40%) GI GAIN</td><td>MCAR Rect. (40%) GI GAIN</td></tr><tr><td>0.0</td><td>87.1 86.0</td><td>76.9 73.6</td></tr><tr><td>0.0125</td><td>87.3 86.3</td><td>76.8 73.3</td></tr><tr><td>0.025</td><td>86.5 86.6</td><td>76.7 73.2</td></tr><tr><td>0.05</td><td>85.6 84.7</td><td>73.7 72.4</td></tr><tr><td>0.1</td><td>82.0 80.6</td><td>68.7 67.0</td></tr></table>
+
+# H IMPACT OF THE MSE LOSS TERM
+
+In our earlier discussions, we stated that the MSE loss term used in GAIN would bias the distribution of generated samples toward the mean of the distribution. Here, a synthesized dataset is used to illustrate the impact of MSE loss term on the distribution of generated samples. A hyperparameter, $\lambda$ , controls the weight of the MSE term in the final objective function. As it can be observed from Figure 8, the higher the $\lambda$ parameter, the lower the variance of the generated samples (i.e., more bias toward the mean of the distribution).
+
+![](images/e6f566e62f5c08205f49f8240037709b45a8d8f533c27ee98af701aa8fdcd47f.jpg)  
+Figure 8: Comparison of generating samples from a Gaussian distribution (a) samples from the original distribution, (b) samples generated using GAIN imputers with different significance of the MSE term (controlled by $\lambda$ ).
+
+# I IMPACT OF THE DISCRIMINATOR HINT VECTOR
+
+Yoon et al. (2018) suggested the idea of guiding the discriminator network using a hint mechanism. A hint vector reveals a subset of features that are missing to the discriminator. In Figure 9 and 10 we provide a comparison of learning curves for GI implemented using different hint rates. From Figure 9, using the hint mechanism does not result in any noticeable improvement in the final imputation quality justifying the added complexity. For the case of the rectangular missing structure in Figure 10; however, using the hint vector causes instabilities in the training process. One possible explanation is: providing even a small portion of the mask as a hint, due to the deterministic nature of the rectangular shape it is equivalent to providing region boundaries to the discriminator making it obvious for the discriminator. In GAN training we generally want to have equal competition between the generator and discriminator.
+
+![](images/d1773a0973e8e20e8a1e95585cf0570e2f70c7ae32a782150bd1926ef6c94fdd.jpg)  
+Figure 9: Learning curves for CIFAR-10 with uniform missing structure at different discriminator hint rates.
+
+![](images/1d860d6685302d772bd786609a2406e9a1cc659ad5aaf397983d57ed6fba2242.jpg)  
+Figure 10: Learning curves for CIFAR-10 with rectangular missing structure at different discriminator hint rates.

parse/train/Bklfsi0cKm/Bklfsi0cKm.md

@@ -0,0 +1,436 @@
+# DEEP CONVOLUTIONAL NETWORKS AS SHALLOW GAUSSIAN PROCESSES
+
+Adrià Garriga-Alonso department of Engineering University of Cambridge ag919@cam.ac.uk
+
+Laurence Aitchison   
+Department of Engineering   
+University of Cambridge   
+laurence.aitchison@gmail.com
+
+# ABSTRACT
+
+We show that the output of a (residual) convolutional neural network (CNN) with an appropriate prior over the weights and biases is a Gaussian process (GP) in the limit of infinitely many convolutional filters, extending similar results for dense networks. For a CNN, the equivalent kernel can be computed exactly and, unlike “deep kernels”, has very few parameters: only the hyperparameters of the original CNN. Further, we show that this kernel has two properties that allow it to be computed efficiently; the cost of evaluating the kernel for a pair of images is similar to a single forward pass through the original CNN with only one filter per layer. The kernel equivalent to a 32-layer ResNet obtains $0 . 8 4 \%$ classification error on MNIST, a new record for GPs with a comparable number of parameters.
+
+# 1 INTRODUCTION
+
+Convolutional Neural Networks (CNNs) have powerful pattern-recognition capabilities that have recently given dramatic improvements in important tasks such as image classification (Krizhevsky et al., 2012). However, as CNNs are increasingly being applied in real-world, safety-critical domains, their vulnerability to adversarial examples (Szegedy et al., 2013; Kurakin et al., 2016), and their poor uncertainty estimates are becoming increasingly problematic. Bayesian inference is a theoretically principled and demonstrably successful (Snoek et al., 2012; Deisenroth & Rasmussen, 2011) framework for learning in the face of uncertainty, which may also help to address the problems of adversarial examples (Gal & Smith, 2018). Unfortunately, Bayesian inference in CNNs is extremely difficult due to the very large number of parameters, requiring highly approximate factorised variational approximations (Blundell et al., 2015; Gal & Ghahramani, 2015), or requiring the storage (Lakshminarayanan et al., 2017) of large numbers of posterior samples (Welling & Teh, 2011; Mandt et al., 2017).
+
+Other methods such as those based on Gaussian Processes (GPs) are more amenable to Bayesian inference, allowing us to compute the posterior uncertainty exactly (Rasmussen & Williams, 2006). This raises the question of whether it might be possible to combine the pattern-recognition capabilities of CNNs with exact probabilistic computations in GPs. Two such approaches exist in the literature. First, deep convolutional kernels (Wilson et al., 2016) parameterise a GP kernel using the weights and biases of a CNN, which is used to embed the input images into some latent space before computing their similarity. The CNN parameters of the resulting kernel then have to be optimised by gradient descent. However, the large number of kernel parameters in the CNN reintroduces the risk of overconfidence and overfitting. To avoid this risk, we need to infer a posterior over the CNN kernel parameters, which is as difficult as directly inferring a posterior over the parameters of the original CNN. Second, it is possible to define a convolutional GP (van der Wilk et al., 2017) or a deep convolutional GP (Kumar et al., 2018) by defining a GP that takes an image patch as input, and using that GP as a component in a larger CNN-like system. However, inference in such systems is very computationally expensive, at least without the use of potentially severe variational approximations (van der Wilk et al., 2017).
+
+An alternative approach is suggested by the underlying connection between Bayesian neural networks (NNs) and GPs. In particular, Neal (1996) showed that the function defined by a single-layer fully-connected NN with infinitely many hidden units, and random independent zero-mean weights and biases is equivalent to a GP, implying that we can do exact Bayesian inference in such a NN by working with the equivalent GP. Recently, this result was extended to arbitrarily deep fullyconnected NNs with infinitely many hidden units at each layer (Lee et al., 2017; Matthews et al., 2018a). However, these fully-connected networks are rarely used in practice, as they are unable to exploit important properties of images such as translational invariance, raising the question of whether state-of-the-art architectures such as CNNs (LeCun et al., 1990) and ResNets (He et al., 2016a) have equivalent GP representations. Here, we answer in the affirmative, giving the GP kernel corresponding to arbitrarily deep CNNs and to (convolutional) residual neural networks (He et al., 2016a). In this case, if each hidden layer has an infinite number of convolutional filters, the network prior is equivalent to a GP.
+
+Furthermore, we show that two properties of the GP kernel induced by a CNN allow it to be computed very efficiently. First, in previous work it was necessary to compute the covariance matrix for the output of a single convolutional filter applied at all possible locations within a single image (van der Wilk et al., 2017), which was prohibitively computationally expensive. In contrast, under our prior, the downstream weights are independent with zero-mean, which decorrelates the contribution from each location, and implies that it is necessary only to track the patch variances, and not their covariances. Second, while it is still necessary to compute the variance of the output of a convolutional filter applied at all locations within the image, the specific structure of the kernel induced by the CNN means that the variance at every location can be computed simultaneously and efficiently as a convolution.
+
+Finally, we empirically demonstrate the performance increase coming from adding translationinvariant structure to the GP prior. Without computing any gradients, and without augmenting the training set (e.g. using translations), we obtain $0 . 8 4 \%$ error rate on the MNIST classification benchmark, setting a new record for nonparametric GP-based methods.
+
+# 2 GP BEHAVIOUR IN A CNN
+
+For clarity of exposition, we will treat the case of a 2D convolutional NN. The result applies straightforwardly to $n \mathbf { D }$ convolutions, dilated convolutions and upconvolutions (“deconvolutions”), since they can be represented as linear transformations with tied coefficients (see Fig. 1).
+
+# 2.1 A 2D CONVOLUTIONAL NETWORK PRIOR
+
+The network takes an arbitrary input image $\mathbf { X }$ of height $H ^ { ( 0 ) }$ and width $D ^ { ( 0 ) }$ , as a $C ^ { ( 0 ) } \times ( H ^ { ( 0 ) } D ^ { ( 0 ) } )$ real matrix. Each row, which we denote $\mathbf { x } _ { 1 } , \mathbf { x } _ { 2 } , \ldots , \mathbf { x } _ { C ^ { ( 0 ) } }$ , corresponds to a channel of the image (e.g. $C ^ { ( 0 ) } = 3$ for RGB), flattened to form a vector. The first activations $\mathbf { A } ^ { ( 1 ) } ( \mathbf { X } )$ are a linear transformation of the inputs. For $i \in \{ 1 , \ldots , C ^ { ( 1 ) } \}$ :
+
+$$
+\mathbf { a } _ { i } ^ { ( 1 ) } ( \mathbf { X } ) : = b _ { i } ^ { ( 1 ) } \mathbf { 1 } + \sum _ { j = 1 } ^ { C ^ { ( 0 ) } } \mathbf { W } _ { i , j } ^ { ( 1 ) } \mathbf { x } _ { j } \ .
+$$
+
+We consider a network with $L$ hidden layers. The other activations of the network, from $\mathbf { A } ^ { ( 2 ) } ( \mathbf { X } )$ up to $\mathbf { A } ^ { ( L + 1 ) } ( \mathbf { X } )$ , are defined recursively:
+
+$$
+\mathbf { a } _ { i } ^ { ( \ell + 1 ) } ( \mathbf { X } ) : = b _ { i } ^ { ( \ell + 1 ) } \mathbf { 1 } + \sum _ { j = 1 } ^ { C ^ { ( \ell ) } } \mathbf { W } _ { i , j } ^ { ( \ell + 1 ) } \phi \left( \mathbf { a } _ { j } ^ { ( \ell ) } ( \mathbf { X } ) \right) .
+$$
+
+![](images/b76e3f5dce59ce270069488ab3ea5f08d6e69a5c74ce89a25358ac556f83a901.jpg)  
+Figure 1: The 2D convolution U(i, $\mathbf { U } _ { i , j } ^ { ( 0 ) } * \mathbf { x } _ { j }$ 0)j ∗ xj as the dot product W(0)i,j xj . The blank elements of W(0)i,j are zeros. The µth row of W(0)i,j corresponds to applying the filter to the $\mu$ th convolutional patch of the channel $\mathbf { x } _ { j }$ .
+
+The activations $\mathbf { A } ^ { ( \ell ) } ( \mathbf { X } )$ are $C ^ { ( \ell ) } \times ( H ^ { ( \ell ) } D ^ { ( \ell ) } )$ matrices. Each row $\mathbf { a } _ { i } ^ { ( \ell + 1 ) }$ represents the flattened $j$ th channel of the image that results from applying a convolutional filter to $\phi ( \mathbf { A } ^ { ( \ell ) } ( \mathbf { X } ) )$ .
+
+and The structure of the pseudo-weight matrices W(\`+1)i,j , depends on the archite and biases or a convolu $b _ { i } ^ { ( \ell + 1 ) }$ , for layer, $i \in \{ 1 , \ldots , C ^ { ( \ell + 1 ) } \}$ $j \in \{ 1 , \ldots , C ^ { ( \ell ) } \}$ $\mathbf { W } _ { i , j } ^ { ( \ell + 1 ) }$ xj represents applying the convolutional filter U(\`+1)i,j to the $j$ th channel. Thus, the elements of each row of where it do W(\`+1) are: 0 where the filter does not apply and the corresponding element of strated in Fig. 1. $\mathbf { U } _ { i , j } ^ { ( \ell + 1 ) }$
+
+The outputs of the network are the last activations, $\mathbf { A } ^ { ( L + 1 ) } ( \mathbf { X } )$ . In the classification or regression setting, the outputs are not spatially extended, so we have $H ^ { ( L + 1 ) } = D ^ { ( L + 1 ) } = 1$ , which is equivalent to a fully-connected output layer. In this case, the pseudo-weights W(L+1)i,j only have one row, and the activations $\mathbf { a } _ { i } ^ { ( L + 1 ) }$ are single-element vectors.
+
+Finally, we define the prior distribution over functions by making the filters $\mathbf { U } _ { i , j } ^ { ( \ell ) }$ and biases $b _ { i } ^ { ( \ell ) }$ be independent Gaussian random variables (RVs). For each layer $\ell$ , channels $i , j$ and locations within the filter $x , y$ :
+
+$$
+U _ { i , j , x , y } ^ { ( \ell ) } \sim \mathcal { N } \left( 0 , \sigma _ { w } ^ { 2 } / C ^ { ( \ell ) } \right) , \qquad b _ { i } ^ { ( \ell ) } \sim \mathcal { N } \left( 0 , \sigma _ { b } ^ { 2 } \right) .
+$$
+
+Note that, to keep the activation variance constant, the weight variance is divided by the number of input channels. The weight variance can also be divided by the number of elements of the filter, which makes it equivalent to the NN weight initialisation scheme introduced by He et al. (2016a).
+
+# 2.2 ARGUMENT FOR GP BEHAVIOUR
+
+We follow the proofs by Lee et al. (2017) and Matthews et al. (2018a) to show that the output of the CNN described in the previous section, $\mathbf { A } ^ { ( L + 1 ) }$ , defines a GP indexed by the inputs, $\mathbf { X }$ . Their proof (Lee et al., 2017) proceeds by applying the multivariate Central Limit Theorem (CLT) to each layer in sequence, i.e. taking the limit as $N ^ { ( 1 ) }  \infty$ , then $N ^ { ( 2 ) }  \infty$ etc, where $N ^ { ( \ell ) }$ is the number of hidden units in layer $\ell$ . By analogy, we sequentially apply the multivariate CLT by taking the limit as the number of channels goes to infinity, i.e. $\dot { C ^ { ( 1 ) } } \stackrel { - } {  } \infty$ , then $C ^ { ( 2 ) }  \infty$ etc. While this is the simplest approach to taking the limits, other potentially more realistic approaches also exist (Matthews et al., 2018a).
+
+The fundamental quantity we consider is a vector formed by concatenating the feature maps (or equivalently channels), ${ \bf a } _ { j } ^ { ( \ell ) } ( { \bf X } )$ and $\mathbf { a } _ { j } ^ { ( \ell ) } ( \mathbf { X } ^ { \prime } )$ from data points $\mathbf { X }$ and $\mathbf { X } ^ { \prime }$ ,
+
+$$
+\begin{array} { r } { { \bf a } _ { i } ^ { ( \ell ) } ( { \bf X } , { \bf X } ^ { \prime } ) = \left( { \bf a } _ { i } ^ { ( \ell ) } ( { \bf X } ) \right) . } \end{array}
+$$
+
+This quantity (and the following arguments) can all be extended to the case of countably finite numbers of input points.
+
+Induction base case. For any pair of data points, $\mathbf { X }$ and $\mathbf { X } ^ { \prime }$ the feature-maps corresponding to the $j$ th channel, $\mathbf { a } _ { j } ^ { ( 1 ) } ( \mathbf { X } , \mathbf { X } ^ { \prime } )$ have a multivariate Gaussian joint distribution. This is because each element is a linear combination of shared Gaussian random variables: the biases, ${ \bf b } _ { j } ^ { ( 0 ) }$ and the filters, $\mathbf { U } _ { j , : } ^ { ( 0 ) }$ . Following Eq. (1),
+
+$$
+\mathbf { a } _ { i } ^ { ( 1 ) } ( \mathbf { X } , \mathbf { X } ^ { \prime } ) = b _ { i } ^ { ( 1 ) } \mathbf { 1 } + \sum _ { i = 1 } ^ { C ^ { ( 0 ) } } \left( \begin{array} { c c } { \mathbf { W } _ { i , j } ^ { ( 1 ) } } & { \mathbf { 0 } } \\ { \mathbf { 0 } } & { \mathbf { W } _ { i , j } ^ { ( 1 ) } } \end{array} \right) \left( \begin{array} { c } { \mathbf { x } _ { i } } \\ { \mathbf { x } _ { i } ^ { \prime } } \end{array} \right) ,
+$$
+
+where 1 is a vector of all-ones. While the elements within a feature map display strong correlations, different feature maps are independent and identically distributed (iid) conditioned on the data (i.e. $\mathbf { a } _ { i } ^ { ( 1 ) } ( \mathbf { X } , \mathbf { X } ^ { \prime } )$ and $\mathbf { a } _ { i ^ { \prime } } ^ { ( \mathrm { i } ) } ( \mathbf { X } , \mathbf { X ^ { \prime } } )$ are iid for $i \neq i ^ { \prime }$ ), because the parameters for different feature-maps (i.e. the biases, $b _ { i } ^ { ( 1 ) }$ and the filters, $\mathbf { W } _ { i , : } ^ { ( 1 ) }$ ) are themselves iid.
+
+Induction step. Consider the feature maps at the \`th layer, $\mathbf { a } _ { j } ^ { ( \ell ) } ( \mathbf { X } , \mathbf { X } ^ { \prime } )$ , to be iid multivariate Gaussian RVs (i.e. for $j \neq j ^ { \prime }$ , $\mathbf { a } _ { j } ^ { ( \ell ) } ( \mathbf { X } , \mathbf { X } ^ { \prime } )$ and $\mathbf { a } _ { j ^ { \prime } } ^ { ( \ell ) } ( \mathbf { X } , \mathbf { X } ^ { \prime } )$ are iid). Our goal is to show that, taking the number of channels at layer $\ell$ to infinity (i.e. $C ^ { ( \ell ) } \to \infty ^ { \cdot }$ ), the same properties hold at the next layer (i.e. all feature maps, a(\`+1)i (X, X0), are iid multivariate Gaussian RVs). Writing eq. (2) for two training examples, $\mathbf { X }$ and $\mathbf { X } ^ { \prime }$ , we obtain,
+
+$$
+\mathbf { a } _ { i } ^ { ( \ell + 1 ) } ( \mathbf { X } , \mathbf { X } ^ { \prime } ) = b _ { i } ^ { ( \ell + 1 ) } \mathbf { 1 } + \sum _ { j = 1 } ^ { C ^ { ( \ell ) } } \left( \begin{array} { c c } { \mathbf { W } _ { i , j } ^ { ( \ell + 1 ) } } & { \mathbf { 0 } } \\ { \mathbf { 0 } } & { \mathbf { W } _ { i , j } ^ { ( \ell + 1 ) } } \end{array} \right) \phi ( \mathbf { a } _ { j } ^ { ( \ell ) } ( \mathbf { X } , \mathbf { X } ^ { \prime } ) )
+$$
+
+We begin by showing that $\mathbf { a } _ { i } ^ { ( \ell + 1 ) } ( \mathbf { X } , \mathbf { X } ^ { \prime } )$ is a multivariate Gaussian RV. The first term is multivariate Gaussian, as it is a linear function of $b _ { i } ^ { ( \ell + 1 ) }$ , which is itself iid Gaussian. We can apply the multivariate CLT to show that the second term is also Gaussian, because, in the limit as $C ^ { ( \ell ) } \to \infty$ , it is the sum of infinitely many iid terms: $\mathbf { a } _ { j } ^ { ( \ell ) } ( \mathbf { X } , \mathbf { X } ^ { \prime } )$ are iid by assumption, and $\mathbf { W } _ { i , j } ^ { ( \ell + 1 ) }$ are iid by definition. Note that the same argument applies to all feature maps jointly, so all elements of $\mathbf { A } ^ { ( \ell + 1 ) } ( \mathbf { X } , \mathbf { X } ^ { \prime } )$ (defined by analogy with eq. 4) are jointly multivariate Gaussian.
+
+Following Lee et al. (2017), to complete the argument, we need to show that the output feature maps are iid, i.e. $\mathbf { a } _ { i } ^ { ( \ell + 1 ) } ( \mathbf { X } , \mathbf { X } ^ { \prime } )$ )(X, X0) and a(\`i0 $\mathbf { a } _ { i ^ { \prime } } ^ { ( \ell + 1 ) } ( \mathbf { X } , \mathbf { X } ^ { \prime } )$ are iid for $i \neq i ^ { \prime }$ . They are identically distributed, re as b(\`+1) a nd r tha $\mathbf { W } _ { i , j } ^ { ( \ell + 1 ) }$ and  and $\phi ( \mathbf { a } _ { j } ^ { ( \ell ) } ( \mathbf { X } , \mathbf { X } ^ { \prime } ) )$ is shared. To show that they are independent,are jointly Gaussian, so it is sufficient to show $\mathbf { a } _ { i } ^ { ( \ell + 1 ) } ( \mathbf { X } , \mathbf { X } ^ { \prime } )$ $\mathbf { a } _ { i ^ { \prime } } ^ { ( \ell + 1 ) } ( \mathbf { X } , \mathbf { X } ^ { \prime } )$   
+that they are uncorrelated, and we can show that they are uncorrelated because the weights, $\mathbf { W } _ { i , j } ^ { ( \ell + 1 ) }$ are independent with zero-mean, eliminating any correlations that might arise through the shared RV, $\phi ( \mathbf { a } _ { j } ^ { ( \ell ) } ( \mathbf { X } , \mathbf { X } ^ { \prime } ) )$ . In the appendix, we consider the more complex case where we take limits simultaneously.
+
+# 3 THE CONVNET AND RESNET KERNELS
+
+Here we derive a computationally efficient kernel corresponding to the CNN described in the previous section. It is surprising that we can compute the kernel efficiently because the feature maps, ${ \bf a } _ { i } ^ { ( \ell ) } ( { \bf X } )$ , display rich covariance structure due to the shared convolutional filter. Computing and representing these covariances would be prohibitively computationally expensive. However, in many cases we only need the variance of the output, e.g. in the case of classification or regression with a final dense layer. It turns out that this propagates backwards through the convolutional network, implying that for every layer, we only need the “diagonal covariance” of the activations: the covariance between the corresponding elements of ${ \bf a } _ { j } ^ { ( \ell ) } ( { \bf X } )$ and $\mathbf { a } _ { j } ^ { ( \ell ) } ( \mathbf { X } ^ { \prime } )$ (i.e. $\mathrm { d i a g } \left( \mathbb { C } \left[ \mathbf { a } _ { j } ^ { ( \ell ) } ( \mathbf { X } ) , \mathbf { a } _ { j } ^ { ( \ell ) } ( \mathbf { X } ^ { \prime } ) \right] \right) )$ .
+
+# 3.1 GP MEAN AND COVARIANCE
+
+A GP is completely specified by its mean and covariance (kernel) functions. These give the parameters of the joint Gaussian distribution of the RVs indexed by any two inputs, $\mathbf { X }$ and $\mathbf { X } ^ { \prime }$ . For the purposes of computing the mean and covariance, it is easiest to consider the network as being written entirely in index notation,
+
+$$
+A _ { i , \mu } ^ { ( \ell + 1 ) } ( \mathbf { X } ) = b _ { i } ^ { ( \ell + 1 ) } + \sum _ { j = 1 } ^ { C ^ { ( \ell ) } } \sum _ { \nu = 1 } ^ { H ^ { ( \ell ) } D ^ { ( \ell ) } } W _ { i , j , \mu , \nu } ^ { ( \ell + 1 ) } \phi ( A _ { j , \nu } ^ { ( \ell ) } ( \mathbf { X } ) ) .
+$$
+
+where $\ell$ and $\ell + 1$ denote the input and output layers respectively, $j$ and $i \in \{ 1 , \ldots , C ^ { ( \ell + 1 ) } \}$ denote the input and output channels, and $\nu$ and $\mu \in \{ 1 , \ldots , H ^ { ( \ell + 1 ) } D ^ { ( \ell + 1 ) } \}$ denote the location within the input and output channel or feature-maps.
+
+The mean function is thus easy to compute
+
+$$
+\mathbb { E } \left[ A _ { i , \mu } ^ { ( \ell + 1 ) } ( \mathbf { X } ) \right] = \mathbb { E } \left[ b _ { i } ^ { ( \ell + 1 ) } \right] + \sum _ { j = 1 } ^ { C ^ { ( \ell ) } } \sum _ { \nu = 1 } ^ { H ^ { ( \ell ) } D ^ { ( \ell ) } } \mathbb { E } \left[ W _ { i , j , \mu , \nu } ^ { ( \ell + 1 ) } \phi ( A _ { j , \nu } ^ { ( \ell ) } ( \mathbf { X } ) ) \right] = 0 .
+$$
+
+as b(\`+1)i a nd W (\`+1)i,j,µ,ν have zero mean, and W (\`+1)i,j,ν,µ are independent of the activations at the previous layer, $\phi ( A _ { j , \nu } ^ { ( \ell ) } ( \mathbf { X } ) )$ .
+
+Now we show that it is possible to efficiently compute the covariance function. This is surprising because for many networks, we nlocations in the feature map (i.e. $\mathbb { C } \left[ A _ { i , \mu } ^ { ( \ell + 1 ) } ( \mathbf { \bar { X } } ) , A _ { i , \mu ^ { \prime } } ^ { ( \ell + 1 ) } ( \mathbf { X } ^ { \prime } ) \right]$ ce ofor $\mu , \mu ^ { \prime } \in \{ 1 , \ldots , H ^ { ( \ell + 1 ) } D ^ { ( \ell + 1 ) } \} )$ and this object is extremely high-dimensional, $N ^ { 2 } ( H ^ { ( \ell + 1 ) } D ^ { \overline { { ( \ell + 1 ) } } } ) ^ { 2 }$ . However, it turns out that we only need to consider the “diagonal” covariance, (i.e. we only need $\mathbb { C } \left[ A _ { i , \mu } ^ { ( \ell + 1 ) } ( \mathbf { X } ) , A _ { i , \mu } ^ { ( \ell + 1 ) } ( \mathbf { X } ^ { \prime } ) \right]$ fo r $\mu \in \{ 1 , \ldots , H ^ { ( \ell + 1 ) } D ^ { ( \ell + 1 ) } \} )$ , which is a more manageable quantity of size $N ^ { 2 } ( H ^ { ( \ell + 1 ) } D ^ { ( \ell + 1 ) } )$ .
+
+This is true at the output layer $( L + 1 )$ : in order to achieve an output suitable for classification or regression, we use only a single output location $H ^ { ( L + 1 ) } = D ^ { ( L + 1 ) } = 1$ , with a number of “channels” equal to the number of of outputs/classes, so it is only possible to compute the covariance at that single location. We now show that, if we only need the covariance at corresponding locations in the outputs, we only need the covariance at corresponding locations in the inputs, and this requirement propagates backwards through the network.
+
+Formally, as the activations are composed of a sum of terms, their covariance is the sum of the covariances of all those underlying terms,
+
+$$
+\begin{array} { r l } { \mathbb { C } \left[ A _ { i , \mu } ^ { ( \ell + 1 ) } ( \mathbf { X } ) , A _ { i , \mu } ^ { ( \ell + 1 ) } ( \mathbf { X } ^ { \prime } ) \right] = \mathbb { V } \left[ b _ { i } ^ { ( \ell ) } \right] + } & { } \\ { \displaystyle \sum _ { j = 1 } ^ { C ^ { ( \ell ) } } \sum _ { j ^ { \prime } = 1 } ^ { C ^ { ( \ell ) } } \sum _ { \nu = 1 } ^ { H ^ { ( \ell ) } D ^ { ( \ell ) } } \sum _ { \nu ^ { \prime } = 1 } ^ { H ^ { ( \ell ) } D ^ { ( \ell ) } } \mathbb { C } \left[ W _ { i , j , \mu , \nu } ^ { ( \ell + 1 ) } \phi ( A _ { j , \nu } ^ { ( \ell ) } ( \mathbf { X } ) ) , W _ { i , j ^ { \prime } , \mu , \nu ^ { \prime } } ^ { ( \ell + 1 ) } \phi ( A _ { j ^ { \prime } , \nu ^ { \prime } } ^ { ( \ell ) } ( \mathbf { X } ^ { \prime } ) ) \right] . } \end{array}
+$$
+
+As the terms in the covariance have mean zero, and as the weights and activations from the previous layer are independent,
+
+$$
+\begin{array} { r l } { \mathbb { C } \left[ A _ { i , \mu } ^ { ( \ell + 1 ) } ( \mathbf { X } ) , A _ { i , \mu } ^ { ( \ell + 1 ) } ( \mathbf { X } ^ { \prime } ) \right] = \sigma _ { \mathrm { b } } ^ { 2 } + } & { } \\ { \quad } & { \qquad \sum _ { j = 1 } ^ { { \ell ^ { ( \ell ) } } } \displaystyle \sum _ { j ^ { \prime } = 1 } ^ { { \ell ^ { ( \ell ) } } } \sum _ { \nu = 1 } ^ { { H ^ { ( \ell ) } } D ^ { ( \ell ) } } \sum _ { \nu ^ { \prime } = 1 } ^ { H ^ { ( \ell ) } D ^ { ( \ell ) } } \mathbb { E } \left[ W _ { i , j , \mu , \nu } ^ { ( \ell + 1 ) } W _ { i , j ^ { \prime } , \mu , \nu ^ { \prime } } ^ { ( \ell + 1 ) } \right] \mathbb { E } \left[ \phi ( A _ { j , \nu } ^ { ( \ell ) } ( \mathbf { X } ) ) \phi ( A _ { j ^ { \prime } , \nu ^ { \prime } } ^ { ( \ell ) } ( \mathbf { X } ^ { \prime } ) ) \right] . } \end{array}
+$$
+
+# Algorithm 1 The ConvNet kernel $k ( \mathbf { X } , \mathbf { X } ^ { \prime } )$
+
+1: Input: two images, X, X0 ∈ RC(0)×(H(0)W (0)).   
+2: Compute $K _ { \mu } ^ { ( 1 ) } ( { \bf X } , { \bf X } )$ , $K _ { \mu } ^ { ( 1 ) } ( { \bf X } , { \bf X ^ { \prime } } )$ , and $K _ { \mu } ^ { ( 1 ) } ( \mathbf { X } ^ { \prime } , \mathbf { X } ^ { \prime } )$ for $\mu \in \{ 1 , \ldots , H ^ { ( 1 ) } D ^ { ( 1 ) } \}$ ; using Eq. (10).   
+3: for $\ell = 1 , 2 , \dots , L$ do   
+4: Compute $V _ { \mu } ^ { ( \ell ) } ( { \bf X } , { \bf X ^ { \prime } } )$ , $V _ { \mu } ^ { ( \ell ) } ( { \bf X } , { \bf X ^ { \prime } } )$ and $V _ { \mu } ^ { ( \ell ) } ( { \bf X } , { \bf X ^ { \prime } } )$ for $\mu \in \{ 1 , \ldots , H ^ { ( \ell ) } D ^ { ( \ell ) } \}$ ; using   
+5: Compute Eq. (13), or some other nonlinearity. $K _ { \mu } ^ { ( \ell + 1 ) } ( { \mathbf { X } } , { \mathbf { X } } )$ , $K _ { \mu } ^ { ( \ell + 1 ) } ( { \bf X } , { \bf X ^ { \prime } } )$ , and $K _ { \mu } ^ { ( \ell + 1 ) } ( { \mathbf { X } } ^ { \prime } , { \mathbf { X } } ^ { \prime } )$ for $\mu$ ∈ $\{ 1 , \ldots , H ^ { ( \ell + 1 ) } D ^ { ( \ell + 1 ) } \}$ ; using Eq. (11).
+
+6: end for   
+7: Output the scalar $K _ { 1 } ^ { ( L + 1 ) } ( { \bf X } , { \bf X ^ { \prime } } )$ .
+
+nt ffor ent channels: Further, each $\mathbf { W } _ { i , j } ^ { ( \ell + 1 ) }$ and of the $\mathbf { W } _ { i , j ^ { \prime } } ^ { ( \ell + 1 ) }$ are iid f matrices $j \neq j ^ { \prime }$ , sonly contains independent variables or zeros (Fig. 1), so $\mathbb { E } \left[ W _ { i , j , \mu , \nu } ^ { ( \ell + 1 ) } W _ { i , j ^ { \prime } , \mu , \nu ^ { \prime } } ^ { ( \ell + 1 ) } \right] = 0$ $j \neq j ^ { \prime }$ $\mathbb { E } \left[ W _ { i , j , \mu , \nu } ^ { ( \ell + 1 ) } W _ { i , j ^ { \prime } , \mu , \nu ^ { \prime } } ^ { ( \ell + 1 ) } \right] = 0$ $\mu$ for $\nu \neq \nu ^ { \prime }$ $\mathbf { W } _ { i , j } ^ { ( \ell + 1 ) }$ . Thus, we can eliminate the sums over $j ^ { \prime }$ and $\nu ^ { \prime }$ :
+
+$$
+\Sigma \left[ A _ { i , \mu } ^ { ( \ell + 1 ) } ( \mathbf { X } ) , A _ { i , \mu } ^ { ( \ell + 1 ) } ( \mathbf { X ^ { \prime } } ) \right] = \sigma _ { \mathrm { b } } ^ { ( \ell ) } + \sum _ { j = 1 } ^ { Q ^ { ( \ell ) } } \sum _ { \nu = 1 } ^ { H ^ { ( \ell ) } D ^ { ( \ell ) } } \mathbb { E } \left[ W _ { i , j , \mu , \nu } ^ { ( \ell + 1 ) } W _ { i , j , \mu , \nu } ^ { ( \ell + 1 ) } \right] \mathbb { E } \left[ \phi ( A _ { j , \nu } ^ { ( \ell ) } ( \mathbf { X } ) ) \phi ( A _ { j , \nu } ^ { ( \ell ) } ( \mathbf { X ^ { \prime } } ) ) \right] .
+$$
+
+The µth row of W(\`+1)i,j i s zero for indices $\nu$ that do not belong to its convolutional patch, so we can restrict the sum over $\nu$ to that region. We also define $v _ { g } ^ { ( 1 ) } ( \mathbf { X } , \mathbf { X } ^ { \prime } )$ , to emphasise that the covariances are independent of the output channel, $j$ . The variance of the first layer is
+
+$$
+K _ { \mu } ^ { ( 1 ) } ( \mathbf { X } , \mathbf { X ^ { \prime } } ) = \mathbb { C } \left[ A _ { i , \mu } ^ { ( 1 ) } ( \mathbf { X } ) , A _ { i , \mu } ^ { ( 1 ) } ( \mathbf { X ^ { \prime } } ) \right] = \sigma _ { \mathrm { b } } ^ { 2 } + \frac { \sigma _ { \mathrm { w } } ^ { 2 } } { C ^ { ( 0 ) } } \sum _ { i = 1 } ^ { C ^ { ( 0 ) } } \sum _ { \nu \in \mu \mathrm { t h } \mathrm { p a t c h } } X _ { i , \nu } X _ { i , \nu } ^ { \prime } .
+$$
+
+And we do the same for the other layers,
+
+$$
+K _ { \mu } ^ { ( \ell + 1 ) } ( \mathbf { X } , \mathbf { X } ^ { \prime } ) = \mathbb { C } \left[ A _ { i , \mu } ^ { ( \ell + 1 ) } ( \mathbf { X } ) , A _ { i , \mu } ^ { ( \ell + 1 ) } ( \mathbf { X } ^ { \prime } ) \right] = \sigma _ { \mathrm { b } } ^ { 2 } + \sigma _ { \mathrm { w } } ^ { 2 } \sum _ { \nu \in \mu \mathrm { t h p a t c h } } V _ { \nu } ^ { ( \ell ) } ( \mathbf { X } , \mathbf { X } ^ { \prime } ) ,
+$$
+
+where
+
+$$
+V _ { \nu } ^ { ( \ell ) } ( \mathbf { X } , \mathbf { X } ^ { \prime } ) = \mathbb { E } \left[ \phi ( A _ { j , \nu } ^ { ( \ell ) } ( \mathbf { X } ) ) \phi ( A _ { j , \nu } ^ { ( \ell ) } ( \mathbf { X } ^ { \prime } ) ) \right]
+$$
+
+is the covariance of the activations, which is again independent of the channel.
+
+# 3.2 COVARIANCE OF THE ACTIVITIES
+
+The elementwise covariance in the right-hand side of Eq. (11) can be computed in closed form for many choices of $\phi$ if the activations are Gaussian. For each element of the activations, one needs to keep track of the 3 distinct entries of the bivariate covariance matrix between the inputs, $K _ { \mu } ^ { ( \ell + 1 ) } ( { \mathbf { X } } , { \mathbf { X } } ) , K _ { \mu } ^ { ( \ell + 1 ) } ( { \mathbf { X } } , { \mathbf { X } } ^ { \prime } )$ and $K _ { \mu } ^ { ( \ell + 1 ) } ( { \mathbf { X } } ^ { \prime } , { \mathbf { X } } ^ { \prime } )$ .
+
+For example, for the ReLU nonlinearity $( \phi ( x ) = \operatorname* { m a x } ( 0 , x ) )$ , one can adapt Cho & Saul (2009) in the same way as Matthews et al. (2018a, section 3) to obtain
+
+$$
+V _ { \nu } ^ { ( \ell ) } ( { \mathbf { X } } , { \mathbf { X ^ { \prime } } } ) = \frac { \sqrt { K _ { \nu } ^ { ( \ell ) } ( { \mathbf { X } } , { \mathbf { X } } ) K _ { \nu } ^ { ( \ell ) } ( { \mathbf { X ^ { \prime } } } , { \mathbf { X ^ { \prime } } } ) } } { \pi } \left( \sin \theta _ { \nu } ^ { ( \ell ) } + ( \pi - \theta _ { \nu } ^ { ( \ell ) } ) \cos \theta _ { \nu } ^ { ( \ell ) } \right)
+$$
+
+where $\theta _ { \nu } ^ { ( \ell ) } = \cos ^ { - 1 } \bigg ( K _ { \nu } ^ { ( \ell ) } ( { \mathbf X } , { \mathbf X ^ { \prime } } ) / \sqrt { K _ { \nu } ^ { ( \ell ) } ( { \mathbf X } , { \mathbf X } ) K _ { \nu } ^ { ( \ell ) } ( { \mathbf X ^ { \prime } } , { \mathbf X ^ { \prime } } ) } \bigg ) .$
+
+# 3.3 EFFICIENCY OF THE CONVNET KERNEL
+
+We now have all the pieces for computing the kernel, as written in Algorithm 1.
+
+Putting together Eq. (11) and Eq. (13) gives us the surprising result that the diagonal covariances of the activations at layer $\ell + 1$ only depend on the diagonal covariances of the activations at layer $\ell$ . This is very important, because it makes the computational cost of the kernel be within a constant factor of the cost of a forward pass for the equivalent CNN with 1 filter per layer.
+
+Thus, the algorithm is more efficient that one would naively think. A priori, one needs to compute the covariance between all the elements of ${ \bf a } _ { j } ^ { ( \ell ) } ( { \bf X } )$ and $\mathbf { a } _ { j } ^ { ( \ell ) } ( \mathbf { X } ^ { \prime } )$ combined, yielding a $2 H ^ { ( \ell ) } D ^ { ( \ell ) } \times$ $2 H ^ { ( \ell ) } D ^ { ( \ell ) }$ covariance matrix for every pair of points. Instead, we only need to keep track of a $H ^ { ( \ell ) } D ^ { ( \ell ) }$ -dimensional vector per layer and pair of points.
+
+Furthermore, the particular form for the kernel (eq. 1 and eq. 2) implies that the required variances and covariances at all required locations can be computed efficiently as a convolution.
+
+# 3.4 KERNEL FOR A RESIDUAL CNN
+
+The induction step in the argument for GP behaviour from Sec. 2.2 depends only on the previous activations being iid Gaussian. Since all the activations are iid Gaussian, we can add skip connections between the activations of different layers while preserving GP behaviour, e.g. $\mathbf { A } ^ { ( \ell + 1 ) }$ and $\mathbf { A } ^ { ( \ell - s ) }$ where $s$ is the number of layers that the skip connection spans. If we change the NN recursion (Eq. 2) to
+
+$$
+\mathbf { a } _ { i } ^ { ( \ell + 1 ) } ( \mathbf { X } ) : = \mathbf { a } _ { i } ^ { ( \ell - s ) } ( \mathbf { X } ) + \mathbf { b } _ { i } ^ { ( \ell + 1 ) } + \sum _ { j = 1 } ^ { C ^ { ( \ell ) } } \mathbf { W } _ { i , j } ^ { ( \ell ) } \phi \left( \mathbf { a } _ { j } ^ { ( \ell ) } ( \mathbf { X } ) \right) ,
+$$
+
+then the kernel recursion (Eq. 11) becomes
+
+$$
+K _ { \mu } ^ { ( \ell + 1 ) } ( \mathbf { X } , \mathbf { X } ^ { \prime } ) = K _ { \mu } ^ { ( \ell - s ) } ( \mathbf { X } , \mathbf { X } ^ { \prime } ) + \sigma _ { b } ^ { 2 } + \sigma _ { w } ^ { 2 } \sum _ { \nu \in \mu \mathrm { t h } \mathrm { p a t c h } } V _ { \nu } ^ { ( \ell ) } ( \mathbf { X } , \mathbf { X } ^ { \prime } ) .
+$$
+
+This way of adding skip connections is equivalent to the “pre-activation” shortcuts described by He et al. (2016b). Remarkably, the natural way of adding residual connections to NNs is the one that performed best in their empirical evaluations.
+
+# 4 EXPERIMENTS
+
+We evaluate our kernel on the MNIST handwritten digit classification task. Classification likelihoods are not conjugate for GPs, so we must make an approximation, and we follow Lee et al. (2017), in re-framing classification as multi-output regression.
+
+The training set is split into $N = 5 0 0 0 0$ training and 10000 validation examples. The regression targets $\mathbf { Y } \in \{ - 1 , 1 \} ^ { \overline { { N } } \times 1 0 }$ are a one-hot encoding of the example’s class: $y _ { n , c } = 1$ if the $n$ th example belongs to class $c$ , and $- 1$ otherwise.
+
+Training is exact conjugate likelihood GP regression with noiseless targets $\mathbf { Y }$ (Rasmussen & Williams, 2006). First we compute the $N \times N$ kernel matrix ${ \bf K } _ { x x }$ , which contains the kernel between every pair of examples. Then we compute ${ \mathbf { K } } _ { x x } ^ { - 1 } { \mathbf { Y } }$ using a linear system solver.
+
+The test set has $N _ { T } = 1 0 0 0 0$ examples. We compute the $N _ { T } \times N$ matrix $\mathbf { K } _ { x ^ { * } x }$ , the kernel between each test example and all the training examples. The predictions are given by the row-wise maximum of $\mathbf { K } _ { x ^ { * } x } \mathbf { K } _ { x x } ^ { - 1 } \bar { \mathbf { Y } }$ .
+
+For the “ConvNet GP” and “Residual CNN GP”, (Table 1) we optimise the kernel hyperparameters by random search. We draw $M$ random hyperparameter samples, compute the resulting kernel’s performance in the validation set, and pick the highest performing run. The kernel hyperparameters are: $\sigma _ { b } ^ { 2 }$ , $\sigma _ { w } ^ { 2 }$ ; the number of layers; the convolution stride, filter sizes and edge behaviour; the nonlinearity (we consider the error function and ReLU); and the frequency of residual skip connections (for Residual CNN GPs). We do not retrain the model on the validation set after choosing hyperparameters.
+
+Table 1: MNIST classification results. #samples gives the number of kernels that were randomly sampled for the hyperparameter search. “ConvNet GP” and “Residual CNN GP” are random CNN architectures with a fixed filter size, whereas “ResNet GP” is a slight modification of the architecture by He et al. (2016b). Entries labelled “SGD” used stochastic gradient descent for tuning hyperparameters, by maximising the likelihood of the training set. The last two methods use parametric neural networks. The hyperparameters of the ResNet GP were not optimised (they were fixed based on the architecture from He et al., 2016b).   
+
+<table><tr><td>Method</td><td>#samples</td><td>Validation error</td><td>Test error</td></tr><tr><td>NNGP (Lee et al., 2017)</td><td>~250</td><td>1</td><td>1.21%</td></tr><tr><td>Convolutional GP (van der Wilk et al., 2017)</td><td>SGD</td><td></td><td>1.17%</td></tr><tr><td>Deep Conv. GP (Kumar et al., 2018)</td><td>SGD</td><td>1</td><td>1.34%</td></tr><tr><td>ConvNetGP</td><td>27</td><td>0.71%</td><td>1.03%</td></tr><tr><td>Residual CNN GP</td><td>27</td><td>0.72%</td><td>0.96%</td></tr><tr><td>ResNet GP</td><td>1</td><td>0.68%</td><td>0.84%</td></tr><tr><td>GP + parametric deep kernel (Bradshaw et al., 2017)</td><td>SGD</td><td>1</td><td>0.60%</td></tr><tr><td>ResNet (Chen et al.,2018)</td><td>一</td><td></td><td>0.41%</td></tr></table>
+
+The “ResNet GP” (Table 1) is the kernel equivalent to a 32-layer version of the basic residual architecture by He et al. (2016a). The differences are: an initial $3 \times 3$ convolutional layer and a final dense layer instead of average pooling. We chose to remove the pooling because computing its output variance requires the off-diagonal elements of the filter covariance, in which case we could not exploit the efficiency gains described in Sec. 3.3.
+
+We found that the despite it not being optimised, the 32-layer ResNet GP outperformed all other comparable architectures (Table 1), including the NNGP in Lee et al. (2017), which is state-ofthe-art for non-convolutional networks, and convolutional GPs (van der Wilk et al., 2017; Kumar et al., 2018). That said, our results have not reached state-of-the-art for methods that incorporate a parametric neural network, such as a standard ResNet (Chen et al., 2018) and a Gaussian process with a deep neural network kernel Bradshaw et al. (2017).
+
+To check whether the GP limit is applicable to relatively small networks used practically (with of the order of 100 channels in the first layers), we randomly sampled 10, 000 32-layer ResNets, with 3, 10, 30 and 100 channels in the first layers, and, following the usual practice for ResNets we increase the number the number of hidden units when we downsample the feature maps. The probability density plots show a good match around 100 channels (Fig. 2A), which matches a more sensitive graphical procedure based on quantile-quantile plots (Fig. 2B). Notably, even for only 30 channels, the moments match closely (Fig. 2C). For comparison, typical ResNets use from 64 (He et al., 2016a) to 192 (Zagoruyko & Komodakis, 2016) channels in their first layers. We believe that this is because the moment propagation equations only require the Gaussianity assumption for propagation through the relu, and presumably this is robust to non-Gaussian input activations.
+
+Computational efficiency. Asymptotically, computing the kernel matrix takes $O ( N ^ { 2 } L D )$ time, where $L$ is the number of layers in the network and $D$ is the dimensionality of the input, and inverting the kernel matrix takes $O ( \bar { N } ^ { 3 } )$ . As such, we expect that for very large datasets, inverting the kernel matrix will dominate the computation time. However, on MNIST, $N ^ { 3 }$ is only around a factor of 10 larger than $N ^ { 2 } L D$ . In practice, we found that it was more expensive to compute the kernel matrix than to invert it. For the ResNet kernel, the most expensive, computing ${ \bf K } _ { x x }$ , and ${ \bf K } _ { x x * }$ for validation and test took 3h 40min on two Tesla P100 GPUs. In contrast, inverting ${ \bf K } _ { x x }$ and computing validation and test performance took $4 3 . 2 5 \pm 8 . 8$ seconds on a single Tesla P100 GPU.
+
+# 5 RELATED WORK
+
+Van der Wilk et al. (van der Wilk et al., 2017) also adapted GPs to image classification. They defined a prior on functions $f$ that takes an image and outputs a scalar. First, draw a function $g \sim \mathcal { G P } ( 0 , k _ { p } ( \mathbf { X } , \mathbf { X } ^ { \prime } ) )$ . Then, $f$ is the sum of the output of $g$ applied to each of the convolutional patches. Their approach is also inspired by convolutional NNs, but their kernel $k _ { p }$ is applied to all pairs of patches of $\mathbf { X }$ and $\mathbf { X } ^ { \prime }$ . This makes their convolutional kernel expensive to evaluate, requiring inter-domain inducing point approximations to remain tractable. The kernels in this work, directly motivated by the infinite-filter limit of a CNN, only apply something like $k _ { p }$ to the corresponding pairs of patches within $\mathbf { X }$ and $\mathbf { X } ^ { \prime }$ (Eq. 10). As such, the CNN kernels are cheaper to compute and exhibit superior performance (Table 1), despite the use of an approximate likelihood function.
+
+![](images/855e86413bd7de48d01d9cca88bd8f2c7466cd7a38d25eebae9541aa8c975eaf.jpg)  
+Figure 2: Comparison of the infinite limit, and outputs from finite 32-layer ResNets with 3, 10, 30, and 100 channels in their first layers. A Comparison of the empirical and limiting probability densities. B A more sensitive test of Gaussianity is a quantile-quantile plot, which shows converges with 100 channels. C The moments (variances and covariances) for 100 training inputs shows gives a good match for all numbers of channels.
+
+Kumar et al. (2018) define a prior over functions by stacking several GPs with van der Wilk’s convolutional kernel, forming a “Deep GP” (Damianou & Lawrence, 2013). In contrast, the kernel in this paper confines all hierarchy to the definition of the kernel, and the resulting GPs is shallow.
+
+Wilson et al. (2016) introduced and Bradshaw et al. (2017) improved deep kernel learning. The inputs to a classic GP kernel $k$ (e.g. RBF) are preprocessed by applying a feature extractor $g$ (a deep NN) prior to computing the kernel: $k _ { \mathrm { d e e p } } ( \mathbf { X } , \bar { \mathbf { X } } ^ { \prime } ) : = k ( g ( \mathbf { X } ; \theta ) , \bar { g ( \mathbf { X } ^ { \prime } , \theta ) } )$ . The NN parameters are optimised by gradient ascent using the likelihood as the objective, as in standard GP kernel learning (Rasmussen & Williams, 2006, Chapter 5). Since deep kernel learning incorporates a state-of-the-art NN with over $1 0 ^ { 6 }$ parameters, we expect it to perform similarly to a NN applied directly to the task of image classification. At present both CNNs and deep kernel learning display superior performance to the GP kernels in this work. However, the kernels defined here have far fewer parameters (around 10, compared to their $1 0 ^ { 6 }$ ).
+
+Borovykh (2018) also suggests that a CNN exhibits GP behaviour. However, they take the infinite limit with respect to the filter size, not the number of filters. Thus, their infinite network is inapplicable to real data which is always of finite dimension.
+
+Finally, there is a series of papers analysing the mean-field behaviour of deep NNs and CNNs which aims to find good random initializations, i.e. those that do not exhibit vanishing or exploding gradients or activations (Schoenholz et al., 2016; Yang & Schoenholz, 2017). Apart from their very different focus, the key difference to our work is that they compute the variance for a single trainingexample, whereas to obtain the GPs kernel, we additionally need to compute the output covariances for different training/test examples (Xiao et al., 2018).
+
+# 6 CONCLUSIONS AND FUTURE WORK
+
+We have shown that deep Bayesian CNNs with infinitely many filters are equivalent to a GP with a recursive kernel. We also derived the kernel for the GP equivalent to a CNN, and showed that, in handwritten digit classification, it outperforms all previous GP approaches that do not incorporate a parametric NN into the kernel. Given that most state-of-the-art neural networks incorporate structure (convolutional or otherwise) into their architecture, the equivalence between CNNs and GPs is potentially of considerable practical relevance. In particular, we hope to apply GP CNNs in domains as widespread as adversarial examples, lifelong learning and $\mathbf { k }$ -shot learning, and we hope to improve them by developing efficient multi-layered inducing point approximation schemes.
+
+# REFERENCES
+
+JR Blum, H Chernoff, M Rosenblatt, and H Teicher. Central limit theorems for interchangeable processes. Canad. J. Math, 10:222–229, 1958.
+
+Charles Blundell, Julien Cornebise, Koray Kavukcuoglu, and Daan Wierstra. Weight uncertainty in neural network. In International Conference on Machine Learning, pp. 1613–1622, 2015.
+
+Anastasia Borovykh. A gaussian process perspective on convolutional neural networks. ResearchGate, 05 2018.
+
+John Bradshaw, Alexander G de G Matthews, and Zoubin Ghahramani. Adversarial examples, uncertainty, and transfer testing robustness in gaussian process hybrid deep networks. arXiv preprint arXiv:1707.02476, 2017.
+
+Tian Qi Chen, Yulia Rubanova, Jesse Bettencourt, and David Duvenaud. Neural ordinary differential equations. arXiv preprint arXiv:1806.07366, 2018.
+
+Youngmin Cho and Lawrence K Saul. Kernel methods for deep learning. In Advances in neural information processing systems, pp. 342–350, 2009. URL http://papers.nips.cc/ paper/3628-kernel-methods-for-deep-learning.pdf.
+
+Andreas Damianou and Neil Lawrence. Deep gaussian processes. In Carlos M. Carvalho and Pradeep Ravikumar (eds.), Proceedings of the Sixteenth International Conference on Artificial Intelligence and Statistics, volume 31 of Proceedings of Machine Learning Research, pp. 207– 215, Scottsdale, Arizona, USA, 29 Apr–01 May 2013. PMLR. URL http://proceedings. mlr.press/v31/damianou13a.html.
+
+Marc Deisenroth and Carl E Rasmussen. PILCO: A model-based and data-efficient approach to policy search. In Proceedings of the 28th International Conference on machine learning (ICML11), pp. 465–472, 2011.
+
+Yarin Gal and Zoubin Ghahramani. Dropout as a bayesian approximation: Representing model uncertainty in deep learning. arXiv preprint arXiv:1506.02142, 2015.
+
+Yarin Gal and Lewis Smith. Idealised bayesian neural networks cannot have adversarial examples: Theoretical and empirical study. arXiv preprint arXiv:1806.00667, 2018.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016a. URL https://arxiv.org/pdf/1512.03385.pdf.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Identity mappings in deep residual networks. In European conference on computer vision, pp. 630–645. Springer, 2016b.
+
+Daniel Hernández-lobato, Jose M. Hernández-lobato, and Pierre Dupont. Robust multiclass gaussian process classification. In J. Shawe-Taylor, R. S. Zemel, P. L. Bartlett, F. Pereira, and K. Q. Weinberger (eds.), Advances in Neural Information Processing Systems 24, pp. 280–288. 2011. URL http://papers.nips.cc/paper/ 4241-robust-multi-class-gaussian-process-classification.pdf.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In Advances in neural information processing systems, pp. 1097–1105, 2012.
+
+Vinayak Kumar, Vaibhav Singh, PK Srijith, and Andreas Damianou. Deep gaussian processes with convolutional kernels. arXiv preprint arXiv:1806.01655, 2018.
+
+Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial examples in the physical world. arXiv preprint arXiv:1607.02533, 2016.
+
+Balaji Lakshminarayanan, Alexander Pritzel, and Charles Blundell. Simple and scalable predictive uncertainty estimation using deep ensembles. In Advances in Neural Information Processing Systems, pp. 6402–6413, 2017.
+
+Yann LeCun, Bernhard E Boser, John S Denker, Donnie Henderson, Richard E Howard, Wayne E Hubbard, and Lawrence D Jackel. Handwritten digit recognition with a back-propagation network. In Advances in neural information processing systems, pp. 396–404, 1990.
+
+Jaehoon Lee, Yasaman Bahri, Roman Novak, Samuel S Schoenholz, Jeffrey Pennington, and Jascha Sohl-Dickstein. Deep neural networks as gaussian processes. arXiv preprint arXiv:1711.00165, 2017.
+
+Stephan Mandt, Matthew D Hoffman, and David M Blei. Stochastic gradient descent as approximate bayesian inference. The Journal of Machine Learning Research, 18(1):4873–4907, 2017.
+
+Alexander G. de G. Matthews, Jiri Hron, Mark Rowland, Richard E. Turner, and Zoubin Ghahramani. Gaussian process behaviour in wide deep neural networks. In International Conference on Learning Representations, 2018a. URL https://openreview.net/forum?id $=$ H1-nGgWC-.
+
+Alexander G de G Matthews, Mark Rowland, Jiri Hron, Richard E Turner, and Zoubin Ghahramani. Gaussian process behaviour in wide deep neural networks. arXiv preprint arXiv:1804.11271, 2018b.
+
+De G Matthews, G Alexander, Mark Van Der Wilk, Tom Nickson, Keisuke Fujii, Alexis Boukouvalas, Pablo León-Villagrá, Zoubin Ghahramani, and James Hensman. GPflow: A gaussian process library using TensorFlow. The Journal of Machine Learning Research, 18(1):1299–1304, 2017.
+
+Radford M. Neal. Bayesian Learning for Neural Networks. Springer-Verlag, Berlin, Heidelberg, 1996. ISBN 0387947248.
+
+Carl Edward Rasmussen and Christopher KI Williams. Gaussian processes for machine learning, volume 1. MIT press Cambridge, 2006.
+
+Samuel S Schoenholz, Justin Gilmer, Surya Ganguli, and Jascha Sohl-Dickstein. Deep information propagation. arXiv preprint arXiv:1611.01232, 2016.
+
+Jasper Snoek, Hugo Larochelle, and Ryan P Adams. Practical bayesian optimization of machine learning algorithms. In Advances in neural information processing systems, pp. 2951–2959, 2012.
+
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. arXiv preprint arXiv:1312.6199, 2013.
+
+Mark van der Wilk, Carl Edward Rasmussen, and James Hensman. Convolutional gaussian processes. In Advances in Neural Information Processing Systems, pp. 2845–2854, 2017.
+
+Max Welling and Yee W Teh. Bayesian learning via stochastic gradient langevin dynamics. In Proceedings of the 28th International Conference on Machine Learning (ICML-11), pp. 681–688, 2011.
+
+Andrew Gordon Wilson, Zhiting Hu, Ruslan Salakhutdinov, and Eric P. Xing. Deep kernel learning. In Arthur Gretton and Christian C. Robert (eds.), Proceedings of the 19th International Conference on Artificial Intelligence and Statistics, volume 51 of Proceedings of Machine Learning Research, pp. 370–378, Cadiz, Spain, 09–11 May 2016. PMLR. URL http: //proceedings.mlr.press/v51/wilson16.html.
+
+Lechao Xiao, Yasaman Bahri, Jascha Sohl-Dickstein, Samuel S Schoenholz, and Jeffrey Pennington. Dynamical isometry and a mean field theory of cnns: How to train 10,000-layer vanilla convolutional neural networks. arXiv preprint arXiv:1806.05393, 2018.
+
+Ge Yang and Samuel Schoenholz. Mean field residual networks: On the edge of chaos. In Advances in neural information processing systems, pp. 7103–7114, 2017.
+
+Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. arXiv preprint arXiv:1605.07146, 2016.
+
+# 7 APPENDIX
+
+# 7.1 TECHNICAL NOTES ON LIMITS
+
+The key technical issues in the proof (and the key differences between Lee et al. 2017 and Matthews et al. 2018b) arise from exactly how and where we take limits. In particular, consider the activations as being functions of the activities at the previous layer,
+
+$$
+{ \bf A } ^ { ( 4 ) } = { \bf A } ^ { ( 4 ) } ( { \bf A } ^ { ( 3 ) } ( { \bf A } ^ { ( 2 ) } ( { \bf A } ^ { ( 1 ) } ( { \bf X } ) ) ) )
+$$
+
+Now, there are two approaches to taking limits. First, both our argument in the main text, and the argument in Lee et al. (2017) is valid if we are able to take limits “inside” the network,
+
+$$
+\mathbf { A } _ { \mathrm { L } } ^ { ( 4 ) } = \operatorname* { l i m } _ { C ^ { ( 3 ) } \to \infty } \mathbf { A } ^ { ( 4 ) } \left( \operatorname* { l i m } _ { C ^ { ( 2 ) } \to \infty } \mathbf { A } ^ { ( 3 ) } \left( \operatorname* { l i m } _ { C ^ { ( 1 ) } \to \infty } \mathbf { A } ^ { ( 2 ) } \left( \mathbf { A } ^ { ( 1 ) } ( \mathbf { X } ) \right) \right) \right) .
+$$
+
+However, Matthews et al. (2018a;b) argue that is preferable to take limits “outside” the network. In particular, Matthews et al. (2018b) take the limit with all layers simultaneously,
+
+$$
+{ \bf A } _ { \mathrm { M } } ^ { ( 4 ) } = \operatorname* { l i m } _ { n  \infty } { \bf A } ^ { ( 4 ) } ( { \bf A } ^ { ( 3 ) } ( { \bf A } ^ { ( 2 ) } ( { \bf A } ^ { ( 1 ) } ( { \bf X } ) ) ) ) ,
+$$
+
+where $C ^ { ( \ell ) } = C ^ { ( \ell ) } ( n )$ goes to infinity as $n \to \infty$ . That said, similar technical issues arise if we take limits in sequence, but outside the network.
+
+# 7.2 EXTENDING THE DERIVATIONS OF MATTHEWS ET AL. (2018B) TO THE CONVOLUTIONAL CASE
+
+In the main text, we follow Lee et al. (2017) in sequentially taking the limit of each layer to infinity (i.e. $C ^ { ( 1 ) } \to \infty$ , then $C ^ { ( 2 ) }  \infty$ etc.). This dramatically simplified the argument, because taking the number of units in the previous layer to infinity means that the inputs from that layer are exactly Gaussian distributed. However, Matthews et al. (2018b) argue that the more practically relevant limit is where we take all layers to infinity simultaneously. This raises considerable additional difficulties, because we must reason about convergence in the case where the previous layer is finite. Note that this section is not intended to stand independently: it is intended to be read alongside Matthews et al. (2018b), and we use several of their results without proof.
+
+Mirroring Definition 3 in Matthews et al. (2018b), we begin by choosing a set of “width” functions, $C ^ { ( \ell ) } ( n )$ , for $\ell \in \{ 1 , \ldots , L \}$ which all approach infinity as $n  \infty$ . In Matthews et al. (2018b), these functions described the number of hidden units in each layer, whereas here they describe the number of channels. Our goal is then to extend the proofs in Matthews et al. (2018b) (in particular, of theorem 4), to show that the output of our convolutional networks converge in distribution to a Gaussian process as $n  \infty$ , with mean zero and covariance given by the recursion in Eqs. (10 – 12).
+
+The proof in Matthews et al. (2018b) has three main steps. First, they use the Cramér-Wold device, to reduce the full problem to that of proving convergence of scalar random variables to a Gaussian with specified variance. Second, if the previous layers have finite numbers of channels, then the channels ${ \bf a } _ { j } ^ { ( \ell ) } ( { \bf X } )$ and $\mathbf { a } _ { j } ^ { ( \ell ) } ( \mathbf { X } ^ { \prime } )$ are uncorrelated but no longer independent, so we cannot apply the CLT directly, as we did in the main text. Instead, they write the activations as a sum of exchangeable random variables, and derive an adapted CLT for exchangeable (rather than independent) random variables (Blum et al., 1958). Third, they show that moment conditions required by their exchangeable CLT are satisfied.
+
+To extend their proofs to the convolutional case, we begin by defining our networks in a form that is easier to manipulate and as close as possible to Eq. (21-23) in Matthews et al. (2018b),
+
+$$
+\begin{array} { c } { { A _ { i , \mu } ^ { ( 1 ) } = f _ { i , \mu } ^ { ( 1 ) } ( x ) = \displaystyle \frac { \sigma _ { \mathbf { w } } } { \sqrt { C ^ { ( 0 ) } } } \sum _ { j = 1 } ^ { C ^ { ( 0 ) } } \sum _ { \nu \in \mu \mathbb { h } \mathrm { p a t e h } } \epsilon _ { i , j , \mu , \nu } ^ { ( 1 ) } x _ { j , \nu } + b _ { i } ^ { ( 1 ) } , \quad i \in \mathbb { N } } } \\ { { g _ { i , \mu } ^ { ( \ell ) } ( x ) = \phi \left( f _ { i , \mu } ^ { ( \ell ) } ( x ) \right) } } \\ { { A _ { i , \mu } ^ { ( \ell + 1 ) } = f _ { i , \mu } ^ { ( \ell + 1 ) } ( x ) = \displaystyle \frac { \sigma _ { \mathbf { w } } } { \sqrt { C ^ { ( \ell ) } ( n ) } } \sum _ { j = 1 } ^ { C ^ { ( \ell ) } } \sum _ { \nu \in \mu \mathrm { t h } \mathrm { p a t e h } } \epsilon _ { i , j , \mu , \nu } ^ { ( \ell + 1 ) } g _ { j , \nu } ^ { ( \ell ) } ( x ) + b _ { i } ^ { ( \ell + 1 ) } , \quad i \in \mathbb { N } } } \end{array}
+$$
+
+where,
+
+$$
+\epsilon _ { i , j , \mu , \nu } \sim \mathcal { N } ( 0 , 1 ) .
+$$
+
+The first step is to use the Cramér-Wold device (Lemma 6 in Matthews et al., 2018b), which indicates that convergence in distribution of a sequence of finite-dimensional vectors is equivalent to convergence on all possible linear projections to the corresponding real-valued random variable. Mirroring Eq. 25 in Matthews et al. (2018b), we consider convergence of random vectors, $f _ { i , \mu } ^ { ( \ell ) } ( x ) [ n ] - b _ { i } ^ { ( \ell ) }$ , projected onto α(x,i,µ),
+
+$$
+\mathcal { T } ^ { ( \ell ) } \left( \mathcal { L } , \alpha \right) \left[ n \right] = \sum _ { ( x , i , \mu ) \in \mathcal { L } } \alpha ^ { ( x , i , \mu ) } \left[ f _ { i , \mu } ^ { ( \ell ) } ( x ) [ n ] - b _ { i } ^ { ( \ell ) } \right] .
+$$
+
+where $\mathcal { L } \subset \mathcal { X } \times \mathbb { N } \times \{ 1 , \ldots , H ^ { ( \ell ) } D ^ { ( \ell ) } \}$ is a finite set of tuples of data points and channel indicies, $i$ , and indicies of elements within channels/feature maps, $\mu$ . The suffix $[ n ]$ indicates width functions that are instantiated with input, $n$ .
+
+Now, we must prove that these projections converge in distribution a Gaussian. We begin by defining summands, as in Eq. 26 in Matthews et al. (2018b),
+
+$$
+\gamma _ { j } ^ { ( \ell ) } \left( \mathcal { L } , \alpha \right) [ n ] : = \sigma _ { \mathrm { w } } \sum _ { ( x , i , \mu ) \in \mathcal { L } } \alpha ^ { ( x , i , \mu ) } \sum _ { \nu \in \mu \mathrm { t h p a t c h } } \epsilon _ { i , j , \mu , \nu } ^ { ( \ell ) } g _ { j , \nu } ^ { ( \ell - 1 ) } ( x ) [ n ] ,
+$$
+
+such that the projections can be written as a sum of the summands, exactly as in Eq. 27 in Matthews et al. (2018b),
+
+$$
+\mathcal { T } ^ { ( \ell ) } \left( \mathcal { L } , \alpha \right) [ n ] = \frac { 1 } { \sqrt { C ^ { ( \ell - 1 ) } ( n ) } } \sum _ { j = 1 } ^ { C ^ { ( \ell - 1 ) } ( n ) } \gamma _ { j } ^ { ( \ell ) } \left( \mathcal { L } , \alpha \right) [ n ] .
+$$
+
+Now we can apply the exchangeable CLT to prove that ${ \mathcal { T } } ^ { ( \ell ) } \left( { \mathcal { L } } , \alpha \right) [ n ]$ converges to the limiting Gaussian implied by the recursions in the main text. To apply the exchangeable CLT, the first step is to mirror Lemma 8 in Matthews et al. (2018b), in showing that for each fixed $n$ and $\ell \in \{ 2 , \ldots , L +$ $1 \}$ , the summands, $\gamma _ { j } ^ { ( \ell ) } \left( \mathcal { L } , \alpha \right) [ n ]$ are exchangeable with respect to the index $j$ . In particular, we apply de Finetti’s theorem, which states that a sequence of random variables is exchangeable if and only if they are i.i.d. conditional on some set of random variables, so it is sufficient to exhibit such a set of random variables. Mirroring Eq. 29 in Matthews et al. (2018b), we apply the recursion,
+
+$$
+ \overset { ( \ell ) } { j } ( \mathcal { L } , \alpha ) [ n ] : = \sigma _ { \mathrm { w } } \sum _ { ( x , i , \mu ) \in \mathcal { L } } \alpha ^ { ( x , i , \mu ) } \sum _ { \nu \in \mu \mathrm { t h } \mathrm { p a t e h } } \epsilon _ { i , j , \mu , \nu } ^ { ( \ell ) } \phi ( \frac { \sigma _ { \mathrm { w } } } { \sqrt { C ^ { ( \ell - 2 ) } ( n ) } } \sum _ { k = 1 } ^ { C ^ { ( \ell - 2 ) } ( n ) } \sum _ { \xi \in \nu \mathrm { t h } \mathrm { p a t e h } } \epsilon _ { j , k , \nu ; \xi } ^ { ( \ell - 1 ) } g _ { k , \xi } ^ { ( \ell - 2 ) } ) ,
+$$
+
+As such, the summands are iid conditional on the finite set of random variables $\left\{ g _ { k , \xi } ^ { ( \ell - 2 ) } ( x ) [ n ] : k \in \{ 1 , \ldots , C ^ { ( \ell - 2 ) } \} , \xi \in \left\{ 1 , \ldots , H ^ { ( \ell - 2 ) } D ^ { ( \ell - 2 ) } \right\} , x \in \mathcal { L } _ { \mathcal { X } } \right\}$ , where $\mathcal { L } _ { \mathcal { X } }$ is the set of input points in $\mathcal { L }$ .
+
+The exchangeable CLT in Lemma 10 in Matthews et al. (2018b) indicates that ${ \mathcal { T } } ^ { ( \ell ) } \left( { \mathcal { L } } , \alpha \right) [ n ]$ converges in distribution to $\mathcal { N } \left( 0 , \sigma _ { * } ^ { 2 } \right)$ if the summands are exchangeable (which we showed above), and if three conditions hold,
+
+$$
+\begin{array} { r l } & { \mathrm { a ) ~ \mathbb { E } } _ { n } [ \gamma _ { j } ^ { ( \ell ) } \gamma _ { j ^ { \prime } } ^ { ( \ell ) } ] = 0 } \\ & { \mathrm { b ) ~ \operatorname* { l i m } _ { n  \infty } \mathbb { E } } _ { n } [ ( \gamma _ { j } ^ { ( \ell ) } ) ^ { 2 } ( \gamma _ { j ^ { \prime } } ^ { ( \ell ) } ) ^ { 2 } ] = \sigma _ { * } ^ { 4 } } \\ & { \mathrm { c ) ~ \mathbb { E } } _ { n } [ | \gamma _ { j } ^ { ( \ell ) } | ^ { 3 } ] = o ( \sqrt { C ^ { ( \ell ) } ( n ) } ) } \end{array}
+$$
+
+Condition a) follows immediately as the summands are uncorrelated and zero-mean. Conditions b) and c) are more involved as convergence in distribution in the previous layers does not imply convergence in moments for our activation functions.
+
+We begin by considering the extension of Lemma 20 in Matthews et al. (2018b), which allow us to show conditions b) and c) above, even in the case of unbounded but linearly enveloped nonlinearities (Definition 1 in Matthews et al., 2018b). Lembounded by a finite constant independent of states that the eighth moments of . We prove this by induction. Th $f _ { i , \mu } ^ { ( t ) } ( x ) [ n ]$ aree is $n \in \mathbb N$   
+trivial, as $f _ { j , \mu } ^ { ( 1 ) } ( x ) [ n ]$ is Gaussian. Following Matthews et al. (2018b), assume the condition holds up to $\ell - 1$ , and show that the condition holds for layer $\ell$ . Using Eq. (21), we can bound the activations at layer $\ell$ ,
+
+$$
+\mathbb { E } \left[ | f _ { i , \mu } ^ { ( \ell ) } ( x ) [ n ] | ^ { 8 } \right] \leq 2 ^ { 8 - 1 } \mathbb { E } \left[ | b _ { i } ^ { ( \ell ) } | ^ { 8 } + \left| \frac { \sigma _ { \mathbf { w } } } { \sqrt { C ^ { ( \ell - 1 ) } } } \sum _ { j = 1 } ^ { C ^ { ( \ell - 1 ) } ( n ) } \sum _ { \nu \in \mu \mathrm { t h } \mathrm { p a t e h } } \epsilon _ { i , j , \mu , \nu } ^ { ( \ell ) } g _ { j , \nu } ^ { ( \ell - 1 ) } ( x ) [ n ] \right| ^ { 8 } \right]
+$$
+
+Following Eq. 48 in Matthews et al. (2018b), which uses Lemma 19 in Matthews et al. (2018b), we have,
+
+$$
+\begin{array} { r l } { \mathbb { E } \left[ \left| \frac { \sigma _ { \mathrm { w } } } { \sqrt { C ^ { ( \ell - 1 ) } } } \sum _ { j = 1 } ^ { C ^ { ( \ell - 1 ) } ( n ) } \displaystyle \sum _ { \nu \in \mu \mathrm { t h } \mathrm { p a t e h } } \epsilon _ { i , j , \mu , \nu } ^ { ( \ell ) } g _ { j , \nu } ^ { ( \ell - 1 ) } ( x ) [ n ] \right| ^ { 8 } \right] } & { } \\ { = \frac { 2 ^ { 4 } \Gamma ( 4 + 1 / 2 ) } { \Gamma ( 1 / 2 ) } \mathbb { E } \left[ \left| \frac { \sigma _ { \mathrm { w } } ^ { 2 } } { C ^ { ( \ell - 1 ) } ( n ) } \| g _ { j \in \{ 1 , \dots , C ^ { ( \ell - 1 ) } ( n ) \} , \nu \in \mu \mathrm { t h } \mathrm { p a t c h } } ^ { ( \ell - 1 ) } ( x ) [ n ] \| _ { 2 } ^ { 2 } \right| ^ { 4 } \right] . } \end{array}
+$$
+
+wher e g(\`−1)j∈{1,...,C(\`−1)(n)},ν∈µth patch(x)[n] is the set of post-nonlinearities corresponding to j ∈ $\{ 1 , \ldots , C ^ { ( \ell - 1 ) } ( n ) \}$ and $\nu \in \mu \mathrm { t h }$ patch. Following Matthews et al. (2018b), observe that,
+
+$$
+\begin{array} { r } { \frac { 1 } { \sum ^ { ( \ell - 1 ) } \left( n \right) } \| g _ { j \in \{ 1 , \dots , C ^ { ( \ell - 1 ) } ( n ) \} , \nu \in \mu \mathrm { t h p a t e h } } ^ { ( \ell - 1 ) } ( x ) [ n ] \| _ { 2 } ^ { 2 } = \frac { 1 } { C ^ { ( \ell - 1 ) } ( n ) } \displaystyle \sum _ { j = 1 } ^ { C ^ { ( \ell - 1 ) } ( n ) } \sum _ { \nu \in \mu \mathrm { t h p a t e h } } \left( g _ { j , \nu } ^ { ( \ell - 1 ) } ( x ) [ n ] \right) ^ { 2 } } \\ { \leq \frac { 1 } { C ^ { ( \ell - 1 ) } ( n ) } \displaystyle \sum _ { j = 1 } ^ { C ^ { ( \ell - 1 ) } ( n ) } \sum _ { \nu \in \mu \mathrm { t h p a t e h } } ^ { C ^ { ( \ell - 1 ) } ( n ) } \left( c + m \big | f _ { j , \nu } ^ { ( \ell - 1 ) } ( x ) \big | \right. } \end{array}
+$$
+
+by the linear envelope property, $| \phi ( u ) | \leq c + m | u |$ . Following Matthews et al. (2018b), we substitute this bound back into Eq. (28) and suppress a multiplicative constant independent of $x$ and $n$ ,
+
+$$
+\begin{array} { r l } & { \mathbb { E } \left[ \left| \frac { \sigma _ { \mathbf { w } } } { \sqrt { C ^ { ( \ell - 1 ) } ( n ) } } \sum _ { j = 1 } ^ { C ^ { ( \ell - 1 ) } ( n ) } \sum _ { \nu \in \mu \mathrm { t h p a t c h } } \epsilon _ { i , j , \mu , \nu } ^ { ( \ell ) } g _ { j , \nu } ^ { ( \ell - 1 ) } ( x ) [ n ] \right| ^ { 8 } \right] } \\ & { \leq \frac { 1 } { \left( C ^ { ( \ell - 1 ) } ( n ) \right) ^ { 4 } } \mathbb { E } \left[ \left| \sum _ { j = 1 } ^ { C ^ { ( \ell - 1 ) } ( n ) } \sum _ { \nu \in \mu \mathrm { t h p a c h } } c ^ { 2 } + 2 c m | f _ { j , \mu } ^ { ( \ell - 1 ) } ( x ) [ n ] | + m ^ { 2 } | f _ { j , \mu } ^ { ( \ell - 1 ) } ( x ) [ n ] | ^ { 2 } \right| ^ { 4 } \right] } \end{array}
+$$
+
+This can be multiplied out, yielding a weighted sum of expectations of the form,
+
+$$
+\mathbb { E } \left[ | f _ { k , \nu } ^ { ( \ell - 1 ) } ( x ) [ n ] | ^ { p _ { 1 } } | f _ { l , \xi } ^ { ( \ell - 1 ) } ( x ) [ n ] | ^ { p _ { 2 } } | f _ { r , \pi } ^ { ( \ell - 1 ) } ( x ) [ n ] | ^ { p _ { 3 } } | f _ { q , \rho } ^ { ( \ell - 1 ) } ( x ) [ n ] | ^ { p _ { 4 } } \right]
+$$
+
+with $p _ { i } \in \{ 0 , 1 , 2 \}$ for $i = { 1 , 2 , 3 , 4 }$ , and $k , l , r , q \in \{ 1 , \dots , C ^ { ( \ell - 1 ) } ( n ) \}$ , and $\nu , \xi , \pi , \rho \in \mu \mathrm { t h }$ patch where the weights of these terms are independent of (2018b), each of these terms is bounded if the eighth mo $n$ . Usinents of in Matthews et al.are bounded, which $f _ { k , \mu } ^ { ( \ell - 1 ) } ( x ) [ n ]$ $\left( 2 C ^ { ( \ell - 1 ) } ( n ) | \mu \mathrm { t h } \mathrm { p a t c h } | \right) ^ { 4 }$ , where $| \mu \mathrm { t h } \ p a \mathrm { t c h } |$ is the number of elements in a convolutional patch. Thus, we can use the same constant for any due to the $1 / \left( C ^ { ( \ell - 1 ) } ( n ) \right) ^ { 4 }$ scaling. As in Matthews et al. (2018b), noting that $f _ { j , \mu } ^ { ( \ell - 1 ) } ( x ) [ n ]$ are exchangeable over $j$ for any $x$ and $n$ concludes the proof. Using this result, we can obtain a straightforward adaptation of Lemmas 15, 16 and 21 in Matthews et al. (2018b). Lemma 15 gives condition b), Lemma 16 gives condition c); Lemma 15 requires uniform integrability, which is established by Lemma 21.
+
+# 7.3 CALIBRATION OF GAUSSIAN PROCESS UNCERTAINTY
+
+It is important to check that the estimates of uncertainty produced by our Gaussian process are reasonable. However, to make this assessment, we needed to use a proper likelihood, and not the squared-error loss in the main text. We therefore used our kernel to perform the full, multi-class classification problem in GPflow Matthews et al. (2017), with a RobustMax likelihood (Hernándezlobato et al., 2011). The more difficult non-conjugate inference problem forced us to use 1000 inducing points, randomly chosen from the training inputs. Both our kernel and an RBF kernel have similar calibration curves, that closely track the diagonal, indicating accurate uncertainty estimation. However, even in the inducing point setting, our convolutional kernel gave considerably better performance than the RBF kernel $2 . 4 \%$ error vs $3 . 4 \%$ error).
+
+![](images/8864ab9d76c33870f50470fe5185392a7878cda9c47764b2ab0ca5045ac895b3.jpg)  
+Figure 3: Calibration plots for an RBF kernel (left) and the ResNet kernel (right). The $\mathbf { X }$ -axis gives GP prediction for the label probability. The points give corresponding proportion of test points with that label, and the bars give the proportion of training examples in each bin.

parse/train/CuQoImkKkIj/CuQoImkKkIj.md

@@ -0,0 +1,336 @@
+# Robust and differentially private mean estimation
+
+Xiyang Liu, Weihao Kong, Sham Kakade, Sewoong Oh
+
+Paul G. Allen School of Computer Science and Engineering, University of Washington {xiyangl,whkong,sham,sewoong}@cs.washington.edu
+
+# Abstract
+
+In statistical learning and analysis from shared data, which is increasingly widely adopted in platforms such as federated learning and meta-learning, there are two major concerns: privacy and robustness. Each participating individual should be able to contribute without the fear of leaking one’s sensitive information. At the same time, the system should be robust in the presence of malicious participants inserting corrupted data. Recent algorithmic advances in learning from shared data focus on either one of these threats, leaving the system vulnerable to the other. We bridge this gap for the canonical problem of estimating the mean from i.i.d. samples. We introduce PRIME, which is the first efficient algorithm that achieves both privacy and robustness for a wide range of distributions. We further complement this result with a novel exponential time algorithm that improves the sample complexity of PRIME, achieving a near-optimal guarantee and matching a known lower bound for (non-robust) private mean estimation. This proves that there is no extra statistical cost to simultaneously guaranteeing privacy and robustness.
+
+# 1 Introduction
+
+When releasing database statistics on a collection of entries from individuals, we would ideally like to make it impossible to reverse-engineer each individual’s potentially sensitive information. Privacy-preserving techniques add just enough randomness tailored to the statistical task to guarantee protection. At the same time, it is becoming increasingly common to apply such techniques to databases collected from multiple sources, not all of which can be trusted. Emerging data access frameworks, such as federated analyses across users’ devices or data silos [50], make it easier to temper with such collected datasets, leaving private statistical analyses vulnerable to a malicious corruption of a fraction of the data.
+
+Differential privacy has emerged as a widely accepted de facto measure of privacy, which is now a standard in releasing the statistics of the U.S. Census data [2] statistics and also deployed in real-world commercial systems [74, 40, 41]. A statistical analysis is said to be differentially private (DP) if the likelihood of the (randomized) outcome does not change significantly when a single arbitrary entry is added/removed (formally defined in $\ S 1 . 2 )$ . This provides a strong privacy guarantee: even a powerful adversary who knows all the other entries in the database cannot confidently identify whether a particular individual is participating in the database based on the outcome of the analysis. This ensures plausible deniability, central to protecting an individual’s privacy.
+
+In this paper, we focus on one of the most canonical problems in statistics: estimating the mean of a distribution from i.i.d. samples. For distributions with unbounded support, such as sub-Gaussian and heavy-tailed distributions, fundamental trade-offs between accuracy, sample size, and privacy have only recently been identified [58, 52, 54, 3] and efficient private estimators proposed. However, these approaches are brittle when a fraction of the data is corrupted, posing a real threat, referred to as data poisoning attacks [19, 79]. In defense of such attacks, robust (but not necessarily private) statistics has emerged as a popular setting of recent algorithmic and mathematical breakthroughs [73, 30].
+
+One might be misled into thinking that privacy ensures robustness since DP guarantees that a single outlier cannot change the estimation too much. This intuition is true only in a low dimension; each sample has to be an obvious outlier to significantly change the mean. However, in a high dimension, each corrupted data point can look perfectly uncorrupted but still shift the mean significant when colluding together (e.g., see Fig. 1). Focusing on the canonical problem of mean estimation, we introduce novel algorithms that achieve robustness and privacy simultaneously even when a fraction of data is corrupted arbitrarily. For such algorithms, there is a fundamental question of interest: do we need more samples to make private mean estimation also robust against adversarial corruption?
+
+Sub-Gaussian distributions. If we can afford exponential run-time in the dimension, robustness can be achieved without extra cost in sample complexity. We introduce a novel estimator that (i) satisfies $( \varepsilon , \delta )$ -DP, $( i i )$ achieves near-optimal robustness under $\alpha$ -fraction of corrupted data, achieving accuracy of $O ( \alpha \sqrt { \log ( 1 / \alpha ) } )$ nearly matching the fundamental lower bound of $\Omega ( \alpha )$ that holds even for a (non-private) robust mean estimation with infinite samples, and $( i i i )$ achieves near-optimal sample complexity matching that of a fundamental lower bound for a (non-robust) private mean estimation as shown in Table 1.
+
+Theorem 1 (Informal Theorem 7, exponential time). Algorithm 2 is $( \varepsilon , \delta )$ -DP. When $\alpha$ fraction of the data is arbitrarily corrupted from $n$ samples from a $d$ -dimensional sub-Gaussian distribution with mean $\mu$ and an identity sub-Gaussian parameter, if $\begin{array} { r } { n = \widetilde \Omega ( d / \alpha ^ { 2 } + ( d + d ^ { 1 / 2 } \log ( 1 / \delta ) ) / ( \alpha \varepsilon ) ) } \end{array}$ then Algorithm 2 achieves $\| \hat { \mu } - \mu \| _ { 2 } = O ( \alpha \sqrt { \log ( 1 / \alpha ) } ) \ : w . h . p$ .
+
+We introduce PRIME (PRIvate and robust Mean Estimation) in $\ S 2 . 3$ with details in Algorithm 9 in Appendix E.1, to achieve computational efficiency. It requires a run-time of only $\widetilde { \cal O } ( d ^ { 3 } + n d ^ { 2 } )$ , but at the cost of requiring extra $d ^ { 1 / 2 }$ factor larger number of samples. This cannot be improved upon with current techniques since efficient robust estimators rely on the top PCA directions of the covariance matrix to detect outliers. [78] showed that $\widetilde \Omega ( d ^ { 3 / 2 } )$ samples are necessary to compute PCA directions while preserving $( \varepsilon , \delta )$ -DP when $\| x _ { i } \| _ { 2 } = O ( { \sqrt { d } } )$ . It remains an open question if this $\widetilde \Omega ( d ^ { 3 / 2 } / ( \alpha \varepsilon ) )$ bottleneck is fundamental; no matching lower bound is currently known.
+
+Theorem 2 (Informal Theorem 6, polynomial time). PRIME is $( \varepsilon , \delta )$ -DP and under the assumption of Thm.1, if $\begin{array} { r } { \dot { n } = \widetilde \Omega ( d / \alpha ^ { 2 } + ( d ^ { 3 / 2 } \log ( 1 / \delta ) ) / ( \alpha \varepsilon ) ) . } \end{array}$ , achieves $\begin{array} { r } { \| \hat { \mu } - \mu \| _ { 2 } = O ( \alpha \sqrt { \log ( 1 / \alpha ) } ) ~ w . h . p . } \end{array}$ .
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Upper bound (poly-time)</td><td rowspan=1 colspan=1>Upper bound (exp-time)</td><td rowspan=1 colspan=1>Lower bound</td></tr><tr><td rowspan=1 colspan=1>(ε,δ)-DP[52]</td><td rowspan=1 colspan=1>0+dlog1/2(1/8））Qε</td><td rowspan=1 colspan=1>+）</td><td rowspan=1 colspan=1>（+）</td></tr><tr><td rowspan=1 colspan=1>α-corruption [36]</td><td rowspan=1 colspan=1>0（</td><td rowspan=1 colspan=1>（</td><td rowspan=1 colspan=1>（</td></tr><tr><td rowspan=1 colspan=1>α-corruption and(ε,δ)-DP (this paper)</td><td rowspan=1 colspan=1>（+/210g(1/8）)αε[Theorem6]</td><td rowspan=1 colspan=1>0（+d+d1/210g(1/8))Q[Theorem7]</td><td rowspan=1 colspan=1>(）[52]</td></tr></table>
+
+Table 1: For estimating the mean $\mu \in \mathbb { R } ^ { d }$ of a sub-Gaussian distribution with a known covariance, we list the sufficient or necessary conditions on the sample sizes to achieve an error $\| \hat { \mu } - \mu \| _ { 2 } = \widetilde { O } ( \alpha )$ under $( \varepsilon , \delta )$ -DP, corruption of an $\alpha$ -fraction of samples, and both. √ $\clubsuit$ requires the distribution to be a Gaussian [14] and $\spadesuit$ requires $\delta \leq \sqrt { d } / n$ .
+
+Heavy-tailed distributions. When samples are drawn from a distribution with a bounded covariance, parameters of Algorithm 2 can be modified to nearly match the optimal sample complexity of (nonrobust) private mean estimation in Table 2. This algorithm also matches the fundamental limit on the accuracy of (non-private) robust estimation, which in this case is $\Omega ( \alpha ^ { 1 / 2 } )$ .
+
+Theorem 3 (Informal Theorem 8, exponential time). From a distribution with mean $\mu \in \mathbb { R } ^ { d }$ and covariance $\Sigma \preceq \mathbf { I }$ , $n$ samples are drawn and $\alpha$ -fraction is corrupted. Algorithm 2 is $( \varepsilon , \delta )$ -DP and $i f$ $n = \widetilde \Omega ( ( d + d ^ { 1 / 2 } \log ( 1 / \delta ) ) / ( \alpha \varepsilon ) + d ^ { 1 / 2 } \log ^ { 3 / 2 } ( 1 / \delta ) / \varepsilon )$ achieves $\| \hat { \mu } - \mu \| _ { 2 } = O ( \alpha ^ { 1 / 2 } ) \ : w . h . p .$ .
+
+The proposed PRIME-HT for covariance bounded distributions achieve computational efficiency at the cost of an extra factor of $d ^ { 1 / 2 }$ in sample size. This bottleneck is also due to DP PCA, and it remains open whether this gap can be closed by an efficient estimator.
+
+Theorem 4 (Informal Theorem 9, polynomial time). PRIME-HT is $( \varepsilon , \delta ) – D P$ and if $n \_ =$ $\widetilde \Omega ( ( d ^ { 3 / 2 } \log ( 1 / \delta ) ) / ( \alpha \varepsilon ) )$ achieves $\| \hat { \mu } - \mu \| _ { 2 } = O ( \alpha ^ { 1 / 2 } ) \ : w . h . p$ . under the assumptions of Thm. 3.
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Upper bound (poly-time)</td><td rowspan=1 colspan=1>Upper bound (exp-time)</td><td rowspan=1 colspan=1>Lower bound</td></tr><tr><td rowspan=1 colspan=1>(ε,δ)-DP [54]</td><td rowspan=1 colspan=1>O（d10g1/2（1/）Qε</td><td rowspan=1 colspan=1>O（d10g1/2（1/0））Qε</td><td rowspan=1 colspan=1>2（）</td></tr><tr><td rowspan=1 colspan=1>α-corruption [36]</td><td rowspan=1 colspan=1>）</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>(）</td></tr><tr><td rowspan=1 colspan=1>α-corruption and(ε,δ)-DP (this paper)</td><td rowspan=1 colspan=1>0（(/210g(1/8))αε[Theorem 9]</td><td rowspan=1 colspan=1>（+d1721g/2(18）αε[Theorem 8]</td><td rowspan=1 colspan=1>(([54])</td></tr></table>
+
+Table 2: For estimating the mean $\mu \in \mathbb { R } ^ { d }$ of a covariance bounded distribution, we list the sufficient or necessary conditions on the sample size to achieve an error $\| \hat { \mu } - \mu \| _ { 2 } = O ( \alpha ^ { 1 / 2 } )$ under $( \varepsilon , \delta )$ -DP, corruption of an $\alpha$ -fraction of samples, and both.
+
+# 1.1 Technical contributions
+
+We introduce PRIME which simultaneously achieves $( \varepsilon , \delta )$ -DP and robustness against $\alpha$ -fraction of corruption. A major challenge in making a standard filter-based robust estimation algorithm (e.g., [30]) private is the high sensitivity of the filtered set that we pass from one iteration to the next. We propose a new framework which makes private only the statistics of the set, hence significantly reducing the sensitivity. Our major innovation is a tight analysis of the end-to-end sensitivity of this multiple interactive accesses to the database. This is critical in achieving robustness while preserving privacy and is also of independent interest in making general iterative filtering algorithms private.
+
+The classical filter approach (see, e.g. [30]) needs to access the database √ $O ( d )$ times, which brings an extra $O ( { \sqrt { d } } )$ factor in the sample complexity due to DP composition. In order to reduce the iteration complexity, following the approach in [36], we propose filtering multiple directions simultaneously using a new score based on the matrix multiplicative weights (MMW). In order to privatize the MMW filter, our major innovation is a novel adaptive filtering algorithm DPTHRESHOLD(·) that outputs a single private threshold which guarantees sufficient progress at every iteration. This brings the number of database accesses from $O ( d )$ to $O ( ( \log d ) ^ { 2 } )$ .
+
+One downside of PRIME is that it requires an extra $d ^ { 1 / 2 }$ factor in the sample complexity, compared to known lower bounds for (non-robust) DP mean estimation. To investigate whether this is also necessary, we propose a sample optimal exponential time robust mean estimation algorithm in $\ S 4$ and prove that there is no extra statistical cost to jointly requiring privacy and robustness. Our major technical innovations is in using resilience property of the dataset to not only find robust mean (which is the typical use case of resilience) but also bound sensitivity of that robust mean.
+
+# 1.2 Preliminary on differential privacy (DP)
+
+DP is a formal metric for measuring privacy leakage when a dataset is accessed with a query [37].
+
+Definition 1.1. Given two datasets $S = \{ x _ { i } \} _ { i = 1 } ^ { n }$ and $S ^ { \prime } = \{ x _ { i } ^ { \prime } \} _ { i = 1 } ^ { n ^ { \prime } }$ , we say $S$ and $S ^ { \prime }$ are neighboring $i f d _ { \triangle } ( S , S ^ { \prime } ) \leq 1$ where $d _ { \triangle } ( S , S ^ { \prime } ) \triangleq \operatorname* { m a x } \{ | S \setminus S ^ { \prime } | , | S ^ { \prime } \setminus S | \}$ , which is denoted by $S \sim S ^ { \prime }$ . For an output of a stochastic query q on a database, we say q satisfies $( \varepsilon , \delta )$ -differential privacy for some $\varepsilon > 0$ and $\delta \in ( 0 , 1 )$ i $\begin{array} { r } { \textstyle f \mathbb { P } ( q ( S ) \in A ) \le e ^ { \varepsilon } \mathbb { P } ( q ( S ^ { \prime } ) \in A ) + \delta } \end{array}$ for all $S \sim S ^ { \prime }$ and all subset $A$ .
+
+Let $z \sim \mathrm { L a p } ( b )$ be a random vector with entries i.i.d. sampled from Laplace distribution with pdf $( 1 / 2 b ) e ^ { - | z | / b }$ . Let $z \sim \mathcal { N } ( \mu , \Sigma )$ denote a Gaussian random vector with mean $\mu$ and covariance $\Sigma$ .
+
+Definition 1.2. The sensitivity of a query $f ( S ) ~ \in ~ \mathbb { R } ^ { k }$ is defined as $\Delta _ { p } ~ = ~ \operatorname* { s u p } _ { S \sim S ^ { \prime } } \| f ( S ) ~ -$ $f ( S ^ { \prime } ) \| _ { p }$ for a norm $\begin{array} { r } { \| { \boldsymbol x } \| _ { p } ~ = ~ ( \sum _ { i \in [ k ] } | x _ { i } | ^ { p } ) ^ { 1 / p } } \end{array}$ . For $p ~ = ~ 1$ , the Laplace mechanism outputs $f ( S ) + \mathrm { L a p } ( { \Delta _ { 1 } } / { \varepsilon } )$ and achieves $( \varepsilon , 0 ) – D P \ : I 3 7 J$ . For $p = 2$ , the Gaussian mechanism outputs $f ( S ) + \mathcal { N } ( 0 , ( \Delta _ { 2 } ( \sqrt { 2 \log ( 1 . 2 5 / \delta ) } ) / \varepsilon ) ^ { 2 } \mathbf { I } )$ and achieves $( \varepsilon , \delta ) – D P / 3 8 J$ .
+
+We use these output perturbation mechanisms along with the exponential mechanism [69] as building blocks. Appendix A provides detailed survey of privacy and robust estimation.
+
+# 1.3 Problem formulation
+
+We are given $n$ samples from a sub-Gaussian distribution with a known covariance but unknown mean, and $\alpha$ fraction of the samples are corrupted by an adversary. Our goal is to estimate the unknown mean. We follow the standard definition of adversary in [30], which can adaptively choose which samples to corrupt and arbitrarily replace them with any points.
+
+Assumption 1. An uncorrupted dataset $S _ { \mathrm { g o o d } }$ consists of $n$ i.i.d. samples from a $d$ -dimensional sub-Gaussian distribution with mean $\mu \in \mathbb { R } ^ { d }$ and covariance $\mathbb { E } [ x x ^ { \top } ] = \mathbf { I } _ { d } ,$ , which is 1-sub-Gaussian, i.e., $\mathbb { E } [ \exp ( v ^ { \top } x ) ] \leq \exp ( \| v \| _ { 2 } ^ { 2 } / 2 )$ for all $v \in \mathbb { R } ^ { d }$ . For some $\alpha \in ( 0 , 1 / 2 )$ , we are given a corrupted dataset $S = \{ x _ { i } \in \mathbb { R } ^ { d } \} _ { i = 1 } ^ { n }$ where an adversary adaptively inspects all the samples in $S _ { \mathrm { g o o d } }$ , removes αn of them, and replaces them with $S _ { \mathrm { b a d } }$ which are αn arbitrary points in $\mathbb { R } ^ { d }$ .
+
+Similarly, we consider the same problem for heavy-tailed distributions with a bounded covariance.   
+We present the assumption and main results for covariance bounded distributions in Appendix B.
+
+Notations. Let $[ n ] = \{ 1 , 2 , \dots , n \}$ . For $x \in \mathbb { R } ^ { d }$ , we use $\textstyle \| x \| _ { 2 } = ( \sum _ { i \in [ d ] } ( x _ { i } ) ^ { 2 } ) ^ { 1 / 2 }$ to denote the Euclidean norm. For $X \in \mathbb { R } ^ { d \times d }$ , we use $\begin{array} { r } { \| X \| _ { 2 } = \operatorname* { m a x } _ { \| v \| _ { 2 } = 1 } \| X v \| _ { 2 } } \end{array}$ to denote the spectral norm. The $d \times d$ identity matrix is $\mathbf { I } _ { d \times d }$ . Whenever it is clear from context, we use $S$ to denote both a set of data points and also the set of indices of those data points. $\widetilde O$ and $\widetilde \Omega$ hide poly-logarithmic factors in $d , n , 1 / \alpha$ , and the failure probability.
+
+Outline. We present PRIME for sub-Gaussian distribution in $\ S 2$ , and present theoretical analysis in $\ S 3$ . We then introduce an exponential time algorithm with near optimal guarantee in $\ S 4$ . Due to space constraints, analogous results for heavy-tailed distributions are presented in Appendix B.
+
+# 2 PRIME: efficient algorithm for robust and DP mean estimation
+
+In order to describe the proposed algorithm PRIME, we need to first describe a standard (non-private) iterative filtering algorithm for robust mean estimation.
+
+# 2.1 Background on (non-private) iterative filtering for robust mean estimation
+
+Non-private robust mean estimation approaches recursively apply the following filter, whose framework is first proposed in [28]. Given a dataset $S = \{ x _ { i } \} _ { i = 1 } ^ { n }$ , the current set $S _ { 0 } \subseteq [ n ]$ of data points is updated starting with $S _ { 1 } = [ n ]$ . At each step, the following filter (Algorithm 1 in [63]) attempts to detect the corrupted data points and remove them.
+
+1. Compute the top eigenvector $v _ { t } \gets \arg \operatorname* { m a x } _ { v : \| v \| _ { 2 } = 1 } v ^ { \top } \mathrm { C o v } ( S _ { t - 1 } ) v$ of the covariance of the current data set $\{ x _ { i } \} _ { i \in S _ { t - 1 } }$ ;   
+2. Compute scores for all data points $j \in S _ { t - 1 } \colon \tau _ { j } \gets \left( v _ { t } ^ { \top } \left( x _ { j } - \mathrm { M e a n } ( S _ { t - 1 } ) \right) \right) ^ { 2 } \ ;$   
+3. Draw a random threshold: $Z _ { t } \gets \mathrm { U n i f } ( [ 0 , 1 ] )$ ;   
+4. Remove outliers from $S _ { t - 1 }$ defined as $\{ i \in S _ { t - 1 } : \tau _ { i }$ is in the largest $2 \alpha$ -tail of $\{ \tau _ { j } \} _ { j \in S _ { t - 1 } }$ and $\tau _ { i } \geq Z _ { t } \tau _ { \operatorname* { m a x } } \}$ , where $\tau _ { \mathrm { m a x } } = \operatorname* { m a x } _ { j \in S _ { t - 1 } } \tau _ { j }$
+
+This is repeated until the empirical covariance is sufficiently small and the empirical mean $\hat { \mu }$ is output. At a high level, the correctness of this algorithm relies on the key observation that the $\alpha$ -fraction of adversarial corruption can not significantly change the mean of the dataset without introducing large eigenvalues in the empirical covariance. Therefore, the algorithm finds top eigenvector of the empirical covariance in step 1, and tries to correct the empirical covariance by removing corrupted data points. Each data point is assigned a score in step 2 which indicates the “badness” of the data points, and a threshold $Z _ { t }$ in step 3 is carefully designed such that step 4 guarantees to remove more corrupted data points than good data points (in expectation). This guarantees the following bound achieving the near-optimal sample complexity shown in the second row of Table 1. A formal description of this algorithm is in Algorithm 4 in Appendix C.
+
+Proposition 2.1 (Corollary of [63, Theorem 2.1]). Under assumption $^ { l }$ , the above filtering algorithm achieves accuracy $\| \hat { \mu } - \mu \| _ { 2 } \le O ( \alpha \sqrt { \log ( 1 / \alpha ) } ) \ w . p . \ 0 . 9 i f n \ge \widetilde { \Omega } ( d / \alpha ^ { 2 } ) \ / .$ .
+
+Challenges in making robust mean estimation private. To get a DP and robust mean, a naive attempt is to apply a standard output perturbation mechanism to $\hat { \mu }$ . However, this is obviously challenging since the end-to-end sensitivity is intractable. The standard recipe to circumvent this is to make the current “state” $S _ { t }$ private at every iteration. Once $S _ { t - 1 }$ is private (hence, public knowledge), making the next “state” $S _ { t }$ private is simpler. We only need to analyze the sensitivity of a single step and apply some output perturbation mechanism with $\left( \varepsilon _ { t } , \delta _ { t } \right)$ . End-to-end privacy is guaranteed by accounting for all these $\left( \varepsilon _ { t } , \delta _ { t } \right)$ ’s using the advanced composition [51]. This recipe has been quite successful, for example, in training neural networks with (stochastic) gradient descent [1], where the current state can be the optimization variable $\mathbf { x } _ { t }$ . However, for the above (non-private) filtering algorithm, this standard recipe fails, since the state $S _ { t }$ is a set and has large sensitivity. Changing a single data point in $S _ { t }$ can significantly alter which (and how many) samples are filtered out.
+
+# 2.2 A new framework for private iterative filtering
+
+Instead of making the (highly sensitive) $S _ { t }$ itself private, we propose a new framework which makes private only the statistics of $S _ { t }$ : the mean $\mu _ { t }$ and the top principal direction $v _ { t }$ . There are two versions of this algorithm, which output the exactly same $\hat { \mu }$ with the exactly same privacy guarantees, but are written from two different perspectives. We present here the interactive version from the perspective of an analyst accessing the dataset via DP queries $\cdot q _ { \mathrm { r a n g e } }$ , $q _ { \mathrm { s i z e } }$ , $q _ { \mathrm { m e a n } }$ , $q _ { \mathrm { n o r m } }$ and $q _ { \mathrm { P C A } } ,$ ), because this version makes clear the inner operations of each private mechanisms, hence making $( i )$ the sensitivity analysis transparent, $( i i )$ checking the correctness of privacy guarantees easy, and $( i i i )$ tracking privacy accountant simple. In practice, one should implement the centralized version (Algorithm 7 in Appendix D), which is significantly more efficient.
+
+# Algorithm 1: Private iterative filtering (interactive version)
+
+Input: $S = \{ x _ { i } \} _ { i \in [ n ] }$ , $\alpha \in ( 0 , 1 / 2 )$ , probability $\zeta \in ( 0 , 1 )$ , # of iterations $T = \Theta ( d ) , ( \varepsilon , \delta )$   
+1 $( \bar { x } , B ) \gets q _ { \mathrm { r a n g e } } ( S , 0 . 0 1 \varepsilon , 0 . 0 1 \delta )$   
+2 $\varepsilon _ { 1 } \gets \operatorname* { m i n } \{ 0 . 9 9 \varepsilon , 0 . 9 \} / ( 4 \sqrt { 2 T \log ( 2 / \delta ) } )$ ), δ1 ← 0.99δ/(8T )   
+3 if $n < ( 4 / \varepsilon _ { 1 } ) \log ( 1 / ( 2 \delta _ { 1 } ) )$ then Output: $\varnothing$   
+4 for $t = 1 , \dots , T$ do   
+5 $n _ { t }  q _ { \mathrm { s i z e } } ( \{ ( \mu _ { \ell } , v _ { \ell } , Z _ { \ell } ) \} _ { \ell \in [ t - 1 ] } , \varepsilon _ { 1 } , \bar { x } , B )$ , if $n _ { t } < 3 n / 4$ then Output: $\varnothing$   
+6 $\mu _ { t }  q _ { \mathrm { m e a n } } ( \{ ( \mu _ { \ell } , v _ { \ell } , Z _ { \ell } ) \} _ { \ell \in [ t - 1 ] } , \varepsilon _ { 1 } , \bar { x } , B )$   
+7 $\lambda _ { t } \gets q _ { \mathrm { n o r m } } ( \{ ( \mu _ { \ell } , v _ { \ell } , Z _ { \ell } ) \} _ { \ell \in [ t - 1 ] } , \mu _ { t } , \varepsilon _ { 1 } , \bar { x } , B )$   
+8 if $\lambda _ { t } \le ( C - 0 . 0 1 ) \alpha \log { 1 / \alpha }$ then Output: $\mu _ { t }$   
+9 $\boldsymbol { v } _ { t }  q _ { \mathrm { P C A } } ( \{ ( \mu _ { \ell } , v _ { \ell } , Z _ { \ell } ) \} _ { \ell \in [ t - 1 ] } , \mu _ { t } , \varepsilon _ { 1 } , \delta _ { 1 } , \bar { x } , B ) )$   
+10 $Z _ { t } \gets \mathrm { U n i f } ( [ 0 , 1 ] )$
+
+# Output: $\mu _ { t }$
+
+We give a high-level explanation of each step of Algorithm 1 here and give the formal definitions of all the queries in Appendix D. First, $q _ { \mathrm { r a n g e } }$ returns (the parameters of) a hypercube $\bar { x } + [ - B / 2 , B / 2 ] ^ { d }$ that is guaranteed to include all uncorrupted samples while preserving privacy. This is achieved by running $d$ coordinate-wise private histograms and selecting $\bar { x } _ { j }$ as the center of the largest bin for the $j$ -th coordinate. Since covariance is I, $q _ { \mathrm { r a n g e } }$ returns a fixed $B = 8 \sigma \sqrt { \log ( d n / \zeta ) }$ . Such an adaptive estimate of the support is critical in tightly bounding the sensitivity of all subsequent queries, which operate on the clipped dataset; all data points are projected as $\mathcal { P } _ { \bar { x } + [ - B / 2 , B / 2 ] ^ { d } } ( x ) =$ arg $\begin{array} { r } { \operatorname* { m i n } _ { y \in \bar { x } + [ - B / 2 , B / 2 ] ^ { c } } } \end{array}$ $\lVert y - x \rVert _ { 2 }$ in all the queries that follow. With clipping, a single data point can now change at most by $B \sqrt { d }$ .
+
+The subsequent steps perform the non-private filtering algorithm of $\ S 2 . 1$ , but with private statistics $\mu _ { t }$ and $v _ { t }$ . As the set $S _ { t }$ changes over time, we lower bound its size (which we choose to be $| S _ { t } | > n / 2 )$ ) to upper bound the sensitivity of other queries $q _ { \mathrm { m e a n } } , q _ { \mathrm { n o r m } }$ and $q _ { \mathrm { P C A } }$ .
+
+At the $t$ -th iterations, every time a query is called the data curator $( i )$ uses $( { \bar { x } } , B )$ to clip the data, $( i i )$ computes $S _ { t }$ by running $t - 1$ steps of the non-private filtering algorithm of $\ S 2 . 1$ but with a given fixed set of parameters $\{ ( \mu _ { \ell } , v _ { \ell } ) \} _ { \ell \in [ t - 1 ] }$ (and the given randomness $\{ Z _ { \ell } \} _ { \ell \in [ t - 1 ] } )$ , and $( i i i )$ computes the queried private statistics of $S _ { t }$ . If the private spectral norm of the covariance of $S _ { t }$ (i.e., $\lambda _ { t } ,$ ) is sufficiently small, we output the private and robust mean $\hat { \mu } = \mu _ { t }$ (line 8). Otherwise, we compute the private top PCA direction $v _ { t }$ and draw an randomness $Z _ { t }$ to be used in the next step of filtering, as in the non-private filtering algorithm. We emphasize that $\{ S _ { \ell } \}$ are not private, and hence never returned to the analyst. We also note that this interactive version is redundant as every query is re-computing $S _ { t }$ . In our setting, the analyst has the dataset and there is no need to separate them. This leads to a centralized version we provide in Algorithm 7 in the appendix, which avoids redundant computations and hence is significantly more efficient.
+
+The main challenge in this framework is the privacy analysis. Because $\{ S _ { \ell } \} _ { \ell \in [ t - 1 ] }$ is not private, each query runs $t - 1$ steps of filtering whose end-to-end sensitivity could blow-up. Algorithmically, $( i )$ we start with a specific choice of a non-private iterative filtering algorithm (among several variations that are equivalent in non-private setting but widely differ in its sensitivity), and $( i i )$ make appropriate changes in the private queries (Algorithm 1) to keep the sensitivity small. Analytically, the following key technical lemma allows a sharp analysis of the end-to-end sensitivity of iterative filtering.
+
+Lemma 2.2. Let $S _ { t } ( S )$ denote the resulting subset of samples after $t$ iterations of the filtering in the queries $( q _ { \mathrm { s i z e } }$ , $q _ { \mathrm { m e a n } }$ , $q _ { \mathrm { n o r m } }$ , and $q _ { \mathrm { P C A } } )$ are applied to a dataset $s$ using fixed parameters $\{ ( \mu _ { \ell } , v _ { \ell } , Z _ { \ell } ) \} _ { \ell = 1 } ^ { t }$ . Then, we have $d _ { \triangle } ( S _ { t } ( S ) , S _ { t } ( S ^ { \prime } ) ) \leq d _ { \triangle } ( S , S ^ { \prime } )$ , where $d _ { \triangle } ( S , S ^ { \prime } ) \triangleq \operatorname* { m a x } \{ | S \ \backslash$ $S ^ { \prime } | , | S ^ { \prime } \backslash S | \}$ .
+
+Recall that two datasets are neighboring, i.e., $\boldsymbol { S } \sim \boldsymbol { S } ^ { \prime }$ , iff $d _ { \triangle } ( S , S ^ { \prime } ) \leq 1$ . This lemma implies that if two datasets are neighboring, then they are still neighboring after filtering with the same parameters, no matter how many times we filter them. Hence, this lemma allows us to use the standard outputperturbation mechanisms with $( \varepsilon _ { 1 } , \delta _ { 1 } )$ -DP. Advanced composition ensures that end-to-end guarantee of $4 T$ such queries is $( 0 . 9 9 \varepsilon , 0 . 9 9 \delta )$ -DP. Together with $( 0 . 0 1 \varepsilon , 0 . 0 1 \delta )$ -DP budget used in $q _ { \mathrm { r a n g e } }$ , this satisfied the target privacy. Analyzing the utility of this algorithm, we get the following guarantee.
+
+Theorem 5. Algorithm $^ { l }$ is $( \varepsilon , \delta )$ -DP. Under Assumption $^ { l }$ , there exists a universal constant $c \in$ $( 0 , 0 . 1 )$ such that if $\alpha \leq c$ and $n = \widetilde \Omega \left( ( d / \alpha ^ { 2 } ) + d ^ { 2 } ( \log ( 1 / \delta ) ) ^ { 3 / 2 } / ( \varepsilon \alpha ) \right)$ then Algorithm 1 achieves $\| \hat { \mu } - \mu \| _ { 2 } \leq O ( \alpha \sqrt { \log ( 1 / \alpha ) } )$ with probability 0.9.
+
+The first term $O ( d / \alpha ^ { 2 } )$ in the sample complexity is optimal (cf. Table 1), but there is a factor of $d$ gap in the second term. This is due to the fact that we need to run $O ( d )$ iterations in the worst-case. Such numerous accesses to the database result in large noise to be added at each iteration, requiring large sample size to combat that extra noise. We introduce PRIME to reduce the number of iterations to ${ \bar { O } } ( ( \log { d } ) ^ { 2 } )$ and significantly reduce the sample complexity.
+
+# 2.3 PRIME: novel robust and private mean estimator
+
+Algorithm 1 (specifically Filter(·) in Algorithm 1) accesses the database $O ( d )$ times. This is necessary for two reasons. First, the filter checks only one direction $v _ { t }$ at each iteration. In the worst case, the corrupted samples can be scattered in $\Omega ( d )$ orthogonal directions such that the filter needs to be repeated $O ( d )$ times. Secondly, even if the corrupted samples are clustered together in one direction, the filter still needs to be repeated $O ( d )$ times. This is because we had to use a large (random) threshold of $d B ^ { 2 } Z _ { t } = { \cal { O } } ( d )$ to make the threshold data-independent so that we can keep the sensitivity of Filter(·) low, which results in slow progress. We propose filtering multiple directions simultaneously using a new score $\{ \tau _ { i } \}$ based on the matrix multiplicative weights. Central to this approach is a novel adaptive filtering algorithm DPTHRESHOLD $( \cdot )$ that guarantees sufficient decrease in the total score at every iteration.
+
+# 2.3.1 Matrix Multiplicative Weight (MMW) scoring
+
+The MMW-based approach, pioneered in [36] for non-private robust mean estimation, filters out multiple directions simultaneously. It runs over $O ( \log d )$ epochs and every epoch consists of $O ( \log d )$ iterations. At every epoch $s$ and iteration $t$ , step 2 of the iterative filtering in $\ S 2 . 1$ is replaced by a new score $\tau _ { i } = ( x _ { i } - \mathrm { M e a n } ( S _ { t } ^ { ( s ) } ) ) ^ { T } U _ { t } ^ { ( s ) } ( x _ { i } - \mathrm { M e a n } ( S _ { t } ^ { ( s ) } ) )$ where $U _ { t } ^ { ( s ) }$ now accounts for all directions in $\mathbb { R } ^ { d }$ but appropriately weighted. Precisely, it is defined via the matrix multiplicative update:
+
+$$
+U _ { t } ^ { ( s ) } = \frac { \exp \left( \alpha ^ { ( s ) } \sum _ { r \in [ t ] } ( \mathrm { C o v } ( S _ { r } ^ { ( s ) } ) - { \bf I } ) \right) } { \mathrm { T r } \big ( \exp ( \alpha ^ { ( s ) } \sum _ { r \in [ t ] } ( \mathrm { C o v } ( S _ { r } ^ { ( s ) } ) - { \bf I } ) ) \big ) } ,
+$$
+
+for some choice of $\alpha ^ { ( s ) } > 0$ . If we set the number of iterations to one, a choice of $\alpha ^ { ( s ) } = \infty$ recovers the previous score that relied on the top singular vector from $\ S 2 . 1$ and a choice of $\alpha ^ { ( s ) } = 0$ gives a simple norm based score $\tau _ { i } = \| x _ { i } \| _ { 2 } ^ { 2 }$ . An appropriate choice of $\alpha ^ { ( s ) }$ smoothly interpolates between these two extremes, which ensures that $O ( \log d )$ iterations are sufficient for the spectral norm of the covariance to decrease strictly by a constant factor. This guarantees that after $O ( \log d )$ epochs, we sufficiently decrease the covariance to ensure that the empirical mean is accurate enough. Critical in achieving this gain is our carefully designed filtering algorithm DPTHRESHOLD that uses the privately computed MMW-based scores using Gaussian mechanism on the covariance matrices as shown in Algorithm 11 in Appendix E.
+
+# 2.3.2 Adaptive filtering with DPTHRESHOLD
+
+Novelty. The corresponding non-private filtering of [36, Algorithm 9] for robust mean estimation takes advantage of an adaptive threshold, but filters out each sample independently resulting in a prohibitively large sensitivity; the coupling between each sample and the randomness used to filter it can change widely between two neighboring datasets. On the other hand, Algorithm 1 (i.e., Filter(·) in Algorithm 6) takes advantage of jointly filtering all points above a single threshold $B ^ { 2 } d Z _ { t }$ with a single randomness $Z _ { t } \sim \mathrm { U n i f } [ 0 , 1 ]$ , but the non-adaptive (and hence large) choice of the range $B ^ { 2 } d$ results in a large number of iterations because each filtering only decrease the score by little. To sufficiently reduce the total score while maintaining a small sensitivity, we introduce a filter with a single and adaptive threshold.
+
+Algorithm. Our goal here is to privately find a single scalar $\rho$ such that when a randomized filter is applied on the scores $\{ \tau _ { i } \}$ with a (random) threshold $\rho Z$ (with $Z$ drawn uniform in $[ 0 , 1 ] )$ , we filter out enough samples to make progress in each iteration while ensuring that we do not remove too many uncorrupted samples. This is a slight generalization of the non-private algorithm in Section 2.1, which simply set $\rho = \operatorname* { m a x } _ { j \in S _ { t } } \tau _ { j }$ . While this guarantees the filter removes more corrupted samples than good samples, it does not make sufficient progress in reducing the total score of the samples.
+
+Ideally, we want the thresholding to decrease the total score by a constant multiplicative factor, which will in the end allow the algorithm to terminate within logarithmic iterations. To this end, we propose a new scheme of using the largest $\rho$ such that the following inequality holds:
+
+$$
+\sum _ { \tau _ { i } > \rho } ( \tau _ { i } - \rho ) \geq 0 . 3 1 \sum _ { \tau _ { i } \in S _ { t } } ( \tau _ { i } - 1 ) .
+$$
+
+We use a private histogram of the scores to approximate this threshold. Similar to [55, 58], we use geometrically increasing bin sizes such that we use only $O ( \log B ^ { 2 } d )$ bins while achieving a preferred multiplicative error in our quantization. At each epoch $s$ and iteration $t$ , we run DPTHRESHOLD sketched in the following to approximate $\rho$ followed by a random filter. Step 3 replaces the non-private condition in Eq. (1). A complete description is provided in Algorithm 11.
+
+1. Privately compute scores for all data points $i \in S _ { t } ^ { ( s ) } : \tau _ { i } \gets ( x _ { i } - \mu _ { t } ) ^ { \top } U _ { t } ^ { ( s ) } ( x _ { i } - \mu _ { t } ) ;$ ;   
+2. Compute a private histogram $\{ \tilde { h } _ { j } \} _ { j = 1 } ^ { 2 + \log ( B ^ { 2 } d ) }$ t i  i  t  t i  t of the scores over geometrically sized bins   
+$I _ { 1 } = [ 1 / 4 , 1 / 2 )$ , $I _ { 2 } = [ 1 / 2 , 1 ) , \ldots , \bar { I } _ { 2 + \log ( B ^ { 2 } d ) } = [ 2 ^ { \log ( B ^ { 2 } d ) - 1 } , 2 ^ { \log ( B ^ { 2 } d ) } ]$ ;   
+3. Privately find the largest $\ell$ satisfying $\begin{array} { r } { \sum _ { j \ge \ell } ( 2 ^ { j } - 2 ^ { \ell } ) \tilde { h } _ { j } \ge 0 . 3 1 \sum _ { i \in S _ { t } ^ { ( s ) } } ( \tau _ { i } - 1 ) ; } \end{array}$ ;   
+4. Output $\rho = 2 ^ { \ell }$ .
+
+# 3 Analyses of PRIME
+
+Building on the framework of Algorithm 1, PRIME (Algorithm 9) replaces the score with the MMWbased score presented in $\ S 2 . 3 . 1$ and the filter with the adaptive DPTHRESHOLD. This reduces the number of iterations to $T = O ( ( \log d ) ^ { 2 } )$ achieving the following bound.
+
+Theorem 6. PRIME is $( \varepsilon , \delta )$ -differentially private. Under Assumption $I$ there exists a universal constant $c \in ( 0 , 0 . 1 )$ such that if $\alpha \leq c$ and $n = \widetilde \Omega ( ( d / \alpha ^ { 2 } ) + ( d ^ { 3 / 2 } / ( \varepsilon \alpha ) ) \log ( 1 / \delta ) )$ , then PRIME achieves $\| \hat { \mu } - \mu \| _ { 2 } = O ( \alpha \sqrt { \log ( 1 / \alpha ) } )$ with probability 0.9.
+
+A proof is provided in Appendix F. The notation $\widetilde { \Omega } ( \cdot )$ hides logarithmic terms in $d , R$ , and $1 / \alpha$ . To achieve an error of $O ( \alpha \sqrt { \log ( 1 / \alpha ) } )$ , the first term $\widetilde \Omega ( d / \alpha ^ { 2 } \log ( 1 / \alpha ) )$ is necessary even if there is no corruption. The accuracy of $O ( \alpha \sqrt { \log ( 1 / \alpha ) } )$ matches the lower bound shown in [33] for any polynomial time statistical query algorithm, and it nearly matches the information theoretical lower bound on robust estimation of $\Omega ( \alpha )$ . On the other hand, the second term of $\widetilde \Omega ( d ^ { 3 / 2 } / ( \varepsilon \alpha \log ( 1 / \alpha ) ) )$
+
+has an extra factor of $d ^ { 1 / 2 }$ compared to the optimal one achieved by exponential time Algorithm 2. It is an open question if this gap can be closed by a polynomial time algorithm.
+
+The bottleneck is the private matrix multiplicative weights. Such spectral analyses are crucial in filter-based robust estimators. Even for a special case of privately computing the top principal component, the best polynomial time algorithm requires $\bar { O } ( d ^ { 3 / 2 } )$ samples [39, 18, 78], and this sample complexity is also necessary as shown in [39, Corollary 25].
+
+To boost the success probability to $1 - \zeta$ for some small $\zeta > 0$ , we need an extra $\log ( 1 / \zeta )$ factor in the sample complexity to make sure the dataset satisfies the regularity condition with probability $\zeta / 2$ . Then we can run PRIME $\log ( 1 / \zeta )$ times and choose the output of a run that satisfies $n ^ { ( s ) } > n ( 1 { - } 1 0 \alpha )$ and $\lambda ^ { ( s ) } \le C \alpha \log ( 1 / \alpha )$ at termination.
+
+![](images/46a53c55cd9bcc36cd60657375546149f2ff820d7058a98083ffc81ea44ac394.jpg)  
+Figure 1: Private mean estimators (e.g., DP mean [52]) are vulnerable to adversarial corruption especially in high dimensions, while the proposed PRIME achieves robustness (and privacy) regardless of the dimension of the samples.
+
+Numerical experiments support our theoretical claims. The left figure with $( \alpha , \varepsilon , \delta , n ) \ =$ $( 0 . 0 5 , 2 0 , 0 . 0 1 , 1 0 ^ { 6 } )$ is in the large $\alpha$ regime where the DP Mean error is dominates by $\alpha \sqrt { d }$ and PRIME error by $\alpha \sqrt { \log ( 1 / \alpha ) }$ . Hence, PRIME error is constant whereas DP Mean error increases with the dimension $d$ . The second figure with √ $( \alpha , \varepsilon , \delta , n ) = ( 0 . 0 0 1 , 2 0 , 0 . 0 1 , 1 0 ^ { 6 } )$ is in the small $\alpha$ regime when DP Mean error consists of $\alpha \sqrt { d } + \sqrt { d / n }$ and PRIME is dominated by $\sqrt { d / n }$ . Both increase with the dimension $d$ , and the gap can be made large by increasing $\alpha$ . The right figure√ with $( \alpha , \delta , d , n ) = ( 0 . 1 , 0 . 0 1 , 1 0 , 1 0 ^ { 6 } )$ is when DP Mean error is dominated by $\alpha \sqrt { d }$ and PRIME by $\alpha \sqrt { \log ( 1 / \alpha ) }$ when $\varepsilon > c d ^ { 1 . 5 } / ( \alpha n )$ . Below this threshold, which happens in this example around $\varepsilon = 0 . 0 5$ , the added noise in the private mechanism starts to dominate with decreasing $\varepsilon$ . Both algorithms have respective thresholds below which the error increases with decreasing $\varepsilon$ . This threshold is larger for PRIME because it uses the privacy budget to perform multiple operations and hence the noise added to the final output is larger compared to DP Mean. Below this threshold, which can be easily determined based on the known parameters $( \varepsilon , \delta , n , \alpha )$ , we should either collect more data (which will decrease the threshold) or give up filtering and spend all privacy budget on $q _ { \mathrm { r a n g e } }$ and the empirical mean (which will reduce the error). Details of the experiments are in Appendix L.
+
+# 4 Exponential time algorithm with near-optimal sample complexity
+
+Novelty. An existing exponential time algorithm for robust and private mean estimation in [14] strictly requires the uncorrupted samples to be drawn from a Gaussian distribution. We also provide a similar algorithm based on private Tukey median in Appendix I and its analysis in Appendix J. In this section, we introduce a novel estimator that achieves near-optimal guarantees for more general sub-Gaussian distributions (and also covariance bounded distributions) but takes an exponential run-time. Its innovation is in leveraging on the resilience property of well-behaved distributions not only to estimate the mean robustly (which is the standard use of the property) but also to adaptively bound the sensitivity of the estimator, thus achieving optimal privacy-accuracy tradeoff.
+
+Definition 4.1 (Resilience from Definition 1 in [73]). $A$ set of points $\{ x _ { i } \} _ { i \in S }$ lying in $\mathbb { R } ^ { d }$ is $( \sigma , \alpha )$ - resilient around a point $\mu$ $\begin{array} { r } { . i f \| ( 1 / | T | ) \sum _ { i \in T } ( x _ { i } - \mu ) \| _ { 2 } \leq \sigma } \end{array}$ for all subsets $T \subset S$ of size $( 1 - \alpha ) | S |$ .
+
+Algorithm. As data is corrupted, we define $R ( S )$ as a surrogate for resilience of the uncorrupted part of the set. If $S$ indeed consists of a $1 - \alpha$ fraction of independent samples from the promised class of distributions, the goodness score $R ( S )$ will be close to the resilience property of the good data.
+
+Definition 4.2 (Goodness of a set). For $\mu ( S ) = ( 1 / | S | ) \sum _ { i \in S } x _ { i }$ , let us define
+
+$$
+R ( S ) \stackrel { \Delta } { = } \operatorname* { m i n } _ { \substack { S ^ { \prime } \subset S , | S ^ { \prime } | = ( 1 - 2 \alpha ) | S | . } } \operatorname* { m a x } _ { \substack { T \subset S ^ { \prime } , | T | = ( 1 - \alpha ) | S ^ { \prime } | . } } \| \mu ( T ) - \mu ( S ^ { \prime } ) \| _ { 2 } .
+$$
+
+Algorithm 2 first checks if the resilience matches that of the promised distribution. The data is pre-processed with $q _ { \mathrm { r a n g e } }$ to ensure we can check $R ( S )$ privately. Once resilience is cleared, we can safely use the exponential mechanism based on the score function $d ( \hat { \mu } , S )$ in Definition 4.3 to select an approximate robust mean $\hat { \mu }$ privately. The choice of the sensitivity critically relies on the fact that resilient datasets have small sensitivity of ${ \cal O } ( ( 1 / n ) \sqrt { \log ( 1 / \alpha ) } )$ . Without the resilience check, the sensitivity is $O ( d ^ { 1 / 2 } / n )$ resulting in an extra factor of $\sqrt { d }$ in the sample complexity.
+
+Input: $S = \{ x _ { i } \} _ { i \in [ n ] } , \alpha \in ( 0 , 1 / 2 ) , ( \varepsilon , \delta )$   
+1 if $n < c d ^ { 1 / 2 } \log ( 1 / \delta ) / \left( \varepsilon \alpha \sqrt { \log ( 1 / \alpha ) } \right)$ then Output: $\emptyset \ [ \ c d ^ { 1 / 2 } \log ( 1 / \delta ) / \ ( \varepsilon \alpha )$ for hevay-tail]   
+2 $( \bar { x } , B ) \gets q _ { \mathrm { r a n g e } } ( S , ( 1 / 3 ) \varepsilon , ( 1 / 3 ) \delta )$ $[ \ q _ { \mathrm { r a n g e - h t } } ( \cdot )$ for hevay-tail]   
+3 Project the data points onto the ball: $x _ { i }  \mathcal { P } _ { B _ { \sqrt { d } B / 2 } ( \bar { x } ) } ( x _ { i } )$ , for all $i \in [ n ]$   
+4 $\widehat { R } ( S ) \gets R ( S ) + \mathrm { L a p } ( 3 B d ^ { 1 / 2 } / ( n \varepsilon ) )$   
+5 if $\widehat { R } ( S ) > 2 \alpha \sqrt { \log ( 1 / \alpha ) }$ then Output: $\varnothing$ $[ \widehat { R } ( S ) > 2 c _ { \zeta } \sqrt { \alpha }$ for hevay-tail]   
+6 else Output: a randomly drawn point $\hat { \mu } \in \mathcal { B } _ { \sqrt { d } B / 2 } ( \bar { x } )$ sampled from a density   
+7 r(ˆµ) ∝ e−(1/(24 log(1/α)))ε n d(ˆµ,S) $[ e ^ { - ( \varepsilon n \sqrt { \alpha } / ( 2 4 c _ { \zeta } ) ) d ( \hat { \mu } , S ) }$ for heavy-tail]
+
+We propose the score function $d ( \hat { \mu } , S )$ in the following definition, which is a robust estimator of the distance between the mean and the candidate $\hat { \mu }$ .
+
+Definition 4.3. For a set of data $\{ x _ { i } \} _ { i \in S }$ lying in $\mathbb { R } ^ { d }$ , for any $v \in \mathbb { S } ^ { d - 1 }$ , define $\mathcal { T } ^ { v }$ to be the $3 \alpha | S |$ points with the largest $v ^ { \top } x _ { i }$ value, $B ^ { v }$ to be the $3 \alpha | S |$ points with the smallest $v ^ { \top } x _ { i }$ value, and $\mathcal { M } ^ { v } = S \setminus ( \mathcal { T } ^ { v } \cup B ^ { v } )$ . Define $\begin{array} { r l r } { d ( \hat { \mu } , S ) } & { \triangleq } & { \operatorname* { m a x } _ { v \in \mathbb { S } ^ { d - 1 } } \left. v ^ { \top } \left( \mu ( \mathcal { M } ^ { v } ) - \hat { \mu } \right) \right. } \end{array}$ .
+
+Analysis. For any direction $v$ , the truncated mean estimator $\mu ( \mathcal { M } ^ { v } )$ provides a robust estimation of the true mean along the direction $v$ , thus the distance can be simply defined by taking the maximum over all directions $v$ . We show the sensitivity of this simple estimator is bounded by the resilience property $\sigma$ divided by $n$ , which is ${ \cal O } ( ( 1 / n ) \sqrt { \log ( 1 / \alpha ) } )$ once the resilience check is passed. This leads to the following near-optimal sample complexity. We provide a proof in Appendix H.2.
+
+Theorem 7 (Exponential time algorithm for sub-Gaussian distributions). Algorithm 2 is $( \varepsilon , \delta )$ -DP. Under Assumption $^ { l }$ , this algorithm achieves $\| \hat { \mu } - \mu \| _ { 2 } = O ( \alpha \sqrt { \log ( 1 / \alpha ) } )$ with probability $1 - \zeta i f$
+
+$$
+n = \widetilde \Omega \Big ( \frac { d + \log \frac { 1 } { \xi } } { \alpha ^ { 2 } \log \frac { 1 } { \alpha } } + \frac { d \log \Big ( d \sqrt { \log ( d n / \zeta ) } / \alpha \Big ) + d ^ { 1 / 2 } \log \frac { 1 } { \delta } + \log \frac { 1 } { \zeta } } { \varepsilon \alpha } + \frac { \sqrt { d \log \frac { 1 } { \delta } } \log \frac { d } { \zeta \delta } } { \varepsilon } \Big ) ~ .
+$$
+
+Run-time. Computing $R ( S )$ exactly can take $O ( d e ^ { \Theta ( n ) } )$ operations. The exponential mechanism implemented with $\alpha$ -covering for $\hat { \mu }$ and a constant covering for $v$ can take $O ( n d ( \sqrt { \log ( d n / \zeta ) } / \alpha ) ^ { d } )$ operations.
+
+# 5 Conclusion
+
+Differentially private mean estimation is brittle against a small fraction of the samples being corrupted by an adversary. We show that robustness can be achieved without any increase in the sample complexity by introducing a novel DP mean estimator, which requires run-time exponential in the dimension of the samples. The technical contribution is in leveraging the resilience property of well-behaved distributions in an innovative way to not only find robust mean (which is the typical use case of resilience) but also bound sensitivity for optimal privacy guarantee. To cope with the computational challenge, we propose an efficient algorithm, which we call PRIME, that achieves the optimal target accuracy at the cost of an increased sample complexity. The technical contributions are $( i )$ a novel framework for private iterative filtering and its tight analysis of the end-to-end sensitivity and $( i i )$ novel filtering algorithm of DPTHRESHOLD which is critical in privately running matrix multiplicative weights and hence significantly reducing the number of accesses to the database. With appropriately chosen parameters, we show that our exponential time approach achieves near-optimal guarantees for both sub-Gaussian and covariance bounded distributions and PRIME achieves the same accuracy efficiently but at the cost of an increased sample complexity by a $d ^ { 1 / 2 }$ factor.
+
+There are several directions for improving our results further and applying the framework to solve other problems. PRIME provides a new design principle for private and robust estimation. This can be more broadly applied to fundamental statistical analyses such as robust covariance estimation [28, 30, 64] robust PCA [60, 48], and robust linear regression [59, 35].
+
+PRIME could be improved in a few directions. First, the sample complexity of $\widetilde \Omega ( ( d / ( \alpha ^ { 2 } \log ( 1 / \alpha ) ) ) +$ $( d ^ { 3 / 2 } / ( \varepsilon \alpha \log ( 1 / \alpha ) ) ) \log ( 1 / \delta ) )$ in Theorem 6 is suboptimal in the second term. Improving the $d ^ { 3 / 2 }$ factor requires bypassing differentially private singular value decomposition, which seems to be a challenging task. However, it might be possible to separate the $\bar { \log ( 1 / \delta ) }$ factor from the rest of the terms and get an additive error of the form $\widetilde \Omega ( ( d / ( \alpha ^ { 2 } \log ( 1 / \alpha ) ) ) + ( d ^ { 3 / 2 } / ( \varepsilon \alpha \log ( 1 / \alpha ) ) ) +$ $( 1 / \varepsilon ) \log ( 1 / \delta ) )$ . This requires using Laplace mechanism in private MMW (line 16 Algortihm 10). Secondly, the time complexity of PRIME is dominated by computation time of the matrix exponential in (line 16 Algortihm 10). Total number of operations scale as ${ \widetilde { O } } ( d ^ { 3 } + n d ^ { 2 } )$ . One might hope to achieve $\widetilde O ( n d )$ time complexity using approximate computations of $\tau _ { j }$ ’s using techniques from [36]. This does not improve the sample complexity, as the number of times the dataset is accessed remains the same. Finally, for (non-robust) private mean estimation, COINPRESS provides a practical improvement in the small sample regime by progressively refining the search space [12]. The same principle could be applied to PRIME to design a robust version of COINPRESS. One important question remains open; how are differential privacy and robust statistics fundamentally related? We believe our exponential time algorithm hints on a fundamental connection between robust statistics of a data projected onto one-dimensional subspace and sensitivity of resulting score function for the exponential mechanism. It is an interesting direction to pursue this connection further to design novel algorithms that bridge privacy and robustness.
+
+# Acknowledgement
+
+Sham Kakade acknowledges funding from the National Science Foundation under award CCF1703574. Sewoong Oh acknowledges funding from Google faculty research award, NSF grants IIS-1929955, CCF-1705007, CNS-2002664, CCF 2019844 as a part of Institute for Foundation of Machine Learning, and CNS-2112471 as a part of Institute for Future Edge Networks and Distributed Intelligence.
+
+# References
+
+[1] Martin Abadi, Andy Chu, Ian Goodfellow, H Brendan McMahan, Ilya Mironov, Kunal Talwar, and Li Zhang. Deep learning with differential privacy. In Proceedings of the 2016 ACM SIGSAC Conference on Computer and Communications Security, pages 308–318, 2016.   
+[2] John M Abowd. The us census bureau adopts differential privacy. In Proceedings of the 24th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, pages 2867–2867, 2018.   
+[3] Ishaq Aden-Ali, Hassan Ashtiani, and Gautam Kamath. On the sample complexity of privately learning unbounded high-dimensional gaussians. arXiv preprint arXiv:2010.09929, 2020.   
+[4] Zeyuan Allen-Zhu, Zhenyu Liao, and Lorenzo Orecchia. Spectral sparsification and regret minimization beyond matrix multiplicative updates. In Proceedings of the forty-seventh annual ACM symposium on Theory of computing, pages 237–245, 2015.   
+[5] Edoardo Amaldi and Viggo Kann. The complexity and approximability of finding maximum feasible subsystems of linear relations. Theoretical computer science, 147(1-2):181–210, 1995.   
+[6] Frank J Anscombe. Rejection of outliers. Technometrics, 2(2):123–146, 1960. [7] Ainesh Bakshi and Pravesh Kothari. List-decodable subspace recovery via sum-of-squares. arXiv preprint arXiv:2002.05139, 2020.   
+[8] S. Balakrishnan, S. S. Du, J. Li, and A. Singh. Computationally efficient robust sparse estimation in high dimensions. In Proceedings of the 30th Conference on Learning Theory, COLT 2017, pages 169–212, 2017.   
+[9] Amos Beimel, Shay Moran, Kobbi Nissim, and Uri Stemmer. Private center points and learning of halfspaces. arXiv preprint arXiv:1902.10731, 2019.   
+[10] K. Bhatia, P. Jain, P. Kamalaruban, and P. Kar. Consistent robust regression. In Advances in Neural Information Processing Systems 30: Annual Conference on Neural Information Processing Systems 2017, pages 2107–2116, 2017.   
+[11] Kush Bhatia, Prateek Jain, and Purushottam Kar. Robust regression via hard thresholding. In Advances in Neural Information Processing Systems, pages 721–729, 2015.   
+[12] Sourav Biswas, Yihe Dong, Gautam Kamath, and Jonathan Ullman. Coinpress: Practical private mean and covariance estimation. arXiv preprint arXiv:2006.06618, 2020.   
+[13] Avrim Blum, Cynthia Dwork, Frank McSherry, and Kobbi Nissim. Practical privacy: the sulq framework. In Proceedings of the twenty-fourth ACM SIGMOD-SIGACT-SIGART symposium on Principles of database systems, pages 128–138, 2005.   
+[14] Mark Bun, Gautam Kamath, Thomas Steinke, and Steven Z Wu. Private hypothesis selection. In Advances in Neural Information Processing Systems, pages 156–167, 2019.   
+[15] T Tony Cai, Yichen Wang, and Linjun Zhang. The cost of privacy: Optimal rates of convergence for parameter estimation with differential privacy. arXiv preprint arXiv:1902.04495, 2019.   
+[16] Clément L Canonne, Gautam Kamath, Audra McMillan, Jonathan Ullman, and Lydia Zakynthinou. Private identity testing for high-dimensional distributions. arXiv preprint arXiv:1905.11947, 2019.   
+[17] Moses Charikar, Jacob Steinhardt, and Gregory Valiant. Learning from untrusted data. In Proceedings of the 49th Annual ACM SIGACT Symposium on Theory of Computing, pages 47–60, 2017.   
+[18] Kamalika Chaudhuri, Anand D Sarwate, and Kaushik Sinha. A near-optimal algorithm for differentially-private principal components. The Journal of Machine Learning Research, 14(1):2905–2943, 2013.   
+[19] Xinyun Chen, Chang Liu, Bo Li, Kimberly Lu, and Dawn Song. Targeted backdoor attacks on deep learning systems using data poisoning. arXiv preprint arXiv:1712.05526, 2017.   
+[20] Yu Cheng, Ilias Diakonikolas, and Rong Ge. High-dimensional robust mean estimation in nearly-linear time. In Proceedings of the Thirtieth Annual ACM-SIAM Symposium on Discrete Algorithms, pages 2755–2771. SIAM, 2019.   
+[21] Yu Cheng, Ilias Diakonikolas, Rong Ge, and David P Woodruff. Faster algorithms for highdimensional robust covariance estimation. In Conference on Learning Theory, pages 727–757. PMLR, 2019.   
+[22] Yeshwanth Cherapanamjeri, Sidhanth Mohanty, and Morris Yau. List decodable mean estimation in nearly linear time. arXiv preprint arXiv:2005.09796, 2020.   
+[23] Arnak Dalalyan and Philip Thompson. Outlier-robust estimation of a sparse linear model using $\ell _ { 1 }$ -penalized huber’s $m$ -estimator. In Advances in Neural Information Processing Systems, pages 13188–13198, 2019.   
+[24] Jules Depersin and Guillaume Lecué. Robust subgaussian estimation of a mean vector in nearly linear time. arXiv preprint arXiv:1906.03058, 2019.   
+[25] Luc Devroye and Gábor Lugosi. Combinatorial methods in density estimation. Springer Science & Business Media, 2012.
+
+[26] Aditya Dhar and Jason Huang. Designing differentially private estimators in high dimensions. arXiv preprint arXiv:2006.01944, 2020.
+
+[27] Ilias Diakonikolas, Samuel B Hopkins, Daniel Kane, and Sushrut Karmalkar. Robustly learning any clusterable mixture of gaussians. arXiv preprint arXiv:2005.06417, 2020.
+
+[28] Ilias Diakonikolas, Gautam Kamath, Daniel Kane, Jerry Li, Ankur Moitra, and Alistair Stewart. Robust estimators in high-dimensions without the computational intractability. SIAM Journal on Computing, 48(2):742–864, 2019.
+
+[29] Ilias Diakonikolas, Gautam Kamath, Daniel Kane, Jerry Li, Jacob Steinhardt, and Alistair Stewart. Sever: A robust meta-algorithm for stochastic optimization. In International Conference on Machine Learning, pages 1596–1606, 2019.
+
+[30] Ilias Diakonikolas, Gautam Kamath, Daniel M. Kane, Jerry Li, Ankur Moitra, and Alistair Stewart. Being Robust (in High Dimensions) Can Be Practical. arXiv e-prints, page arXiv:1703.00893, March 2017.
+
+[31] Ilias Diakonikolas, Gautam Kamath, Daniel M Kane, Jerry Li, Ankur Moitra, and Alistair Stewart. Robustly learning a gaussian: Getting optimal error, efficiently. In Proceedings of the Twenty-Ninth Annual ACM-SIAM Symposium on Discrete Algorithms, pages 2683–2702. SIAM, 2018.
+
+[32] Ilias Diakonikolas and Daniel M Kane. Recent advances in algorithmic high-dimensional robust statistics. arXiv preprint arXiv:1911.05911, 2019.
+
+[33] Ilias Diakonikolas, Daniel M Kane, and Alistair Stewart. Statistical query lower bounds for robust estimation of high-dimensional gaussians and gaussian mixtures. In 2017 IEEE 58th Annual Symposium on Foundations of Computer Science (FOCS), pages 73–84. IEEE, 2017.
+
+[34] Ilias Diakonikolas, Daniel M Kane, and Alistair Stewart. List-decodable robust mean estimation and learning mixtures of spherical gaussians. In Proceedings of the 50th Annual ACM SIGACT Symposium on Theory of Computing, pages 1047–1060, 2018.
+
+[35] Ilias Diakonikolas, Weihao Kong, and Alistair Stewart. Efficient algorithms and lower bounds for robust linear regression. In Proceedings of the Thirtieth Annual ACM-SIAM Symposium on Discrete Algorithms, pages 2745–2754. SIAM, 2019.
+
+[36] Yihe Dong, Samuel Hopkins, and Jerry Li. Quantum entropy scoring for fast robust mean estimation and improved outlier detection. In Advances in Neural Information Processing Systems, pages 6067–6077, 2019.
+
+[37] Cynthia Dwork, Frank McSherry, Kobbi Nissim, and Adam Smith. Calibrating noise to sensitivity in private data analysis. In Theory of cryptography conference, pages 265–284. Springer, 2006.
+
+[38] Cynthia Dwork and Aaron Roth. The algorithmic foundations of differential privacy. Foundations and Trends in Theoretical Computer Science, 9(3-4):211–407, 2014.
+
+[39] Cynthia Dwork, Kunal Talwar, Abhradeep Thakurta, and Li Zhang. Analyze gauss: optimal bounds for privacy-preserving principal component analysis. In Proceedings of the forty-sixth annual ACM symposium on Theory of computing, pages 11–20, 2014.
+
+[40] Úlfar Erlingsson, Vasyl Pihur, and Aleksandra Korolova. Rappor: Randomized aggregatable privacy-preserving ordinal response. In Proceedings of the 2014 ACM SIGSAC conference on computer and communications security, pages 1054–1067, 2014.
+
+[41] Giulia Fanti, Vasyl Pihur, and Úlfar Erlingsson. Building a rappor with the unknown: Privacypreserving learning of associations and data dictionaries. Proceedings on Privacy Enhancing Technologies, 2016(3):41–61, 2016.
+
+[42] Chao Gao et al. Robust regression via mutivariate regression depth. Bernoulli, 26(2):1139–1170, 2020.
+
+[43] Sam Hopkins, Jerry Li, and Fred Zhang. Robust and heavy-tailed mean estimation made simple, via regret minimization. Advances in Neural Information Processing Systems, 33, 2020.
+
+[44] Samuel B Hopkins. Mean estimation with sub-gaussian rates in polynomial time. Annals of Statistics, 48(2):1193–1213, 2020.   
+[45] Samuel B Hopkins and Jerry Li. Mixture models, robustness, and sum of squares proofs. In Proceedings of the 50th Annual ACM SIGACT Symposium on Theory of Computing, pages 1021–1034, 2018.   
+[46] Samuel B Hopkins and Jerry Li. How hard is robust mean estimation? In Conference on Learning Theory, pages 1649–1682. PMLR, 2019.   
+[47] Peter J. Huber. Robust Estimation of a Location Parameter. The Annals of Mathematical Statistics, 35(1):73 – 101, 1964.   
+[48] Arun Jambulapati, Jerry Li, and Kevin Tian. Robust sub-gaussian principal component analysis and width-independent schatten packing. Advances in Neural Information Processing Systems, 33, 2020.   
+[49] He Jia and Santosh Vempala. Robustly clustering a mixture of gaussians. arXiv preprint arXiv:1911.11838, 2019.   
+[50] Peter Kairouz, H Brendan McMahan, Brendan Avent, Aurélien Bellet, Mehdi Bennis, Arjun Nitin Bhagoji, Keith Bonawitz, Zachary Charles, Graham Cormode, Rachel Cummings, et al. Advances and open problems in federated learning. arXiv preprint arXiv:1912.04977, 2019.   
+[51] Peter Kairouz, Sewoong Oh, and Pramod Viswanath. The composition theorem for differential privacy. In International conference on machine learning, pages 1376–1385, 2015.   
+[52] Gautam Kamath, Jerry Li, Vikrant Singhal, and Jonathan Ullman. Privately learning highdimensional distributions. In Conference on Learning Theory, pages 1853–1902, 2019.   
+[53] Gautam Kamath, Or Sheffet, Vikrant Singhal, and Jonathan Ullman. Differentially private algorithms for learning mixtures of separated gaussians. In 2020 Information Theory and Applications Workshop (ITA), pages 1–62. IEEE, 2020.   
+[54] Gautam Kamath, Vikrant Singhal, and Jonathan Ullman. Private mean estimation of heavy-tailed distributions. arXiv preprint arXiv:2002.09464, 2020.   
+[55] Haim Kaplan, Katrina Ligett, Yishay Mansour, Moni Naor, and Uri Stemmer. Privately learning thresholds: Closing the exponential gap. In Conference on Learning Theory, pages 2263–2285. PMLR, 2020.   
+[56] Sushrut Karmalkar, Adam Klivans, and Pravesh Kothari. List-decodable linear regression. In Advances in Neural Information Processing Systems, pages 7423–7432, 2019.   
+[57] Sushrut Karmalkar and Eric Price. Compressed sensing with adversarial sparse noise via l1 regression. In 2nd Symposium on Simplicity in Algorithms, 2019.   
+[58] Vishesh Karwa and Salil Vadhan. Finite sample differentially private confidence intervals. arXiv preprint arXiv:1711.03908, 2017.   
+[59] Adam Klivans, Pravesh K Kothari, and Raghu Meka. Efficient algorithms for outlier-robust regression. In Conference On Learning Theory, pages 1420–1430, 2018.   
+[60] Weihao Kong, Raghav Somani, Sham Kakade, and Sewoong Oh. Robust meta-learning for mixed linear regression with small batches. Advances in Neural Information Processing Systems, 33, 2020.   
+[61] Pravesh K Kothari, Jacob Steinhardt, and David Steurer. Robust moment estimation and improved clustering via sum of squares. In Proceedings of the 50th Annual ACM SIGACT Symposium on Theory of Computing, pages 1035–1046, 2018.   
+[62] Kevin A Lai, Anup B Rao, and Santosh Vempala. Agnostic estimation of mean and covariance. In 2016 IEEE 57th Annual Symposium on Foundations of Computer Science (FOCS), pages 665–674. IEEE, 2016.   
+[63] Jerry Li. CSE 599-M, Lecture Notes: Robustness in Machine Learning , 2019. URL: https: //jerryzli.github.io/robust-ml-fall19/lec7.pdf.   
+[64] Jerry Li and Guanghao Ye. Robust gaussian covariance estimation in nearly-matrix multiplication time. Advances in Neural Information Processing Systems, 33, 2020.   
+[65] Liu Liu, Yanyao Shen, Tianyang Li, and Constantine Caramanis. High dimensional robust sparse regression. arXiv preprint arXiv:1805.11643, 2018.   
+[66] Xiaohui Liu. Fast implementation of the tukey depth. Computational Statistics, 32(4):1395– 1410, 2017.   
+[67] Xiaohui Liu, Karl Mosler, and Pavlo Mozharovskyi. Fast computation of tukey trimmed regions and median in dimension p> 2. Journal of Computational and Graphical Statistics, 28(3):682–697, 2019.   
+[68] Gábor Lugosi, Shahar Mendelson, et al. Sub-gaussian estimators of the mean of a random vector. Annals of Statistics, 47(2):783–794, 2019.   
+[69] Frank McSherry and Kunal Talwar. Mechanism design via differential privacy. In 48th Annual IEEE Symposium on Foundations of Computer Science (FOCS’07), pages 94–103. IEEE, 2007.   
+[70] Bhaskar Mukhoty, Govind Gopakumar, Prateek Jain, and Purushottam Kar. Globally-convergent iteratively reweighted least squares for robust regression problems. In The 22nd International Conference on Artificial Intelligence and Statistics, pages 313–322, 2019.   
+[71] A. Prasad, A. S. Suggala, S. Balakrishnan, and P. Ravikumar. Robust estimation via robust gradient estimation. arXiv preprint arXiv:1802.06485, 2018.   
+[72] Prasad Raghavendra and Morris Yau. List decodable learning via sum of squares. In Proceedings of the Fourteenth Annual ACM-SIAM Symposium on Discrete Algorithms, pages 161–180. SIAM, 2020.   
+[73] Jacob Steinhardt, Moses Charikar, and Gregory Valiant. Resilience: A criterion for learning in the presence of arbitrary outliers. In 9th Innovations in Theoretical Computer Science Conference (ITCS 2018). Schloss Dagstuhl-Leibniz-Zentrum fuer Informatik, 2018.   
+[74] Jun Tang, Aleksandra Korolova, Xiaolong Bai, Xueqiang Wang, and Xiaofeng Wang. Privacy loss in apple’s implementation of differential privacy on macos 10.12. arXiv preprint arXiv:1709.02753, 2017.   
+[75] Terence Tao. Topics in random matrix theory, volume 132. American Mathematical Soc., 2012.   
+[76] John W Tukey. A survey of sampling from contaminated distributions. Contributions to probability and statistics, pages 448–485, 1960.   
+[77] Martin J Wainwright. High-dimensional statistics: A non-asymptotic viewpoint, volume 48. Cambridge University Press, 2019.   
+[78] Lu Wei, Anand D Sarwate, Jukka Corander, Alfred Hero, and Vahid Tarokh. Analysis of a privacy-preserving pca algorithm using random matrix theory. In 2016 IEEE Global Conference on Signal and Information Processing (GlobalSIP), pages 1335–1339. IEEE, 2016.   
+[79] Huang Xiao, Battista Biggio, Gavin Brown, Giorgio Fumera, Claudia Eckert, and Fabio Roli. Is feature selection secure against training data poisoning? In International Conference on Machine Learning, pages 1689–1698. PMLR, 2015.   
+[80] Huanyu Zhang, Gautam Kamath, Janardhan Kulkarni, and Zhiwei Steven Wu. Privately learning markov random fields. arXiv preprint arXiv:2002.09463, 2020.

parse/train/CuQoImkKkIj/CuQoImkKkIj_content_list.json

@@ -0,0 +1,1458 @@
+[
+    {
+        "type": "text",
+        "text": "Robust and differentially private mean estimation ",
+        "text_level": 1,
+        "bbox": [
+            196,
+            122,
+            802,
+            148
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Xiyang Liu, Weihao Kong, Sham Kakade, Sewoong Oh ",
+        "bbox": [
+            285,
+            200,
+            710,
+            215
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Paul G. Allen School of Computer Science and Engineering, University of Washington {xiyangl,whkong,sham,sewoong}@cs.washington.edu ",
+        "bbox": [
+            294,
+            215,
+            699,
+            257
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            292,
+            535,
+            309
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In statistical learning and analysis from shared data, which is increasingly widely adopted in platforms such as federated learning and meta-learning, there are two major concerns: privacy and robustness. Each participating individual should be able to contribute without the fear of leaking one’s sensitive information. At the same time, the system should be robust in the presence of malicious participants inserting corrupted data. Recent algorithmic advances in learning from shared data focus on either one of these threats, leaving the system vulnerable to the other. We bridge this gap for the canonical problem of estimating the mean from i.i.d. samples. We introduce PRIME, which is the first efficient algorithm that achieves both privacy and robustness for a wide range of distributions. We further complement this result with a novel exponential time algorithm that improves the sample complexity of PRIME, achieving a near-optimal guarantee and matching a known lower bound for (non-robust) private mean estimation. This proves that there is no extra statistical cost to simultaneously guaranteeing privacy and robustness. ",
+        "bbox": [
+            233,
+            321,
+            766,
+            516
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            540,
+            310,
+            558
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "When releasing database statistics on a collection of entries from individuals, we would ideally like to make it impossible to reverse-engineer each individual’s potentially sensitive information. Privacy-preserving techniques add just enough randomness tailored to the statistical task to guarantee protection. At the same time, it is becoming increasingly common to apply such techniques to databases collected from multiple sources, not all of which can be trusted. Emerging data access frameworks, such as federated analyses across users’ devices or data silos [50], make it easier to temper with such collected datasets, leaving private statistical analyses vulnerable to a malicious corruption of a fraction of the data. ",
+        "bbox": [
+            174,
+            570,
+            825,
+            681
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Differential privacy has emerged as a widely accepted de facto measure of privacy, which is now a standard in releasing the statistics of the U.S. Census data [2] statistics and also deployed in real-world commercial systems [74, 40, 41]. A statistical analysis is said to be differentially private (DP) if the likelihood of the (randomized) outcome does not change significantly when a single arbitrary entry is added/removed (formally defined in $\\ S 1 . 2 )$ . This provides a strong privacy guarantee: even a powerful adversary who knows all the other entries in the database cannot confidently identify whether a particular individual is participating in the database based on the outcome of the analysis. This ensures plausible deniability, central to protecting an individual’s privacy. ",
+        "bbox": [
+            174,
+            689,
+            825,
+            799
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we focus on one of the most canonical problems in statistics: estimating the mean of a distribution from i.i.d. samples. For distributions with unbounded support, such as sub-Gaussian and heavy-tailed distributions, fundamental trade-offs between accuracy, sample size, and privacy have only recently been identified [58, 52, 54, 3] and efficient private estimators proposed. However, these approaches are brittle when a fraction of the data is corrupted, posing a real threat, referred to as data poisoning attacks [19, 79]. In defense of such attacks, robust (but not necessarily private) statistics has emerged as a popular setting of recent algorithmic and mathematical breakthroughs [73, 30]. ",
+        "bbox": [
+            174,
+            805,
+            825,
+            902
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "One might be misled into thinking that privacy ensures robustness since DP guarantees that a single outlier cannot change the estimation too much. This intuition is true only in a low dimension; each sample has to be an obvious outlier to significantly change the mean. However, in a high dimension, each corrupted data point can look perfectly uncorrupted but still shift the mean significant when colluding together (e.g., see Fig. 1). Focusing on the canonical problem of mean estimation, we introduce novel algorithms that achieve robustness and privacy simultaneously even when a fraction of data is corrupted arbitrarily. For such algorithms, there is a fundamental question of interest: do we need more samples to make private mean estimation also robust against adversarial corruption? ",
+        "bbox": [
+            173,
+            90,
+            825,
+            203
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Sub-Gaussian distributions. If we can afford exponential run-time in the dimension, robustness can be achieved without extra cost in sample complexity. We introduce a novel estimator that (i) satisfies $( \\varepsilon , \\delta )$ -DP, $( i i )$ achieves near-optimal robustness under $\\alpha$ -fraction of corrupted data, achieving accuracy of $O ( \\alpha \\sqrt { \\log ( 1 / \\alpha ) } )$ nearly matching the fundamental lower bound of $\\Omega ( \\alpha )$ that holds even for a (non-private) robust mean estimation with infinite samples, and $( i i i )$ achieves near-optimal sample complexity matching that of a fundamental lower bound for a (non-robust) private mean estimation as shown in Table 1. ",
+        "bbox": [
+            173,
+            208,
+            825,
+            308
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Theorem 1 (Informal Theorem 7, exponential time). Algorithm 2 is $( \\varepsilon , \\delta )$ -DP. When $\\alpha$ fraction of the data is arbitrarily corrupted from $n$ samples from a $d$ -dimensional sub-Gaussian distribution with mean $\\mu$ and an identity sub-Gaussian parameter, if $\\begin{array} { r } { n = \\widetilde \\Omega ( d / \\alpha ^ { 2 } + ( d + d ^ { 1 / 2 } \\log ( 1 / \\delta ) ) / ( \\alpha \\varepsilon ) ) } \\end{array}$ then Algorithm 2 achieves $\\| \\hat { \\mu } - \\mu \\| _ { 2 } = O ( \\alpha \\sqrt { \\log ( 1 / \\alpha ) } ) \\ : w . h . p$ . ",
+        "bbox": [
+            173,
+            310,
+            826,
+            372
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We introduce PRIME (PRIvate and robust Mean Estimation) in $\\ S 2 . 3$ with details in Algorithm 9 in Appendix E.1, to achieve computational efficiency. It requires a run-time of only $\\widetilde { \\cal O } ( d ^ { 3 } + n d ^ { 2 } )$ , but at the cost of requiring extra $d ^ { 1 / 2 }$ factor larger number of samples. This cannot be improved upon with current techniques since efficient robust estimators rely on the top PCA directions of the covariance matrix to detect outliers. [78] showed that $\\widetilde \\Omega ( d ^ { 3 / 2 } )$ samples are necessary to compute PCA directions while preserving $( \\varepsilon , \\delta )$ -DP when $\\| x _ { i } \\| _ { 2 } = O ( { \\sqrt { d } } )$ . It remains an open question if this $\\widetilde \\Omega ( d ^ { 3 / 2 } / ( \\alpha \\varepsilon ) )$ bottleneck is fundamental; no matching lower bound is currently known. ",
+        "bbox": [
+            173,
+            380,
+            826,
+            488
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Theorem 2 (Informal Theorem 6, polynomial time). PRIME is $( \\varepsilon , \\delta )$ -DP and under the assumption of Thm.1, if $\\begin{array} { r } { \\dot { n } = \\widetilde \\Omega ( d / \\alpha ^ { 2 } + ( d ^ { 3 / 2 } \\log ( 1 / \\delta ) ) / ( \\alpha \\varepsilon ) ) . } \\end{array}$ , achieves $\\begin{array} { r } { \\| \\hat { \\mu } - \\mu \\| _ { 2 } = O ( \\alpha \\sqrt { \\log ( 1 / \\alpha ) } ) ~ w . h . p . } \\end{array}$ . ",
+        "bbox": [
+            174,
+            489,
+            823,
+            522
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "table",
+        "img_path": "images/1e64b991060acd268af93ff0942da309a127755f1575377d2afa3e229b23eccd.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Upper bound (poly-time)</td><td rowspan=1 colspan=1>Upper bound (exp-time)</td><td rowspan=1 colspan=1>Lower bound</td></tr><tr><td rowspan=1 colspan=1>(ε,δ)-DP[52]</td><td rowspan=1 colspan=1>0+dlog1/2(1/8��）Qε</td><td rowspan=1 colspan=1>+）</td><td rowspan=1 colspan=1>（+）</td></tr><tr><td rowspan=1 colspan=1>α-corruption [36]</td><td rowspan=1 colspan=1>0（</td><td rowspan=1 colspan=1>（</td><td rowspan=1 colspan=1>（</td></tr><tr><td rowspan=1 colspan=1>α-corruption and(ε,δ)-DP (this paper)</td><td rowspan=1 colspan=1>（+/210g(1/8）)αε[Theorem6]</td><td rowspan=1 colspan=1>0（+d+d1/210g(1/8))Q[Theorem7]</td><td rowspan=1 colspan=1>(）[52]</td></tr></table>",
+        "bbox": [
+            179,
+            536,
+            818,
+            625
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Table 1: For estimating the mean $\\mu \\in \\mathbb { R } ^ { d }$ of a sub-Gaussian distribution with a known covariance, we list the sufficient or necessary conditions on the sample sizes to achieve an error $\\| \\hat { \\mu } - \\mu \\| _ { 2 } = \\widetilde { O } ( \\alpha )$ under $( \\varepsilon , \\delta )$ -DP, corruption of an $\\alpha$ -fraction of samples, and both. √ $\\clubsuit$ requires the distribution to be a Gaussian [14] and $\\spadesuit$ requires $\\delta \\leq \\sqrt { d } / n$ . ",
+        "bbox": [
+            173,
+            637,
+            825,
+            702
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Heavy-tailed distributions. When samples are drawn from a distribution with a bounded covariance, parameters of Algorithm 2 can be modified to nearly match the optimal sample complexity of (nonrobust) private mean estimation in Table 2. This algorithm also matches the fundamental limit on the accuracy of (non-private) robust estimation, which in this case is $\\Omega ( \\alpha ^ { 1 / 2 } )$ . ",
+        "bbox": [
+            174,
+            712,
+            826,
+            770
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Theorem 3 (Informal Theorem 8, exponential time). From a distribution with mean $\\mu \\in \\mathbb { R } ^ { d }$ and covariance $\\Sigma \\preceq \\mathbf { I }$ , $n$ samples are drawn and $\\alpha$ -fraction is corrupted. Algorithm 2 is $( \\varepsilon , \\delta )$ -DP and $i f$ $n = \\widetilde \\Omega ( ( d + d ^ { 1 / 2 } \\log ( 1 / \\delta ) ) / ( \\alpha \\varepsilon ) + d ^ { 1 / 2 } \\log ^ { 3 / 2 } ( 1 / \\delta ) / \\varepsilon )$ achieves $\\| \\hat { \\mu } - \\mu \\| _ { 2 } = O ( \\alpha ^ { 1 / 2 } ) \\ : w . h . p .$ . ",
+        "bbox": [
+            173,
+            772,
+            826,
+            820
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The proposed PRIME-HT for covariance bounded distributions achieve computational efficiency at the cost of an extra factor of $d ^ { 1 / 2 }$ in sample size. This bottleneck is also due to DP PCA, and it remains open whether this gap can be closed by an efficient estimator. ",
+        "bbox": [
+            174,
+            827,
+            821,
+            872
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Theorem 4 (Informal Theorem 9, polynomial time). PRIME-HT is $( \\varepsilon , \\delta ) – D P$ and if $n \\_ =$ $\\widetilde \\Omega ( ( d ^ { 3 / 2 } \\log ( 1 / \\delta ) ) / ( \\alpha \\varepsilon ) )$ achieves $\\| \\hat { \\mu } - \\mu \\| _ { 2 } = O ( \\alpha ^ { 1 / 2 } ) \\ : w . h . p$ . under the assumptions of Thm. 3. ",
+        "bbox": [
+            171,
+            873,
+            823,
+            906
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "table",
+        "img_path": "images/191d63f4ee021bb7fbfe8805bb187077f698af2e6e124ee5962d88fbe956348f.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Upper bound (poly-time)</td><td rowspan=1 colspan=1>Upper bound (exp-time)</td><td rowspan=1 colspan=1>Lower bound</td></tr><tr><td rowspan=1 colspan=1>(ε,δ)-DP [54]</td><td rowspan=1 colspan=1>O（d10g1/2（1/）Qε</td><td rowspan=1 colspan=1>O（d10g1/2（1/0））Qε</td><td rowspan=1 colspan=1>2（）</td></tr><tr><td rowspan=1 colspan=1>α-corruption [36]</td><td rowspan=1 colspan=1>）</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>(）</td></tr><tr><td rowspan=1 colspan=1>α-corruption and(ε,δ)-DP (this paper)</td><td rowspan=1 colspan=1>0（(/210g(1/8))αε[Theorem 9]</td><td rowspan=1 colspan=1>（+d1721g/2(18）αε[Theorem 8]</td><td rowspan=1 colspan=1>(([54])</td></tr></table>",
+        "bbox": [
+            184,
+            88,
+            813,
+            176
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Table 2: For estimating the mean $\\mu \\in \\mathbb { R } ^ { d }$ of a covariance bounded distribution, we list the sufficient or necessary conditions on the sample size to achieve an error $\\| \\hat { \\mu } - \\mu \\| _ { 2 } = O ( \\alpha ^ { 1 / 2 } )$ under $( \\varepsilon , \\delta )$ -DP, corruption of an $\\alpha$ -fraction of samples, and both. ",
+        "bbox": [
+            174,
+            189,
+            825,
+            234
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "1.1 Technical contributions ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            257,
+            377,
+            272
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We introduce PRIME which simultaneously achieves $( \\varepsilon , \\delta )$ -DP and robustness against $\\alpha$ -fraction of corruption. A major challenge in making a standard filter-based robust estimation algorithm (e.g., [30]) private is the high sensitivity of the filtered set that we pass from one iteration to the next. We propose a new framework which makes private only the statistics of the set, hence significantly reducing the sensitivity. Our major innovation is a tight analysis of the end-to-end sensitivity of this multiple interactive accesses to the database. This is critical in achieving robustness while preserving privacy and is also of independent interest in making general iterative filtering algorithms private. ",
+        "bbox": [
+            173,
+            281,
+            826,
+            381
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The classical filter approach (see, e.g. [30]) needs to access the database √ $O ( d )$ times, which brings an extra $O ( { \\sqrt { d } } )$ factor in the sample complexity due to DP composition. In order to reduce the iteration complexity, following the approach in [36], we propose filtering multiple directions simultaneously using a new score based on the matrix multiplicative weights (MMW). In order to privatize the MMW filter, our major innovation is a novel adaptive filtering algorithm DPTHRESHOLD(·) that outputs a single private threshold which guarantees sufficient progress at every iteration. This brings the number of database accesses from $O ( d )$ to $O ( ( \\log d ) ^ { 2 } )$ . ",
+        "bbox": [
+            174,
+            386,
+            825,
+            486
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "One downside of PRIME is that it requires an extra $d ^ { 1 / 2 }$ factor in the sample complexity, compared to known lower bounds for (non-robust) DP mean estimation. To investigate whether this is also necessary, we propose a sample optimal exponential time robust mean estimation algorithm in $\\ S 4$ and prove that there is no extra statistical cost to jointly requiring privacy and robustness. Our major technical innovations is in using resilience property of the dataset to not only find robust mean (which is the typical use case of resilience) but also bound sensitivity of that robust mean. ",
+        "bbox": [
+            173,
+            492,
+            825,
+            577
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "1.2 Preliminary on differential privacy (DP) ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            592,
+            493,
+            608
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "DP is a formal metric for measuring privacy leakage when a dataset is accessed with a query [37]. ",
+        "bbox": [
+            173,
+            617,
+            813,
+            632
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Definition 1.1. Given two datasets $S = \\{ x _ { i } \\} _ { i = 1 } ^ { n }$ and $S ^ { \\prime } = \\{ x _ { i } ^ { \\prime } \\} _ { i = 1 } ^ { n ^ { \\prime } }$ , we say $S$ and $S ^ { \\prime }$ are neighboring $i f d _ { \\triangle } ( S , S ^ { \\prime } ) \\leq 1$ where $d _ { \\triangle } ( S , S ^ { \\prime } ) \\triangleq \\operatorname* { m a x } \\{ | S \\setminus S ^ { \\prime } | , | S ^ { \\prime } \\setminus S | \\}$ , which is denoted by $S \\sim S ^ { \\prime }$ . For an output of a stochastic query q on a database, we say q satisfies $( \\varepsilon , \\delta )$ -differential privacy for some $\\varepsilon > 0$ and $\\delta \\in ( 0 , 1 )$ i $\\begin{array} { r } { \\textstyle f \\mathbb { P } ( q ( S ) \\in A ) \\le e ^ { \\varepsilon } \\mathbb { P } ( q ( S ^ { \\prime } ) \\in A ) + \\delta } \\end{array}$ for all $S \\sim S ^ { \\prime }$ and all subset $A$ . ",
+        "bbox": [
+            174,
+            636,
+            825,
+            696
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Let $z \\sim \\mathrm { L a p } ( b )$ be a random vector with entries i.i.d. sampled from Laplace distribution with pdf $( 1 / 2 b ) e ^ { - | z | / b }$ . Let $z \\sim \\mathcal { N } ( \\mu , \\Sigma )$ denote a Gaussian random vector with mean $\\mu$ and covariance $\\Sigma$ . ",
+        "bbox": [
+            173,
+            705,
+            823,
+            736
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Definition 1.2. The sensitivity of a query $f ( S ) ~ \\in ~ \\mathbb { R } ^ { k }$ is defined as $\\Delta _ { p } ~ = ~ \\operatorname* { s u p } _ { S \\sim S ^ { \\prime } } \\| f ( S ) ~ -$ $f ( S ^ { \\prime } ) \\| _ { p }$ for a norm $\\begin{array} { r } { \\| { \\boldsymbol x } \\| _ { p } ~ = ~ ( \\sum _ { i \\in [ k ] } | x _ { i } | ^ { p } ) ^ { 1 / p } } \\end{array}$ . For $p ~ = ~ 1$ , the Laplace mechanism outputs $f ( S ) + \\mathrm { L a p } ( { \\Delta _ { 1 } } / { \\varepsilon } )$ and achieves $( \\varepsilon , 0 ) – D P \\ : I 3 7 J$ . For $p = 2$ , the Gaussian mechanism outputs $f ( S ) + \\mathcal { N } ( 0 , ( \\Delta _ { 2 } ( \\sqrt { 2 \\log ( 1 . 2 5 / \\delta ) } ) / \\varepsilon ) ^ { 2 } \\mathbf { I } )$ and achieves $( \\varepsilon , \\delta ) – D P / 3 8 J$ . ",
+        "bbox": [
+            173,
+            739,
+            825,
+            805
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We use these output perturbation mechanisms along with the exponential mechanism [69] as building blocks. Appendix A provides detailed survey of privacy and robust estimation. ",
+        "bbox": [
+            173,
+            813,
+            823,
+            842
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "1.3 Problem formulation ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            857,
+            359,
+            872
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We are given $n$ samples from a sub-Gaussian distribution with a known covariance but unknown mean, and $\\alpha$ fraction of the samples are corrupted by an adversary. Our goal is to estimate the unknown mean. We follow the standard definition of adversary in [30], which can adaptively choose which samples to corrupt and arbitrarily replace them with any points. ",
+        "bbox": [
+            174,
+            882,
+            821,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            90,
+            823,
+            119
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Assumption 1. An uncorrupted dataset $S _ { \\mathrm { g o o d } }$ consists of $n$ i.i.d. samples from a $d$ -dimensional sub-Gaussian distribution with mean $\\mu \\in \\mathbb { R } ^ { d }$ and covariance $\\mathbb { E } [ x x ^ { \\top } ] = \\mathbf { I } _ { d } ,$ , which is 1-sub-Gaussian, i.e., $\\mathbb { E } [ \\exp ( v ^ { \\top } x ) ] \\leq \\exp ( \\| v \\| _ { 2 } ^ { 2 } / 2 )$ for all $v \\in \\mathbb { R } ^ { d }$ . For some $\\alpha \\in ( 0 , 1 / 2 )$ , we are given a corrupted dataset $S = \\{ x _ { i } \\in \\mathbb { R } ^ { d } \\} _ { i = 1 } ^ { n }$ where an adversary adaptively inspects all the samples in $S _ { \\mathrm { g o o d } }$ , removes αn of them, and replaces them with $S _ { \\mathrm { b a d } }$ which are αn arbitrary points in $\\mathbb { R } ^ { d }$ . ",
+        "bbox": [
+            173,
+            122,
+            825,
+            199
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Similarly, we consider the same problem for heavy-tailed distributions with a bounded covariance.   \nWe present the assumption and main results for covariance bounded distributions in Appendix B. ",
+        "bbox": [
+            174,
+            209,
+            823,
+            238
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Notations. Let $[ n ] = \\{ 1 , 2 , \\dots , n \\}$ . For $x \\in \\mathbb { R } ^ { d }$ , we use $\\textstyle \\| x \\| _ { 2 } = ( \\sum _ { i \\in [ d ] } ( x _ { i } ) ^ { 2 } ) ^ { 1 / 2 }$ to denote the Euclidean norm. For $X \\in \\mathbb { R } ^ { d \\times d }$ , we use $\\begin{array} { r } { \\| X \\| _ { 2 } = \\operatorname* { m a x } _ { \\| v \\| _ { 2 } = 1 } \\| X v \\| _ { 2 } } \\end{array}$ to denote the spectral norm. The $d \\times d$ identity matrix is $\\mathbf { I } _ { d \\times d }$ . Whenever it is clear from context, we use $S$ to denote both a set of data points and also the set of indices of those data points. $\\widetilde O$ and $\\widetilde \\Omega$ hide poly-logarithmic factors in $d , n , 1 / \\alpha$ , and the failure probability. ",
+        "bbox": [
+            173,
+            244,
+            826,
+            323
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Outline. We present PRIME for sub-Gaussian distribution in $\\ S 2$ , and present theoretical analysis in $\\ S 3$ . We then introduce an exponential time algorithm with near optimal guarantee in $\\ S 4$ . Due to space constraints, analogous results for heavy-tailed distributions are presented in Appendix B. ",
+        "bbox": [
+            173,
+            328,
+            825,
+            371
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2 PRIME: efficient algorithm for robust and DP mean estimation ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            388,
+            733,
+            406
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In order to describe the proposed algorithm PRIME, we need to first describe a standard (non-private) iterative filtering algorithm for robust mean estimation. ",
+        "bbox": [
+            174,
+            420,
+            825,
+            449
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.1 Background on (non-private) iterative filtering for robust mean estimation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            464,
+            728,
+            479
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Non-private robust mean estimation approaches recursively apply the following filter, whose framework is first proposed in [28]. Given a dataset $S = \\{ x _ { i } \\} _ { i = 1 } ^ { n }$ , the current set $S _ { 0 } \\subseteq [ n ]$ of data points is updated starting with $S _ { 1 } = [ n ]$ . At each step, the following filter (Algorithm 1 in [63]) attempts to detect the corrupted data points and remove them. ",
+        "bbox": [
+            174,
+            489,
+            826,
+            546
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "1. Compute the top eigenvector $v _ { t } \\gets \\arg \\operatorname* { m a x } _ { v : \\| v \\| _ { 2 } = 1 } v ^ { \\top } \\mathrm { C o v } ( S _ { t - 1 } ) v$ of the covariance of the current data set $\\{ x _ { i } \\} _ { i \\in S _ { t - 1 } }$ ;   \n2. Compute scores for all data points $j \\in S _ { t - 1 } \\colon \\tau _ { j } \\gets \\left( v _ { t } ^ { \\top } \\left( x _ { j } - \\mathrm { M e a n } ( S _ { t - 1 } ) \\right) \\right) ^ { 2 } \\ ;$   \n3. Draw a random threshold: $Z _ { t } \\gets \\mathrm { U n i f } ( [ 0 , 1 ] )$ ;   \n4. Remove outliers from $S _ { t - 1 }$ defined as $\\{ i \\in S _ { t - 1 } : \\tau _ { i }$ is in the largest $2 \\alpha$ -tail of $\\{ \\tau _ { j } \\} _ { j \\in S _ { t - 1 } }$ and $\\tau _ { i } \\geq Z _ { t } \\tau _ { \\operatorname* { m a x } } \\}$ , where $\\tau _ { \\mathrm { m a x } } = \\operatorname* { m a x } _ { j \\in S _ { t - 1 } } \\tau _ { j }$ ",
+        "bbox": [
+            210,
+            549,
+            825,
+            650
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "This is repeated until the empirical covariance is sufficiently small and the empirical mean $\\hat { \\mu }$ is output. At a high level, the correctness of this algorithm relies on the key observation that the $\\alpha$ -fraction of adversarial corruption can not significantly change the mean of the dataset without introducing large eigenvalues in the empirical covariance. Therefore, the algorithm finds top eigenvector of the empirical covariance in step 1, and tries to correct the empirical covariance by removing corrupted data points. Each data point is assigned a score in step 2 which indicates the “badness” of the data points, and a threshold $Z _ { t }$ in step 3 is carefully designed such that step 4 guarantees to remove more corrupted data points than good data points (in expectation). This guarantees the following bound achieving the near-optimal sample complexity shown in the second row of Table 1. A formal description of this algorithm is in Algorithm 4 in Appendix C. ",
+        "bbox": [
+            173,
+            657,
+            825,
+            796
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Proposition 2.1 (Corollary of [63, Theorem 2.1]). Under assumption $^ { l }$ , the above filtering algorithm achieves accuracy $\\| \\hat { \\mu } - \\mu \\| _ { 2 } \\le O ( \\alpha \\sqrt { \\log ( 1 / \\alpha ) } ) \\ w . p . \\ 0 . 9 i f n \\ge \\widetilde { \\Omega } ( d / \\alpha ^ { 2 } ) \\ / .$ . ",
+        "bbox": [
+            171,
+            799,
+            823,
+            833
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Challenges in making robust mean estimation private. To get a DP and robust mean, a naive attempt is to apply a standard output perturbation mechanism to $\\hat { \\mu }$ . However, this is obviously challenging since the end-to-end sensitivity is intractable. The standard recipe to circumvent this is to make the current “state” $S _ { t }$ private at every iteration. Once $S _ { t - 1 }$ is private (hence, public knowledge), making the next “state” $S _ { t }$ private is simpler. We only need to analyze the sensitivity of a single step and apply some output perturbation mechanism with $\\left( \\varepsilon _ { t } , \\delta _ { t } \\right)$ . End-to-end privacy is guaranteed by accounting for all these $\\left( \\varepsilon _ { t } , \\delta _ { t } \\right)$ ’s using the advanced composition [51]. This recipe has been quite successful, for example, in training neural networks with (stochastic) gradient descent [1], where the current state can be the optimization variable $\\mathbf { x } _ { t }$ . However, for the above (non-private) filtering algorithm, this standard recipe fails, since the state $S _ { t }$ is a set and has large sensitivity. Changing a single data point in $S _ { t }$ can significantly alter which (and how many) samples are filtered out. ",
+        "bbox": [
+            174,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            175
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2.2 A new framework for private iterative filtering ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            196,
+            534,
+            212
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Instead of making the (highly sensitive) $S _ { t }$ itself private, we propose a new framework which makes private only the statistics of $S _ { t }$ : the mean $\\mu _ { t }$ and the top principal direction $v _ { t }$ . There are two versions of this algorithm, which output the exactly same $\\hat { \\mu }$ with the exactly same privacy guarantees, but are written from two different perspectives. We present here the interactive version from the perspective of an analyst accessing the dataset via DP queries $\\cdot q _ { \\mathrm { r a n g e } }$ , $q _ { \\mathrm { s i z e } }$ , $q _ { \\mathrm { m e a n } }$ , $q _ { \\mathrm { n o r m } }$ and $q _ { \\mathrm { P C A } } ,$ ), because this version makes clear the inner operations of each private mechanisms, hence making $( i )$ the sensitivity analysis transparent, $( i i )$ checking the correctness of privacy guarantees easy, and $( i i i )$ tracking privacy accountant simple. In practice, one should implement the centralized version (Algorithm 7 in Appendix D), which is significantly more efficient. ",
+        "bbox": [
+            173,
+            223,
+            825,
+            348
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1: Private iterative filtering (interactive version) ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            373,
+            563,
+            387
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Input: $S = \\{ x _ { i } \\} _ { i \\in [ n ] }$ , $\\alpha \\in ( 0 , 1 / 2 )$ , probability $\\zeta \\in ( 0 , 1 )$ , # of iterations $T = \\Theta ( d ) , ( \\varepsilon , \\delta )$   \n1 $( \\bar { x } , B ) \\gets q _ { \\mathrm { r a n g e } } ( S , 0 . 0 1 \\varepsilon , 0 . 0 1 \\delta )$   \n2 $\\varepsilon _ { 1 } \\gets \\operatorname* { m i n } \\{ 0 . 9 9 \\varepsilon , 0 . 9 \\} / ( 4 \\sqrt { 2 T \\log ( 2 / \\delta ) } )$ ), δ1 ← 0.99δ/(8T )   \n3 if $n < ( 4 / \\varepsilon _ { 1 } ) \\log ( 1 / ( 2 \\delta _ { 1 } ) )$ then Output: $\\varnothing$   \n4 for $t = 1 , \\dots , T$ do   \n5 $n _ { t }  q _ { \\mathrm { s i z e } } ( \\{ ( \\mu _ { \\ell } , v _ { \\ell } , Z _ { \\ell } ) \\} _ { \\ell \\in [ t - 1 ] } , \\varepsilon _ { 1 } , \\bar { x } , B )$ , if $n _ { t } < 3 n / 4$ then Output: $\\varnothing$   \n6 $\\mu _ { t }  q _ { \\mathrm { m e a n } } ( \\{ ( \\mu _ { \\ell } , v _ { \\ell } , Z _ { \\ell } ) \\} _ { \\ell \\in [ t - 1 ] } , \\varepsilon _ { 1 } , \\bar { x } , B )$   \n7 $\\lambda _ { t } \\gets q _ { \\mathrm { n o r m } } ( \\{ ( \\mu _ { \\ell } , v _ { \\ell } , Z _ { \\ell } ) \\} _ { \\ell \\in [ t - 1 ] } , \\mu _ { t } , \\varepsilon _ { 1 } , \\bar { x } , B )$   \n8 if $\\lambda _ { t } \\le ( C - 0 . 0 1 ) \\alpha \\log { 1 / \\alpha }$ then Output: $\\mu _ { t }$   \n9 $\\boldsymbol { v } _ { t }  q _ { \\mathrm { P C A } } ( \\{ ( \\mu _ { \\ell } , v _ { \\ell } , Z _ { \\ell } ) \\} _ { \\ell \\in [ t - 1 ] } , \\mu _ { t } , \\varepsilon _ { 1 } , \\delta _ { 1 } , \\bar { x } , B ) )$   \n10 $Z _ { t } \\gets \\mathrm { U n i f } ( [ 0 , 1 ] )$ ",
+        "bbox": [
+            160,
+            390,
+            776,
+            558
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Output: $\\mu _ { t }$ ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            559,
+            253,
+            573
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We give a high-level explanation of each step of Algorithm 1 here and give the formal definitions of all the queries in Appendix D. First, $q _ { \\mathrm { r a n g e } }$ returns (the parameters of) a hypercube $\\bar { x } + [ - B / 2 , B / 2 ] ^ { d }$ that is guaranteed to include all uncorrupted samples while preserving privacy. This is achieved by running $d$ coordinate-wise private histograms and selecting $\\bar { x } _ { j }$ as the center of the largest bin for the $j$ -th coordinate. Since covariance is I, $q _ { \\mathrm { r a n g e } }$ returns a fixed $B = 8 \\sigma \\sqrt { \\log ( d n / \\zeta ) }$ . Such an adaptive estimate of the support is critical in tightly bounding the sensitivity of all subsequent queries, which operate on the clipped dataset; all data points are projected as $\\mathcal { P } _ { \\bar { x } + [ - B / 2 , B / 2 ] ^ { d } } ( x ) =$ arg $\\begin{array} { r } { \\operatorname* { m i n } _ { y \\in \\bar { x } + [ - B / 2 , B / 2 ] ^ { c } } } \\end{array}$ $\\lVert y - x \\rVert _ { 2 }$ in all the queries that follow. With clipping, a single data point can now change at most by $B \\sqrt { d }$ . ",
+        "bbox": [
+            173,
+            598,
+            825,
+            732
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The subsequent steps perform the non-private filtering algorithm of $\\ S 2 . 1$ , but with private statistics $\\mu _ { t }$ and $v _ { t }$ . As the set $S _ { t }$ changes over time, we lower bound its size (which we choose to be $| S _ { t } | > n / 2 )$ ) to upper bound the sensitivity of other queries $q _ { \\mathrm { m e a n } } , q _ { \\mathrm { n o r m } }$ and $q _ { \\mathrm { P C A } }$ . ",
+        "bbox": [
+            174,
+            738,
+            825,
+            781
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "At the $t$ -th iterations, every time a query is called the data curator $( i )$ uses $( { \\bar { x } } , B )$ to clip the data, $( i i )$ computes $S _ { t }$ by running $t - 1$ steps of the non-private filtering algorithm of $\\ S 2 . 1$ but with a given fixed set of parameters $\\{ ( \\mu _ { \\ell } , v _ { \\ell } ) \\} _ { \\ell \\in [ t - 1 ] }$ (and the given randomness $\\{ Z _ { \\ell } \\} _ { \\ell \\in [ t - 1 ] } )$ , and $( i i i )$ computes the queried private statistics of $S _ { t }$ . If the private spectral norm of the covariance of $S _ { t }$ (i.e., $\\lambda _ { t } ,$ ) is sufficiently small, we output the private and robust mean $\\hat { \\mu } = \\mu _ { t }$ (line 8). Otherwise, we compute the private top PCA direction $v _ { t }$ and draw an randomness $Z _ { t }$ to be used in the next step of filtering, as in the non-private filtering algorithm. We emphasize that $\\{ S _ { \\ell } \\}$ are not private, and hence never returned to the analyst. We also note that this interactive version is redundant as every query is re-computing $S _ { t }$ . In our setting, the analyst has the dataset and there is no need to separate them. This leads to a centralized version we provide in Algorithm 7 in the appendix, which avoids redundant computations and hence is significantly more efficient. ",
+        "bbox": [
+            173,
+            786,
+            825,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            823,
+            119
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The main challenge in this framework is the privacy analysis. Because $\\{ S _ { \\ell } \\} _ { \\ell \\in [ t - 1 ] }$ is not private, each query runs $t - 1$ steps of filtering whose end-to-end sensitivity could blow-up. Algorithmically, $( i )$ we start with a specific choice of a non-private iterative filtering algorithm (among several variations that are equivalent in non-private setting but widely differ in its sensitivity), and $( i i )$ make appropriate changes in the private queries (Algorithm 1) to keep the sensitivity small. Analytically, the following key technical lemma allows a sharp analysis of the end-to-end sensitivity of iterative filtering. ",
+        "bbox": [
+            173,
+            126,
+            825,
+            210
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Lemma 2.2. Let $S _ { t } ( S )$ denote the resulting subset of samples after $t$ iterations of the filtering in the queries $( q _ { \\mathrm { s i z e } }$ , $q _ { \\mathrm { m e a n } }$ , $q _ { \\mathrm { n o r m } }$ , and $q _ { \\mathrm { P C A } } )$ are applied to a dataset $s$ using fixed parameters $\\{ ( \\mu _ { \\ell } , v _ { \\ell } , Z _ { \\ell } ) \\} _ { \\ell = 1 } ^ { t }$ . Then, we have $d _ { \\triangle } ( S _ { t } ( S ) , S _ { t } ( S ^ { \\prime } ) ) \\leq d _ { \\triangle } ( S , S ^ { \\prime } )$ , where $d _ { \\triangle } ( S , S ^ { \\prime } ) \\triangleq \\operatorname* { m a x } \\{ | S \\ \\backslash$ $S ^ { \\prime } | , | S ^ { \\prime } \\backslash S | \\}$ . ",
+        "bbox": [
+            173,
+            213,
+            825,
+            273
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Recall that two datasets are neighboring, i.e., $\\boldsymbol { S } \\sim \\boldsymbol { S } ^ { \\prime }$ , iff $d _ { \\triangle } ( S , S ^ { \\prime } ) \\leq 1$ . This lemma implies that if two datasets are neighboring, then they are still neighboring after filtering with the same parameters, no matter how many times we filter them. Hence, this lemma allows us to use the standard outputperturbation mechanisms with $( \\varepsilon _ { 1 } , \\delta _ { 1 } )$ -DP. Advanced composition ensures that end-to-end guarantee of $4 T$ such queries is $( 0 . 9 9 \\varepsilon , 0 . 9 9 \\delta )$ -DP. Together with $( 0 . 0 1 \\varepsilon , 0 . 0 1 \\delta )$ -DP budget used in $q _ { \\mathrm { r a n g e } }$ , this satisfied the target privacy. Analyzing the utility of this algorithm, we get the following guarantee. ",
+        "bbox": [
+            173,
+            281,
+            825,
+            367
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Theorem 5. Algorithm $^ { l }$ is $( \\varepsilon , \\delta )$ -DP. Under Assumption $^ { l }$ , there exists a universal constant $c \\in$ $( 0 , 0 . 1 )$ such that if $\\alpha \\leq c$ and $n = \\widetilde \\Omega \\left( ( d / \\alpha ^ { 2 } ) + d ^ { 2 } ( \\log ( 1 / \\delta ) ) ^ { 3 / 2 } / ( \\varepsilon \\alpha ) \\right)$ then Algorithm 1 achieves $\\| \\hat { \\mu } - \\mu \\| _ { 2 } \\leq O ( \\alpha \\sqrt { \\log ( 1 / \\alpha ) } )$ with probability 0.9. ",
+        "bbox": [
+            173,
+            369,
+            825,
+            420
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The first term $O ( d / \\alpha ^ { 2 } )$ in the sample complexity is optimal (cf. Table 1), but there is a factor of $d$ gap in the second term. This is due to the fact that we need to run $O ( d )$ iterations in the worst-case. Such numerous accesses to the database result in large noise to be added at each iteration, requiring large sample size to combat that extra noise. We introduce PRIME to reduce the number of iterations to ${ \\bar { O } } ( ( \\log { d } ) ^ { 2 } )$ and significantly reduce the sample complexity. ",
+        "bbox": [
+            173,
+            429,
+            825,
+            501
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "2.3 PRIME: novel robust and private mean estimator ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            515,
+            558,
+            531
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 (specifically Filter(·) in Algorithm 1) accesses the database $O ( d )$ times. This is necessary for two reasons. First, the filter checks only one direction $v _ { t }$ at each iteration. In the worst case, the corrupted samples can be scattered in $\\Omega ( d )$ orthogonal directions such that the filter needs to be repeated $O ( d )$ times. Secondly, even if the corrupted samples are clustered together in one direction, the filter still needs to be repeated $O ( d )$ times. This is because we had to use a large (random) threshold of $d B ^ { 2 } Z _ { t } = { \\cal { O } } ( d )$ to make the threshold data-independent so that we can keep the sensitivity of Filter(·) low, which results in slow progress. We propose filtering multiple directions simultaneously using a new score $\\{ \\tau _ { i } \\}$ based on the matrix multiplicative weights. Central to this approach is a novel adaptive filtering algorithm DPTHRESHOLD $( \\cdot )$ that guarantees sufficient decrease in the total score at every iteration. ",
+        "bbox": [
+            173,
+            540,
+            826,
+            680
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "2.3.1 Matrix Multiplicative Weight (MMW) scoring ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            693,
+            547,
+            709
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The MMW-based approach, pioneered in [36] for non-private robust mean estimation, filters out multiple directions simultaneously. It runs over $O ( \\log d )$ epochs and every epoch consists of $O ( \\log d )$ iterations. At every epoch $s$ and iteration $t$ , step 2 of the iterative filtering in $\\ S 2 . 1$ is replaced by a new score $\\tau _ { i } = ( x _ { i } - \\mathrm { M e a n } ( S _ { t } ^ { ( s ) } ) ) ^ { T } U _ { t } ^ { ( s ) } ( x _ { i } - \\mathrm { M e a n } ( S _ { t } ^ { ( s ) } ) )$ where $U _ { t } ^ { ( s ) }$ now accounts for all directions in $\\mathbb { R } ^ { d }$ but appropriately weighted. Precisely, it is defined via the matrix multiplicative update: ",
+        "bbox": [
+            174,
+            717,
+            826,
+            792
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/53bb8d5442b2b4afe0bd0508483ccca717b6e5178e5593b665b58a74b0e0e679.jpg",
+        "text": "$$\nU _ { t } ^ { ( s ) } = \\frac { \\exp \\left( \\alpha ^ { ( s ) } \\sum _ { r \\in [ t ] } ( \\mathrm { C o v } ( S _ { r } ^ { ( s ) } ) - { \\bf I } ) \\right) } { \\mathrm { T r } \\big ( \\exp ( \\alpha ^ { ( s ) } \\sum _ { r \\in [ t ] } ( \\mathrm { C o v } ( S _ { r } ^ { ( s ) } ) - { \\bf I } ) ) \\big ) } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            312,
+            797,
+            651,
+            847
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "for some choice of $\\alpha ^ { ( s ) } > 0$ . If we set the number of iterations to one, a choice of $\\alpha ^ { ( s ) } = \\infty$ recovers the previous score that relied on the top singular vector from $\\ S 2 . 1$ and a choice of $\\alpha ^ { ( s ) } = 0$ gives a simple norm based score $\\tau _ { i } = \\| x _ { i } \\| _ { 2 } ^ { 2 }$ . An appropriate choice of $\\alpha ^ { ( s ) }$ smoothly interpolates between these two extremes, which ensures that $O ( \\log d )$ iterations are sufficient for the spectral norm of the covariance to decrease strictly by a constant factor. This guarantees that after $O ( \\log d )$ epochs, we sufficiently decrease the covariance to ensure that the empirical mean is accurate enough. Critical in achieving this gain is our carefully designed filtering algorithm DPTHRESHOLD that uses the privately computed MMW-based scores using Gaussian mechanism on the covariance matrices as shown in Algorithm 11 in Appendix E. ",
+        "bbox": [
+            174,
+            853,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            161
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "2.3.2 Adaptive filtering with DPTHRESHOLD ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            175,
+            495,
+            190
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Novelty. The corresponding non-private filtering of [36, Algorithm 9] for robust mean estimation takes advantage of an adaptive threshold, but filters out each sample independently resulting in a prohibitively large sensitivity; the coupling between each sample and the randomness used to filter it can change widely between two neighboring datasets. On the other hand, Algorithm 1 (i.e., Filter(·) in Algorithm 6) takes advantage of jointly filtering all points above a single threshold $B ^ { 2 } d Z _ { t }$ with a single randomness $Z _ { t } \\sim \\mathrm { U n i f } [ 0 , 1 ]$ , but the non-adaptive (and hence large) choice of the range $B ^ { 2 } d$ results in a large number of iterations because each filtering only decrease the score by little. To sufficiently reduce the total score while maintaining a small sensitivity, we introduce a filter with a single and adaptive threshold. ",
+        "bbox": [
+            173,
+            198,
+            825,
+            324
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Algorithm. Our goal here is to privately find a single scalar $\\rho$ such that when a randomized filter is applied on the scores $\\{ \\tau _ { i } \\}$ with a (random) threshold $\\rho Z$ (with $Z$ drawn uniform in $[ 0 , 1 ] )$ , we filter out enough samples to make progress in each iteration while ensuring that we do not remove too many uncorrupted samples. This is a slight generalization of the non-private algorithm in Section 2.1, which simply set $\\rho = \\operatorname* { m a x } _ { j \\in S _ { t } } \\tau _ { j }$ . While this guarantees the filter removes more corrupted samples than good samples, it does not make sufficient progress in reducing the total score of the samples. ",
+        "bbox": [
+            173,
+            329,
+            825,
+            414
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Ideally, we want the thresholding to decrease the total score by a constant multiplicative factor, which will in the end allow the algorithm to terminate within logarithmic iterations. To this end, we propose a new scheme of using the largest $\\rho$ such that the following inequality holds: ",
+        "bbox": [
+            174,
+            420,
+            825,
+            462
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6e717cdd2620c553eeae0f0bac341635344a945d930dd30b1b3e271d36a171e1.jpg",
+        "text": "$$\n\\sum _ { \\tau _ { i } > \\rho } ( \\tau _ { i } - \\rho ) \\geq 0 . 3 1 \\sum _ { \\tau _ { i } \\in S _ { t } } ( \\tau _ { i } - 1 ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            364,
+            467,
+            599,
+            502
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We use a private histogram of the scores to approximate this threshold. Similar to [55, 58], we use geometrically increasing bin sizes such that we use only $O ( \\log B ^ { 2 } d )$ bins while achieving a preferred multiplicative error in our quantization. At each epoch $s$ and iteration $t$ , we run DPTHRESHOLD sketched in the following to approximate $\\rho$ followed by a random filter. Step 3 replaces the non-private condition in Eq. (1). A complete description is provided in Algorithm 11. ",
+        "bbox": [
+            174,
+            507,
+            825,
+            579
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "1. Privately compute scores for all data points $i \\in S _ { t } ^ { ( s ) } : \\tau _ { i } \\gets ( x _ { i } - \\mu _ { t } ) ^ { \\top } U _ { t } ^ { ( s ) } ( x _ { i } - \\mu _ { t } ) ;$ ;   \n2. Compute a private histogram $\\{ \\tilde { h } _ { j } \\} _ { j = 1 } ^ { 2 + \\log ( B ^ { 2 } d ) }$ t i  i  t  t i  t of the scores over geometrically sized bins   \n$I _ { 1 } = [ 1 / 4 , 1 / 2 )$ , $I _ { 2 } = [ 1 / 2 , 1 ) , \\ldots , \\bar { I } _ { 2 + \\log ( B ^ { 2 } d ) } = [ 2 ^ { \\log ( B ^ { 2 } d ) - 1 } , 2 ^ { \\log ( B ^ { 2 } d ) } ]$ ;   \n3. Privately find the largest $\\ell$ satisfying $\\begin{array} { r } { \\sum _ { j \\ge \\ell } ( 2 ^ { j } - 2 ^ { \\ell } ) \\tilde { h } _ { j } \\ge 0 . 3 1 \\sum _ { i \\in S _ { t } ^ { ( s ) } } ( \\tau _ { i } - 1 ) ; } \\end{array}$ ;   \n4. Output $\\rho = 2 ^ { \\ell }$ . ",
+        "bbox": [
+            210,
+            587,
+            826,
+            676
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3 Analyses of PRIME ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            693,
+            370,
+            710
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Building on the framework of Algorithm 1, PRIME (Algorithm 9) replaces the score with the MMWbased score presented in $\\ S 2 . 3 . 1$ and the filter with the adaptive DPTHRESHOLD. This reduces the number of iterations to $T = O ( ( \\log d ) ^ { 2 } )$ achieving the following bound. ",
+        "bbox": [
+            174,
+            724,
+            826,
+            767
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Theorem 6. PRIME is $( \\varepsilon , \\delta )$ -differentially private. Under Assumption $I$ there exists a universal constant $c \\in ( 0 , 0 . 1 )$ such that if $\\alpha \\leq c$ and $n = \\widetilde \\Omega ( ( d / \\alpha ^ { 2 } ) + ( d ^ { 3 / 2 } / ( \\varepsilon \\alpha ) ) \\log ( 1 / \\delta ) )$ , then PRIME achieves $\\| \\hat { \\mu } - \\mu \\| _ { 2 } = O ( \\alpha \\sqrt { \\log ( 1 / \\alpha ) } )$ with probability 0.9. ",
+        "bbox": [
+            174,
+            771,
+            825,
+            820
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "A proof is provided in Appendix F. The notation $\\widetilde { \\Omega } ( \\cdot )$ hides logarithmic terms in $d , R$ , and $1 / \\alpha$ . To achieve an error of $O ( \\alpha \\sqrt { \\log ( 1 / \\alpha ) } )$ , the first term $\\widetilde \\Omega ( d / \\alpha ^ { 2 } \\log ( 1 / \\alpha ) )$ is necessary even if there is no corruption. The accuracy of $O ( \\alpha \\sqrt { \\log ( 1 / \\alpha ) } )$ matches the lower bound shown in [33] for any polynomial time statistical query algorithm, and it nearly matches the information theoretical lower bound on robust estimation of $\\Omega ( \\alpha )$ . On the other hand, the second term of $\\widetilde \\Omega ( d ^ { 3 / 2 } / ( \\varepsilon \\alpha \\log ( 1 / \\alpha ) ) )$ ",
+        "bbox": [
+            174,
+            830,
+            825,
+            912
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "has an extra factor of $d ^ { 1 / 2 }$ compared to the optimal one achieved by exponential time Algorithm 2. It is an open question if this gap can be closed by a polynomial time algorithm. ",
+        "bbox": [
+            171,
+            90,
+            823,
+            119
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The bottleneck is the private matrix multiplicative weights. Such spectral analyses are crucial in filter-based robust estimators. Even for a special case of privately computing the top principal component, the best polynomial time algorithm requires $\\bar { O } ( d ^ { 3 / 2 } )$ samples [39, 18, 78], and this sample complexity is also necessary as shown in [39, Corollary 25]. ",
+        "bbox": [
+            174,
+            126,
+            825,
+            183
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To boost the success probability to $1 - \\zeta$ for some small $\\zeta > 0$ , we need an extra $\\log ( 1 / \\zeta )$ factor in the sample complexity to make sure the dataset satisfies the regularity condition with probability $\\zeta / 2$ . Then we can run PRIME $\\log ( 1 / \\zeta )$ times and choose the output of a run that satisfies $n ^ { ( s ) } > n ( 1 { - } 1 0 \\alpha )$ and $\\lambda ^ { ( s ) } \\le C \\alpha \\log ( 1 / \\alpha )$ at termination. ",
+        "bbox": [
+            174,
+            189,
+            826,
+            250
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/46a53c55cd9bcc36cd60657375546149f2ff820d7058a98083ffc81ea44ac394.jpg",
+        "image_caption": [
+            "Figure 1: Private mean estimators (e.g., DP mean [52]) are vulnerable to adversarial corruption especially in high dimensions, while the proposed PRIME achieves robustness (and privacy) regardless of the dimension of the samples. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            266,
+            826,
+            363
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Numerical experiments support our theoretical claims. The left figure with $( \\alpha , \\varepsilon , \\delta , n ) \\ =$ $( 0 . 0 5 , 2 0 , 0 . 0 1 , 1 0 ^ { 6 } )$ is in the large $\\alpha$ regime where the DP Mean error is dominates by $\\alpha \\sqrt { d }$ and PRIME error by $\\alpha \\sqrt { \\log ( 1 / \\alpha ) }$ . Hence, PRIME error is constant whereas DP Mean error increases with the dimension $d$ . The second figure with √ $( \\alpha , \\varepsilon , \\delta , n ) = ( 0 . 0 0 1 , 2 0 , 0 . 0 1 , 1 0 ^ { 6 } )$ is in the small $\\alpha$ regime when DP Mean error consists of $\\alpha \\sqrt { d } + \\sqrt { d / n }$ and PRIME is dominated by $\\sqrt { d / n }$ . Both increase with the dimension $d$ , and the gap can be made large by increasing $\\alpha$ . The right figure√ with $( \\alpha , \\delta , d , n ) = ( 0 . 1 , 0 . 0 1 , 1 0 , 1 0 ^ { 6 } )$ is when DP Mean error is dominated by $\\alpha \\sqrt { d }$ and PRIME by $\\alpha \\sqrt { \\log ( 1 / \\alpha ) }$ when $\\varepsilon > c d ^ { 1 . 5 } / ( \\alpha n )$ . Below this threshold, which happens in this example around $\\varepsilon = 0 . 0 5$ , the added noise in the private mechanism starts to dominate with decreasing $\\varepsilon$ . Both algorithms have respective thresholds below which the error increases with decreasing $\\varepsilon$ . This threshold is larger for PRIME because it uses the privacy budget to perform multiple operations and hence the noise added to the final output is larger compared to DP Mean. Below this threshold, which can be easily determined based on the known parameters $( \\varepsilon , \\delta , n , \\alpha )$ , we should either collect more data (which will decrease the threshold) or give up filtering and spend all privacy budget on $q _ { \\mathrm { r a n g e } }$ and the empirical mean (which will reduce the error). Details of the experiments are in Appendix L. ",
+        "bbox": [
+            173,
+            430,
+            825,
+            650
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4 Exponential time algorithm with near-optimal sample complexity ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            674,
+            750,
+            693
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Novelty. An existing exponential time algorithm for robust and private mean estimation in [14] strictly requires the uncorrupted samples to be drawn from a Gaussian distribution. We also provide a similar algorithm based on private Tukey median in Appendix I and its analysis in Appendix J. In this section, we introduce a novel estimator that achieves near-optimal guarantees for more general sub-Gaussian distributions (and also covariance bounded distributions) but takes an exponential run-time. Its innovation is in leveraging on the resilience property of well-behaved distributions not only to estimate the mean robustly (which is the standard use of the property) but also to adaptively bound the sensitivity of the estimator, thus achieving optimal privacy-accuracy tradeoff. ",
+        "bbox": [
+            173,
+            708,
+            825,
+            820
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Definition 4.1 (Resilience from Definition 1 in [73]). $A$ set of points $\\{ x _ { i } \\} _ { i \\in S }$ lying in $\\mathbb { R } ^ { d }$ is $( \\sigma , \\alpha )$ - resilient around a point $\\mu$ $\\begin{array} { r } { . i f \\| ( 1 / | T | ) \\sum _ { i \\in T } ( x _ { i } - \\mu ) \\| _ { 2 } \\leq \\sigma } \\end{array}$ for all subsets $T \\subset S$ of size $( 1 - \\alpha ) | S |$ . ",
+        "bbox": [
+            171,
+            825,
+            825,
+            857
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Algorithm. As data is corrupted, we define $R ( S )$ as a surrogate for resilience of the uncorrupted part of the set. If $S$ indeed consists of a $1 - \\alpha$ fraction of independent samples from the promised class of distributions, the goodness score $R ( S )$ will be close to the resilience property of the good data. ",
+        "bbox": [
+            174,
+            868,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Definition 4.2 (Goodness of a set). For $\\mu ( S ) = ( 1 / | S | ) \\sum _ { i \\in S } x _ { i }$ , let us define ",
+        "bbox": [
+            171,
+            89,
+            691,
+            108
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a63fff882c56dd4d22cd7a5e3f73c597dc62e918ef47ae2bcdaf9517671e805d.jpg",
+        "text": "$$\nR ( S ) \\stackrel { \\Delta } { = } \\operatorname* { m i n } _ { \\substack { S ^ { \\prime } \\subset S , | S ^ { \\prime } | = ( 1 - 2 \\alpha ) | S | . } } \\operatorname* { m a x } _ { \\substack { T \\subset S ^ { \\prime } , | T | = ( 1 - \\alpha ) | S ^ { \\prime } | . } } \\| \\mu ( T ) - \\mu ( S ^ { \\prime } ) \\| _ { 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            261,
+            113,
+            738,
+            140
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 2 first checks if the resilience matches that of the promised distribution. The data is pre-processed with $q _ { \\mathrm { r a n g e } }$ to ensure we can check $R ( S )$ privately. Once resilience is cleared, we can safely use the exponential mechanism based on the score function $d ( \\hat { \\mu } , S )$ in Definition 4.3 to select an approximate robust mean $\\hat { \\mu }$ privately. The choice of the sensitivity critically relies on the fact that resilient datasets have small sensitivity of ${ \\cal O } ( ( 1 / n ) \\sqrt { \\log ( 1 / \\alpha ) } )$ . Without the resilience check, the sensitivity is $O ( d ^ { 1 / 2 } / n )$ resulting in an extra factor of $\\sqrt { d }$ in the sample complexity. ",
+        "bbox": [
+            173,
+            161,
+            826,
+            252
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Input: $S = \\{ x _ { i } \\} _ { i \\in [ n ] } , \\alpha \\in ( 0 , 1 / 2 ) , ( \\varepsilon , \\delta )$   \n1 if $n < c d ^ { 1 / 2 } \\log ( 1 / \\delta ) / \\left( \\varepsilon \\alpha \\sqrt { \\log ( 1 / \\alpha ) } \\right)$ then Output: $\\emptyset \\ [ \\ c d ^ { 1 / 2 } \\log ( 1 / \\delta ) / \\ ( \\varepsilon \\alpha )$ for hevay-tail]   \n2 $( \\bar { x } , B ) \\gets q _ { \\mathrm { r a n g e } } ( S , ( 1 / 3 ) \\varepsilon , ( 1 / 3 ) \\delta )$ $[ \\ q _ { \\mathrm { r a n g e - h t } } ( \\cdot )$ for hevay-tail]   \n3 Project the data points onto the ball: $x _ { i }  \\mathcal { P } _ { B _ { \\sqrt { d } B / 2 } ( \\bar { x } ) } ( x _ { i } )$ , for all $i \\in [ n ]$   \n4 $\\widehat { R } ( S ) \\gets R ( S ) + \\mathrm { L a p } ( 3 B d ^ { 1 / 2 } / ( n \\varepsilon ) )$   \n5 if $\\widehat { R } ( S ) > 2 \\alpha \\sqrt { \\log ( 1 / \\alpha ) }$ then Output: $\\varnothing$ $[ \\widehat { R } ( S ) > 2 c _ { \\zeta } \\sqrt { \\alpha }$ for hevay-tail]   \n6 else Output: a randomly drawn point $\\hat { \\mu } \\in \\mathcal { B } _ { \\sqrt { d } B / 2 } ( \\bar { x } )$ sampled from a density   \n7 r(ˆµ) ∝ e−(1/(24 log(1/α)))ε n d(ˆµ,S) $[ e ^ { - ( \\varepsilon n \\sqrt { \\alpha } / ( 2 4 c _ { \\zeta } ) ) d ( \\hat { \\mu } , S ) }$ for heavy-tail] ",
+        "bbox": [
+            158,
+            287,
+            815,
+            425
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We propose the score function $d ( \\hat { \\mu } , S )$ in the following definition, which is a robust estimator of the distance between the mean and the candidate $\\hat { \\mu }$ . ",
+        "bbox": [
+            171,
+            443,
+            823,
+            472
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Definition 4.3. For a set of data $\\{ x _ { i } \\} _ { i \\in S }$ lying in $\\mathbb { R } ^ { d }$ , for any $v \\in \\mathbb { S } ^ { d - 1 }$ , define $\\mathcal { T } ^ { v }$ to be the $3 \\alpha | S |$ points with the largest $v ^ { \\top } x _ { i }$ value, $B ^ { v }$ to be the $3 \\alpha | S |$ points with the smallest $v ^ { \\top } x _ { i }$ value, and $\\mathcal { M } ^ { v } = S \\setminus ( \\mathcal { T } ^ { v } \\cup B ^ { v } )$ . Define $\\begin{array} { r l r } { d ( \\hat { \\mu } , S ) } & { \\triangleq } & { \\operatorname* { m a x } _ { v \\in \\mathbb { S } ^ { d - 1 } } \\left. v ^ { \\top } \\left( \\mu ( \\mathcal { M } ^ { v } ) - \\hat { \\mu } \\right) \\right. } \\end{array}$ . ",
+        "bbox": [
+            173,
+            474,
+            825,
+            523
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Analysis. For any direction $v$ , the truncated mean estimator $\\mu ( \\mathcal { M } ^ { v } )$ provides a robust estimation of the true mean along the direction $v$ , thus the distance can be simply defined by taking the maximum over all directions $v$ . We show the sensitivity of this simple estimator is bounded by the resilience property $\\sigma$ divided by $n$ , which is ${ \\cal O } ( ( 1 / n ) \\sqrt { \\log ( 1 / \\alpha ) } )$ once the resilience check is passed. This leads to the following near-optimal sample complexity. We provide a proof in Appendix H.2. ",
+        "bbox": [
+            173,
+            532,
+            825,
+            606
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Theorem 7 (Exponential time algorithm for sub-Gaussian distributions). Algorithm 2 is $( \\varepsilon , \\delta )$ -DP. Under Assumption $^ { l }$ , this algorithm achieves $\\| \\hat { \\mu } - \\mu \\| _ { 2 } = O ( \\alpha \\sqrt { \\log ( 1 / \\alpha ) } )$ with probability $1 - \\zeta i f$ ",
+        "bbox": [
+            173,
+            608,
+            826,
+            641
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9aa30506fb06fc1067dfbb7018804b830bc0f54e20e433fb8eb13e7b665ff047.jpg",
+        "text": "$$\nn = \\widetilde \\Omega \\Big ( \\frac { d + \\log \\frac { 1 } { \\xi } } { \\alpha ^ { 2 } \\log \\frac { 1 } { \\alpha } } + \\frac { d \\log \\Big ( d \\sqrt { \\log ( d n / \\zeta ) } / \\alpha \\Big ) + d ^ { 1 / 2 } \\log \\frac { 1 } { \\delta } + \\log \\frac { 1 } { \\zeta } } { \\varepsilon \\alpha } + \\frac { \\sqrt { d \\log \\frac { 1 } { \\delta } } \\log \\frac { d } { \\zeta \\delta } } { \\varepsilon } \\Big ) ~ .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            194,
+            646,
+            803,
+            693
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Run-time. Computing $R ( S )$ exactly can take $O ( d e ^ { \\Theta ( n ) } )$ operations. The exponential mechanism implemented with $\\alpha$ -covering for $\\hat { \\mu }$ and a constant covering for $v$ can take $O ( n d ( \\sqrt { \\log ( d n / \\zeta ) } / \\alpha ) ^ { d } )$ operations. ",
+        "bbox": [
+            174,
+            704,
+            826,
+            751
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            768,
+            299,
+            786
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Differentially private mean estimation is brittle against a small fraction of the samples being corrupted by an adversary. We show that robustness can be achieved without any increase in the sample complexity by introducing a novel DP mean estimator, which requires run-time exponential in the dimension of the samples. The technical contribution is in leveraging the resilience property of well-behaved distributions in an innovative way to not only find robust mean (which is the typical use case of resilience) but also bound sensitivity for optimal privacy guarantee. To cope with the computational challenge, we propose an efficient algorithm, which we call PRIME, that achieves the optimal target accuracy at the cost of an increased sample complexity. The technical contributions are $( i )$ a novel framework for private iterative filtering and its tight analysis of the end-to-end sensitivity and $( i i )$ novel filtering algorithm of DPTHRESHOLD which is critical in privately running matrix multiplicative weights and hence significantly reducing the number of accesses to the database. With appropriately chosen parameters, we show that our exponential time approach achieves near-optimal guarantees for both sub-Gaussian and covariance bounded distributions and PRIME achieves the same accuracy efficiently but at the cost of an increased sample complexity by a $d ^ { 1 / 2 }$ factor. ",
+        "bbox": [
+            173,
+            799,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            92,
+            825,
+            176
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "There are several directions for improving our results further and applying the framework to solve other problems. PRIME provides a new design principle for private and robust estimation. This can be more broadly applied to fundamental statistical analyses such as robust covariance estimation [28, 30, 64] robust PCA [60, 48], and robust linear regression [59, 35]. ",
+        "bbox": [
+            174,
+            183,
+            825,
+            238
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "PRIME could be improved in a few directions. First, the sample complexity of $\\widetilde \\Omega ( ( d / ( \\alpha ^ { 2 } \\log ( 1 / \\alpha ) ) ) +$ $( d ^ { 3 / 2 } / ( \\varepsilon \\alpha \\log ( 1 / \\alpha ) ) ) \\log ( 1 / \\delta ) )$ in Theorem 6 is suboptimal in the second term. Improving the $d ^ { 3 / 2 }$ factor requires bypassing differentially private singular value decomposition, which seems to be a challenging task. However, it might be possible to separate the $\\bar { \\log ( 1 / \\delta ) }$ factor from the rest of the terms and get an additive error of the form $\\widetilde \\Omega ( ( d / ( \\alpha ^ { 2 } \\log ( 1 / \\alpha ) ) ) + ( d ^ { 3 / 2 } / ( \\varepsilon \\alpha \\log ( 1 / \\alpha ) ) ) +$ $( 1 / \\varepsilon ) \\log ( 1 / \\delta ) )$ . This requires using Laplace mechanism in private MMW (line 16 Algortihm 10). Secondly, the time complexity of PRIME is dominated by computation time of the matrix exponential in (line 16 Algortihm 10). Total number of operations scale as ${ \\widetilde { O } } ( d ^ { 3 } + n d ^ { 2 } )$ . One might hope to achieve $\\widetilde O ( n d )$ time complexity using approximate computations of $\\tau _ { j }$ ’s using techniques from [36]. This does not improve the sample complexity, as the number of times the dataset is accessed remains the same. Finally, for (non-robust) private mean estimation, COINPRESS provides a practical improvement in the small sample regime by progressively refining the search space [12]. The same principle could be applied to PRIME to design a robust version of COINPRESS. One important question remains open; how are differential privacy and robust statistics fundamentally related? We believe our exponential time algorithm hints on a fundamental connection between robust statistics of a data projected onto one-dimensional subspace and sensitivity of resulting score function for the exponential mechanism. It is an interesting direction to pursue this connection further to design novel algorithms that bridge privacy and robustness. ",
+        "bbox": [
+            173,
+            246,
+            826,
+            505
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgement ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            525,
+            330,
+            541
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sham Kakade acknowledges funding from the National Science Foundation under award CCF1703574. Sewoong Oh acknowledges funding from Google faculty research award, NSF grants IIS-1929955, CCF-1705007, CNS-2002664, CCF 2019844 as a part of Institute for Foundation of Machine Learning, and CNS-2112471 as a part of Institute for Future Edge Networks and Distributed Intelligence. ",
+        "bbox": [
+            174,
+            555,
+            825,
+            626
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            645,
+            266,
+            660
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[1] Martin Abadi, Andy Chu, Ian Goodfellow, H Brendan McMahan, Ilya Mironov, Kunal Talwar, and Li Zhang. Deep learning with differential privacy. In Proceedings of the 2016 ACM SIGSAC Conference on Computer and Communications Security, pages 308–318, 2016.   \n[2] John M Abowd. The us census bureau adopts differential privacy. In Proceedings of the 24th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, pages 2867–2867, 2018.   \n[3] Ishaq Aden-Ali, Hassan Ashtiani, and Gautam Kamath. On the sample complexity of privately learning unbounded high-dimensional gaussians. arXiv preprint arXiv:2010.09929, 2020.   \n[4] Zeyuan Allen-Zhu, Zhenyu Liao, and Lorenzo Orecchia. Spectral sparsification and regret minimization beyond matrix multiplicative updates. In Proceedings of the forty-seventh annual ACM symposium on Theory of computing, pages 237–245, 2015.   \n[5] Edoardo Amaldi and Viggo Kann. The complexity and approximability of finding maximum feasible subsystems of linear relations. Theoretical computer science, 147(1-2):181–210, 1995.   \n[6] Frank J Anscombe. Rejection of outliers. Technometrics, 2(2):123–146, 1960. [7] Ainesh Bakshi and Pravesh Kothari. List-decodable subspace recovery via sum-of-squares. arXiv preprint arXiv:2002.05139, 2020.   \n[8] S. Balakrishnan, S. S. Du, J. Li, and A. Singh. Computationally efficient robust sparse estimation in high dimensions. In Proceedings of the 30th Conference on Learning Theory, COLT 2017, pages 169–212, 2017.   \n[9] Amos Beimel, Shay Moran, Kobbi Nissim, and Uri Stemmer. Private center points and learning of halfspaces. arXiv preprint arXiv:1902.10731, 2019.   \n[10] K. Bhatia, P. Jain, P. Kamalaruban, and P. Kar. Consistent robust regression. In Advances in Neural Information Processing Systems 30: Annual Conference on Neural Information Processing Systems 2017, pages 2107–2116, 2017.   \n[11] Kush Bhatia, Prateek Jain, and Purushottam Kar. Robust regression via hard thresholding. In Advances in Neural Information Processing Systems, pages 721–729, 2015.   \n[12] Sourav Biswas, Yihe Dong, Gautam Kamath, and Jonathan Ullman. Coinpress: Practical private mean and covariance estimation. arXiv preprint arXiv:2006.06618, 2020.   \n[13] Avrim Blum, Cynthia Dwork, Frank McSherry, and Kobbi Nissim. Practical privacy: the sulq framework. In Proceedings of the twenty-fourth ACM SIGMOD-SIGACT-SIGART symposium on Principles of database systems, pages 128–138, 2005.   \n[14] Mark Bun, Gautam Kamath, Thomas Steinke, and Steven Z Wu. Private hypothesis selection. In Advances in Neural Information Processing Systems, pages 156–167, 2019.   \n[15] T Tony Cai, Yichen Wang, and Linjun Zhang. The cost of privacy: Optimal rates of convergence for parameter estimation with differential privacy. arXiv preprint arXiv:1902.04495, 2019.   \n[16] Clément L Canonne, Gautam Kamath, Audra McMillan, Jonathan Ullman, and Lydia Zakynthinou. Private identity testing for high-dimensional distributions. arXiv preprint arXiv:1905.11947, 2019.   \n[17] Moses Charikar, Jacob Steinhardt, and Gregory Valiant. Learning from untrusted data. In Proceedings of the 49th Annual ACM SIGACT Symposium on Theory of Computing, pages 47–60, 2017.   \n[18] Kamalika Chaudhuri, Anand D Sarwate, and Kaushik Sinha. A near-optimal algorithm for differentially-private principal components. The Journal of Machine Learning Research, 14(1):2905–2943, 2013.   \n[19] Xinyun Chen, Chang Liu, Bo Li, Kimberly Lu, and Dawn Song. Targeted backdoor attacks on deep learning systems using data poisoning. arXiv preprint arXiv:1712.05526, 2017.   \n[20] Yu Cheng, Ilias Diakonikolas, and Rong Ge. High-dimensional robust mean estimation in nearly-linear time. In Proceedings of the Thirtieth Annual ACM-SIAM Symposium on Discrete Algorithms, pages 2755–2771. SIAM, 2019.   \n[21] Yu Cheng, Ilias Diakonikolas, Rong Ge, and David P Woodruff. Faster algorithms for highdimensional robust covariance estimation. In Conference on Learning Theory, pages 727–757. PMLR, 2019.   \n[22] Yeshwanth Cherapanamjeri, Sidhanth Mohanty, and Morris Yau. List decodable mean estimation in nearly linear time. arXiv preprint arXiv:2005.09796, 2020.   \n[23] Arnak Dalalyan and Philip Thompson. Outlier-robust estimation of a sparse linear model using $\\ell _ { 1 }$ -penalized huber’s $m$ -estimator. In Advances in Neural Information Processing Systems, pages 13188–13198, 2019.   \n[24] Jules Depersin and Guillaume Lecué. Robust subgaussian estimation of a mean vector in nearly linear time. arXiv preprint arXiv:1906.03058, 2019.   \n[25] Luc Devroye and Gábor Lugosi. Combinatorial methods in density estimation. Springer Science & Business Media, 2012. ",
+        "bbox": [
+            179,
+            667,
+            826,
+            914
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            56,
+            828,
+            917
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[26] Aditya Dhar and Jason Huang. Designing differentially private estimators in high dimensions. arXiv preprint arXiv:2006.01944, 2020. ",
+        "bbox": [
+            171,
+            90,
+            825,
+            119
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[27] Ilias Diakonikolas, Samuel B Hopkins, Daniel Kane, and Sushrut Karmalkar. Robustly learning any clusterable mixture of gaussians. arXiv preprint arXiv:2005.06417, 2020. ",
+        "bbox": [
+            171,
+            128,
+            823,
+            159
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[28] Ilias Diakonikolas, Gautam Kamath, Daniel Kane, Jerry Li, Ankur Moitra, and Alistair Stewart. Robust estimators in high-dimensions without the computational intractability. SIAM Journal on Computing, 48(2):742–864, 2019. ",
+        "bbox": [
+            174,
+            166,
+            825,
+            210
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[29] Ilias Diakonikolas, Gautam Kamath, Daniel Kane, Jerry Li, Jacob Steinhardt, and Alistair Stewart. Sever: A robust meta-algorithm for stochastic optimization. In International Conference on Machine Learning, pages 1596–1606, 2019. ",
+        "bbox": [
+            171,
+            218,
+            823,
+            262
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[30] Ilias Diakonikolas, Gautam Kamath, Daniel M. Kane, Jerry Li, Ankur Moitra, and Alistair Stewart. Being Robust (in High Dimensions) Can Be Practical. arXiv e-prints, page arXiv:1703.00893, March 2017. ",
+        "bbox": [
+            173,
+            271,
+            825,
+            314
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[31] Ilias Diakonikolas, Gautam Kamath, Daniel M Kane, Jerry Li, Ankur Moitra, and Alistair Stewart. Robustly learning a gaussian: Getting optimal error, efficiently. In Proceedings of the Twenty-Ninth Annual ACM-SIAM Symposium on Discrete Algorithms, pages 2683–2702. SIAM, 2018. ",
+        "bbox": [
+            173,
+            321,
+            825,
+            378
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[32] Ilias Diakonikolas and Daniel M Kane. Recent advances in algorithmic high-dimensional robust statistics. arXiv preprint arXiv:1911.05911, 2019. ",
+        "bbox": [
+            173,
+            387,
+            823,
+            417
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[33] Ilias Diakonikolas, Daniel M Kane, and Alistair Stewart. Statistical query lower bounds for robust estimation of high-dimensional gaussians and gaussian mixtures. In 2017 IEEE 58th Annual Symposium on Foundations of Computer Science (FOCS), pages 73–84. IEEE, 2017. ",
+        "bbox": [
+            176,
+            426,
+            823,
+            469
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[34] Ilias Diakonikolas, Daniel M Kane, and Alistair Stewart. List-decodable robust mean estimation and learning mixtures of spherical gaussians. In Proceedings of the 50th Annual ACM SIGACT Symposium on Theory of Computing, pages 1047–1060, 2018. ",
+        "bbox": [
+            174,
+            478,
+            823,
+            522
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[35] Ilias Diakonikolas, Weihao Kong, and Alistair Stewart. Efficient algorithms and lower bounds for robust linear regression. In Proceedings of the Thirtieth Annual ACM-SIAM Symposium on Discrete Algorithms, pages 2745–2754. SIAM, 2019. ",
+        "bbox": [
+            174,
+            530,
+            823,
+            573
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[36] Yihe Dong, Samuel Hopkins, and Jerry Li. Quantum entropy scoring for fast robust mean estimation and improved outlier detection. In Advances in Neural Information Processing Systems, pages 6067–6077, 2019. ",
+        "bbox": [
+            173,
+            582,
+            823,
+            625
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[37] Cynthia Dwork, Frank McSherry, Kobbi Nissim, and Adam Smith. Calibrating noise to sensitivity in private data analysis. In Theory of cryptography conference, pages 265–284. Springer, 2006. ",
+        "bbox": [
+            173,
+            633,
+            825,
+            676
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[38] Cynthia Dwork and Aaron Roth. The algorithmic foundations of differential privacy. Foundations and Trends in Theoretical Computer Science, 9(3-4):211–407, 2014. ",
+        "bbox": [
+            173,
+            685,
+            825,
+            715
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[39] Cynthia Dwork, Kunal Talwar, Abhradeep Thakurta, and Li Zhang. Analyze gauss: optimal bounds for privacy-preserving principal component analysis. In Proceedings of the forty-sixth annual ACM symposium on Theory of computing, pages 11–20, 2014. ",
+        "bbox": [
+            173,
+            724,
+            825,
+            767
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[40] Úlfar Erlingsson, Vasyl Pihur, and Aleksandra Korolova. Rappor: Randomized aggregatable privacy-preserving ordinal response. In Proceedings of the 2014 ACM SIGSAC conference on computer and communications security, pages 1054–1067, 2014. ",
+        "bbox": [
+            173,
+            776,
+            823,
+            820
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[41] Giulia Fanti, Vasyl Pihur, and Úlfar Erlingsson. Building a rappor with the unknown: Privacypreserving learning of associations and data dictionaries. Proceedings on Privacy Enhancing Technologies, 2016(3):41–61, 2016. ",
+        "bbox": [
+            173,
+            830,
+            821,
+            873
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[42] Chao Gao et al. Robust regression via mutivariate regression depth. Bernoulli, 26(2):1139–1170, 2020. ",
+        "bbox": [
+            173,
+            882,
+            821,
+            911
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[43] Sam Hopkins, Jerry Li, and Fred Zhang. Robust and heavy-tailed mean estimation made simple, via regret minimization. Advances in Neural Information Processing Systems, 33, 2020. ",
+        "bbox": [
+            171,
+            90,
+            826,
+            121
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[44] Samuel B Hopkins. Mean estimation with sub-gaussian rates in polynomial time. Annals of Statistics, 48(2):1193–1213, 2020.   \n[45] Samuel B Hopkins and Jerry Li. Mixture models, robustness, and sum of squares proofs. In Proceedings of the 50th Annual ACM SIGACT Symposium on Theory of Computing, pages 1021–1034, 2018.   \n[46] Samuel B Hopkins and Jerry Li. How hard is robust mean estimation? In Conference on Learning Theory, pages 1649–1682. PMLR, 2019.   \n[47] Peter J. Huber. Robust Estimation of a Location Parameter. The Annals of Mathematical Statistics, 35(1):73 – 101, 1964.   \n[48] Arun Jambulapati, Jerry Li, and Kevin Tian. Robust sub-gaussian principal component analysis and width-independent schatten packing. Advances in Neural Information Processing Systems, 33, 2020.   \n[49] He Jia and Santosh Vempala. Robustly clustering a mixture of gaussians. arXiv preprint arXiv:1911.11838, 2019.   \n[50] Peter Kairouz, H Brendan McMahan, Brendan Avent, Aurélien Bellet, Mehdi Bennis, Arjun Nitin Bhagoji, Keith Bonawitz, Zachary Charles, Graham Cormode, Rachel Cummings, et al. Advances and open problems in federated learning. arXiv preprint arXiv:1912.04977, 2019.   \n[51] Peter Kairouz, Sewoong Oh, and Pramod Viswanath. The composition theorem for differential privacy. In International conference on machine learning, pages 1376–1385, 2015.   \n[52] Gautam Kamath, Jerry Li, Vikrant Singhal, and Jonathan Ullman. Privately learning highdimensional distributions. In Conference on Learning Theory, pages 1853–1902, 2019.   \n[53] Gautam Kamath, Or Sheffet, Vikrant Singhal, and Jonathan Ullman. Differentially private algorithms for learning mixtures of separated gaussians. In 2020 Information Theory and Applications Workshop (ITA), pages 1–62. IEEE, 2020.   \n[54] Gautam Kamath, Vikrant Singhal, and Jonathan Ullman. Private mean estimation of heavy-tailed distributions. arXiv preprint arXiv:2002.09464, 2020.   \n[55] Haim Kaplan, Katrina Ligett, Yishay Mansour, Moni Naor, and Uri Stemmer. Privately learning thresholds: Closing the exponential gap. In Conference on Learning Theory, pages 2263–2285. PMLR, 2020.   \n[56] Sushrut Karmalkar, Adam Klivans, and Pravesh Kothari. List-decodable linear regression. In Advances in Neural Information Processing Systems, pages 7423–7432, 2019.   \n[57] Sushrut Karmalkar and Eric Price. Compressed sensing with adversarial sparse noise via l1 regression. In 2nd Symposium on Simplicity in Algorithms, 2019.   \n[58] Vishesh Karwa and Salil Vadhan. Finite sample differentially private confidence intervals. arXiv preprint arXiv:1711.03908, 2017.   \n[59] Adam Klivans, Pravesh K Kothari, and Raghu Meka. Efficient algorithms for outlier-robust regression. In Conference On Learning Theory, pages 1420–1430, 2018.   \n[60] Weihao Kong, Raghav Somani, Sham Kakade, and Sewoong Oh. Robust meta-learning for mixed linear regression with small batches. Advances in Neural Information Processing Systems, 33, 2020.   \n[61] Pravesh K Kothari, Jacob Steinhardt, and David Steurer. Robust moment estimation and improved clustering via sum of squares. In Proceedings of the 50th Annual ACM SIGACT Symposium on Theory of Computing, pages 1035–1046, 2018.   \n[62] Kevin A Lai, Anup B Rao, and Santosh Vempala. Agnostic estimation of mean and covariance. In 2016 IEEE 57th Annual Symposium on Foundations of Computer Science (FOCS), pages 665–674. IEEE, 2016.   \n[63] Jerry Li. CSE 599-M, Lecture Notes: Robustness in Machine Learning , 2019. URL: https: //jerryzli.github.io/robust-ml-fall19/lec7.pdf.   \n[64] Jerry Li and Guanghao Ye. Robust gaussian covariance estimation in nearly-matrix multiplication time. Advances in Neural Information Processing Systems, 33, 2020.   \n[65] Liu Liu, Yanyao Shen, Tianyang Li, and Constantine Caramanis. High dimensional robust sparse regression. arXiv preprint arXiv:1805.11643, 2018.   \n[66] Xiaohui Liu. Fast implementation of the tukey depth. Computational Statistics, 32(4):1395– 1410, 2017.   \n[67] Xiaohui Liu, Karl Mosler, and Pavlo Mozharovskyi. Fast computation of tukey trimmed regions and median in dimension p> 2. Journal of Computational and Graphical Statistics, 28(3):682–697, 2019.   \n[68] Gábor Lugosi, Shahar Mendelson, et al. Sub-gaussian estimators of the mean of a random vector. Annals of Statistics, 47(2):783–794, 2019.   \n[69] Frank McSherry and Kunal Talwar. Mechanism design via differential privacy. In 48th Annual IEEE Symposium on Foundations of Computer Science (FOCS’07), pages 94–103. IEEE, 2007.   \n[70] Bhaskar Mukhoty, Govind Gopakumar, Prateek Jain, and Purushottam Kar. Globally-convergent iteratively reweighted least squares for robust regression problems. In The 22nd International Conference on Artificial Intelligence and Statistics, pages 313–322, 2019.   \n[71] A. Prasad, A. S. Suggala, S. Balakrishnan, and P. Ravikumar. Robust estimation via robust gradient estimation. arXiv preprint arXiv:1802.06485, 2018.   \n[72] Prasad Raghavendra and Morris Yau. List decodable learning via sum of squares. In Proceedings of the Fourteenth Annual ACM-SIAM Symposium on Discrete Algorithms, pages 161–180. SIAM, 2020.   \n[73] Jacob Steinhardt, Moses Charikar, and Gregory Valiant. Resilience: A criterion for learning in the presence of arbitrary outliers. In 9th Innovations in Theoretical Computer Science Conference (ITCS 2018). Schloss Dagstuhl-Leibniz-Zentrum fuer Informatik, 2018.   \n[74] Jun Tang, Aleksandra Korolova, Xiaolong Bai, Xueqiang Wang, and Xiaofeng Wang. Privacy loss in apple’s implementation of differential privacy on macos 10.12. arXiv preprint arXiv:1709.02753, 2017.   \n[75] Terence Tao. Topics in random matrix theory, volume 132. American Mathematical Soc., 2012.   \n[76] John W Tukey. A survey of sampling from contaminated distributions. Contributions to probability and statistics, pages 448–485, 1960.   \n[77] Martin J Wainwright. High-dimensional statistics: A non-asymptotic viewpoint, volume 48. Cambridge University Press, 2019.   \n[78] Lu Wei, Anand D Sarwate, Jukka Corander, Alfred Hero, and Vahid Tarokh. Analysis of a privacy-preserving pca algorithm using random matrix theory. In 2016 IEEE Global Conference on Signal and Information Processing (GlobalSIP), pages 1335–1339. IEEE, 2016.   \n[79] Huang Xiao, Battista Biggio, Gavin Brown, Giorgio Fumera, Claudia Eckert, and Fabio Roli. Is feature selection secure against training data poisoning? In International Conference on Machine Learning, pages 1689–1698. PMLR, 2015.   \n[80] Huanyu Zhang, Gautam Kamath, Janardhan Kulkarni, and Zhiwei Steven Wu. Privately learning markov random fields. arXiv preprint arXiv:2002.09463, 2020. ",
+        "bbox": [
+            169,
+            128,
+            828,
+            917
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            71,
+            828,
+            914
+        ],
+        "page_idx": 13
+    }
+]

parse/train/HJgZrsC5t7/HJgZrsC5t7.md

@@ -0,0 +1,327 @@
+# IMPROVING ON-POLICY LEARNING WITH STATISTICAL REWARD ACCUMULATION
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Deep reinforcement learning has obtained significant breakthroughs in recent years. Most methods in deep-RL achieve good results via the maximization of the reward signal provided by the environment, typically in the form of discounted cumulative returns. Such reward signals represent the immediate feedback of a particular action performed by an agent. However, tasks with sparse reward signals are still challenging to on-policy methods. In this paper, we introduce an effective characterization of past reward statistics (which can be seen as long-term feedback signals) to supplement this immediate reward feedback. In particular, value functions are learned with multi-critics supervision, enabling complex value functions to be more easily approximated in on-policy learning, even when the reward signals are sparse. We also introduce a novel exploration mechanism called “hot-wiring” that can give a boost to seemingly trapped agents. We demonstrate the effectiveness of our advantage actor multi-critic (A2MC) method across the discrete domains in Atari games as well as continuous domains in the MuJoCo environments. A video demo is provided at https://youtu.be/zBmpf3Yz8tc and source codes will be made available upon paper acceptance.
+
+# 1 INTRODUCTION
+
+Advances in deep learning have mobilized the research community to adopt deep reinforcement learning (RL) agents for challenging control problems, typically in complex environments with raw sensory state-spaces. Breakthroughs by Mnih et al. (2015) show RL-agents can reach abovehuman performance in Atari 2600 games, and AlphaGo Zero Silver et al. (2017) becomes the world champions on the game of Go. Still, training RL agents is non-trivial. Off-policy methods typically require days of training to obtain competitive performance, while on-policy methods could be trapped in local minima. Recent techniques featuring on-policy learning Mnih et al. (2016); Schulman et al. (2017); Wu et al. (2017) have shown promising results in stabilizing the learning processes, enabling an agent to solve a variety of tasks in much less time. In particular, the state-of-the-art on-policy ACKTR agent by Wu et al. (2017) shows improved sample efficiency with the help of Kronecker-factored (K-Fac) approximate curvature for natural gradient updates, resulting in stable and effective model updates towards a more promising direction.
+
+However, tasks with sparse rewards remain challenging to on-policy methods. An agent could take massive amount of exploration before reaching non-zero rewards; and as the agent learns on-policy, the sparseness of reward feedback (receiving all-zero rewards from most actions performed by the agent) could be malicious and render an agent to falsely predict all states in an environment towards a value of zero. As there does not exist a universal criterion for measuring “task sparseness”, we show an ad-hoc metric in Figure 1 in an attempt to provide intuition. For example, we observe that the ACKTR agent is unable to receive sufficient non-zero immediate rewards that can provide instructive agent updates in Atari games “Freeway” and “Enduro”, resulting in failures when solving these two games. Moreover, if ACKTR gets drawn to and trapped in unfavorable states (as in games like Boxing and WizardOfWor), it could again take long hours of exploration before the agent can get out of the local minima. Such evidence shows that on-policy agent could indeed suffer from the insufficiencies of guidance provided by the exclusive immediate reward signals from the environment.
+
+In this paper, we introduce an effective auxiliary reward signal in tasks with sparse rewards to remedy the deficiencies of learning purely from standard immediate reward feedbacks. As on-policy agents may take many explorations before reaching non-zero immediate rewards, we argue that we can leverage past reward statistics to provide more instructive feedbacks to agents in the same environment. To this end, we propose to characterize the past reward statistics in order to gauge the “long-term” performance of an agent (detailed in Section 4). After performing an action, an agent will receive a long-term reward signal describing its past performance upon this step, as well as the conventional immediate reward from the environment. To effectively characterize the long-term performance of the agent, we take into considerations both the crude amount of rewards and the volatility of rewards received in the past, where highly volatile distributions of long-term rewards are explicitly penalized. This enables complex value functions to be more easily approximated in multi-critics supervision. We find in practice that by explicitly penalizing highly volatile long-term rewards while maximizing the expectation of short-term rewards, the learning process and the overall performance are improved regarding both sample efficiency and final rewards. We further propose a “hot-wiring” exploration mechanism that can boost seemingly trapped agent in the earlier stage of learning. By leveraging the characterization of long/short-term reward statistics, our proposed advantage actor multi-critic model (A2MC) shows significantly improved performance on the Atari 2600 games and the MuJoCo tasks as compared to the state-of-the-art on-policy methods.
+
+![](images/cd753a39ce5a48461924628e1e3afe7243006032133b48f3e336125002681ed3.jpg)  
+Figure 1: Performance of A2MC on Atari games trained with 15 million timesteps. Our method has a winning rate of $5 5 . 3 \%$ among all the Atari games tested, as compared to the ACKTR. Our A2MC learns quickly in some of the hardest games for on-policy methods, such as “Boxing”, “Enduro”, “Freeway”, “Robotank” and “WizardOfWor”. The sparseness of a game is defined as the sparseness of average rewards $\mathbf { x }$ obtained by ACKTR within the first $n = 1 0 ^ { 6 }$ timesteps by $\begin{array} { r } { \varphi ( \mathbf { x } ) ^ { \mathbf { \tilde { \alpha } } } = \left( \sqrt { n } - \frac { \| \mathbf { x } \| _ { 1 } } { \| \mathbf { x } \| _ { 2 } } \right) \tilde { \mathbf { \alpha } } ( \sqrt { n } - 1 ) } \end{array}$ . A higher value of sparseness indicates sparser rewards. A relative performance margin (in terms of final reward) larger than $1 0 \%$ is deemed as winning / losing. The shaded region denotes the standard deviation over 2 random seeds.
+
+# 2 RELATED WORK
+
+Reward shaping and pseudo-rewards: To tackle the challenge in tasks with rarely observed rewards, pseudo-rewards maximization is adopted in earlier works Konidaris & Barto (2009); Silver & Ciosek (2012). Auxiliary vision tasks (e.g., learning pixel changes or network features) are adopted in the off-policy UNREAL agent Jaderberg et al. (2016) in order to facilitate learning better feature representations, particularly for sparse reward environments. Another direction of effort involves directly engineering a better reward function or shaping the reward signal. Andrychowicz et al. (2017) enhances off-policy learning by re-producing informative reward in hindsight for sequences of actions that do not lead to success previously. The HRA approach Van Seijen et al. (2017) exploits domain knowledge to define a set of environment-specific rewards based on reward categories. And the winning approach that learns playing “Doom” Lample & Chaplot (2017) shows promising success in the FPS game that carefully crafting the task rewards would indeed be beneficial. In contrast to heuristically defining vision-related auxiliary tasks, our proposed A2MC agent learns from the characterization of intrinsic past reward statistics obtainable from any environment; and different from the hybrid architecture pertaining to Ms. Pacman only and the reward shaping settings tailored specifically to ”Doom”, our proposed reward characterization mechanism is generic and our A2MC generalizes well to a variety of tasks without the need to engineer a decomposition of problemspecific environment rewards. Moreover, the capability of the proposed method to further boost reward shaping is evidenced in our case study on playing Doom (see Appendix F).
+
+Multi-agents: The multi-agent approaches Lanctot et al. (2017); Lowe et al. (2017); Jin et al. (2018) present another promising direction for learning. They propose to train multiple agents in parallel when solving a task, and to combine multiple action-value functions with a centralized action-value function. The multi-critics supervision in our proposed A2MC model can be seen as a form of joint-task or multi-task learning Teh et al. (2017) for both long-term and short-term rewards.
+
+On-policy v.s. Off-policy: Our empirical results based on learning the characterization of long/shortterm reward statistics also echo the effectiveness of a recently proposed off-policy reinforcement learning framework Bellemare et al. (2017) that features a distributional variant of Q-learning, wherein the value functions are learned to match the distribution of standard immediate returns. Also, Wang et al. (2016) shows that applying experience replay to on-policy methods can further enhance learning stability. Schulman et al. (2016) proposes a variant of advantage function using eligibility traces that provides both low-variance and low-bias gradient estimates. These works are orthogonal to our approach can potentially be combined with the proposed characterization of past reward statistics to further enhance learning performance. While our extensive experiments (see also Appendix E and Appendix F) show promising results of our approach in both on- and off-policy frameworks, we focus on “on-policy” methods (i.e., those that do not involve off-policy trajectories or experience replay) as in $\mathrm { W u }$ et al. (2017) in the main text in order to systematically evaluate the potential of our proposed reward mechanism within the scope of this work.
+
+# 3 PRELIMINARY
+
+Consider the standard reinforcement learning setting where an agent interacts with an environment over a number of discrete time step. At each time step $t$ , the agent receives an environment state $s _ { t }$ , then executes an action $a _ { t }$ based on policy $\pi _ { t }$ . The environment produces reward $r _ { t }$ and next state $s _ { t + 1 }$ , according to which the agent gets feedback of its immediate action and will decide its next action $a _ { t + 1 }$ . The process $< { \bf S } , { \bf A } , { \bf R } , { \bf S } >$ , typically considered as a Markov Decision Process, continues until a terminal state $s _ { T }$ upon which the environment resets itself and produces a new episode. Under conventional settings, the return is calculated as the discounted summation of rewards $r _ { t }$ accumulated from time step $t$ onwards $\begin{array} { r } { R _ { t } = \sum _ { k = 0 } ^ { \infty } \gamma ^ { k } r _ { t + k } } \end{array}$ . The goal of the agent is to maximize the expected return from each state $s _ { t }$ while following policy $\pi$ . Each policy has a corresponding action-value function defined as $Q ^ { \pi } ( s , a ) = \mathbb { E } [ R _ { t } | s _ { t } = s , a _ { t } = a ; \pi ]$ . Similarly, each state $s \in S$ under policy $\pi$ has a value function defined as: $V ^ { \pi } ( s ) = \mathbb { E } [ R _ { t } | s _ { t } = s ]$ . In value-based approaches (e.g., Q-learning Mnih et al. (2015)), function approximator $Q ( s , a ; \theta )$ can be used to approximate the optimal action value function $Q ^ { * } ( s , a )$ . This is conventionally learned by iteratively minimizing the below loss function:
+
+$$
+L ( \theta ) = \mathbb { E } [ ( y _ { t } ^ { t a r g e t } - Q ( s _ { t } , a _ { t } ; \theta ) ) ^ { 2 } ] ,
+$$
+
+where ytargett = rt + γ maxa0 Q(st+1, a0; θ) and st+1 is the next state following state st.
+
+In policy-based approaches (e.g., policy gradient methods), the optimal policy $\pi ^ { * } ( a | s )$ is approximated using the approximator $\pi ( a | s ; \theta )$ . The policy approximator is then learned by gradient ascent on $\nabla _ { \boldsymbol { \theta } } \mathbb { E } [ h _ { t } ] \approx \dot { \nabla _ { \boldsymbol { \theta } } } \log \pi ( a _ { t } | s _ { t } ; \boldsymbol { \theta } ) \dot { R } _ { t }$ . The REINFORCE method Williams (1992) further incorporates a baseline $b ( s _ { t } )$ to reduce the variance of the gradient estimator: $\nabla _ { \theta } \mathbb { E } [ R _ { t } ] _ { R E I N F O R C E } \approx$ $\nabla _ { \theta } \log \pi ( a _ { t } | s _ { t } ; \theta ) \dot { ( R _ { t } - b ( s _ { t } ) ) }$
+
+In actor-critic based approaches, the variance reduction further evolves into the advantage function $A ( s _ { t } , a _ { t } ) = Q ( s _ { t } , a _ { t } ) - V ( s _ { t } )$ in Mnih et al. (2016), where the action value $Q ^ { \pi } ( s _ { t } , a _ { t } )$ is approximated by $R _ { t }$ and $b ( s _ { t } )$ is replaced by $V ^ { \pi } ( s _ { t } )$ , deriving the advantage actor-critic architecture where actor-head $\pi ( \cdot | s )$ and the critic-head $V ( s )$ share low-level features. The gradient update rule w.r.t. the action-head is $\nabla _ { \theta } \log \pi ( a _ { t } | s _ { t } ; \theta ) ( R _ { t } - V ( s _ { t } ; \theta ) )$ . The gradient update w.r.t. the critic-head is: $\nabla _ { \boldsymbol { \theta } } ( R _ { t } - V ( s _ { t } ; \boldsymbol { \theta } ) ) ^ { 2 }$ , where $R _ { t } = r _ { t } + \gamma V ( s _ { t + 1 } )$ .
+
+![](images/691a77d1436be9adc6c816257080ddb1982e633dec02a7c34a27ed2085021986.jpg)  
+Figure 2: Illustration of the proposed variability-weighted reward (VWR). The first row shows the raw reward sequence (blue) while the second row presents the post-processed sequence $\vec { \mathcal { R } }$ (green) and the zero-variability reference $\vec { \mathcal { R } } ^ { z e r o }$ (orange), and $\mathcal { R } _ { H }$ is calculated as a reflection of how high the immediate reward is. The third row shows the volatility statistics of $\delta _ { \mathcal { R } }$ , representing how varied past rewards were. We curated 3 hypothetical reward sequences – (a) highly varied sequence with low immediate reward, resulting in the lowest VWR; (b) highly varied sequence with high immediate reward, leading to a relatively high VWR; (c) stable sequence with high immediate reward, achieving the best VWR. More examples can be found in the Appendix A.
+
+# 4 CHARACTERIZATION OF PAST REWARD STATISTICS
+
+The conventional reward $r _ { t }$ received from the environment at time step $t$ after an action $a _ { t }$ is performed represents the immediate reward regarding this particular action. This “immediacy” could be interpreted as a short-term horizon of how the agent is doing, i.e., evaluating the agent via judging its actions by immediate rewards. We argue that the deficiencies of learning solely from immediate rewards mainly come from this limitation that the agent is learning from one single type of exclusive short-term feedback.
+
+As the goal of providing reward feedback to an agent is to inform the agent of its performance, we seek to find an auxiliary performance metric that can measure whether the agent is performing consistently well. Inspired by the formulation of Sharpe Ratio $\begin{array} { r } { ( \mathbb { E } [ r ] \times \frac { 1 } { \sigma _ { r } } ) } \end{array}$ in evaluating the long-term performance of porfolio strategies where the return $\mathbb { E } [ r ]$ is inversely weighted by the risk $\sigma _ { r }$ , an effective characterization of historical reward statistics should take into account at least two factors, namely 1) how high the immediate reward is and 2) how varied past rewards were, bringing the desired notion of “risk-adjusted return” as in Sharpe (1994).
+
+# 4.1 VARIABILITY-WEIGHTED REWARD
+
+To this end, we follow insights behind Dowd (2000); Sharpe (1994) and define a variability-weighted characterization of past rewards. This is illustrated in Figure 2. We consider a historical sequence of $T$ rewards upon timestep $t$ (looking backward $T - 1$ timesteps): $\vec { \mathbf { r } } = \left[ r _ { t - ( T - 1 ) } . . . , r _ { t - 2 } , r _ { t - 1 } , r _ { t } \right]$ . In order to evaluate how high and varied the reward sequence is, a few steps of pre-processing $\mathcal { G }$ is applied, denoted as $\vec { \mathcal { R } } = \mathcal { G } ( \vec { \bf r } )$ . Specifically, we first derive the reward change at each timestep (similar to the “differential return” concept in Sharpe (1994)) with $d _ { n } = r _ { n } - r _ { n - 1 }$ :
+
+$$
+\vec { \mathbf { d } } = [ d _ { t - ( T - 1 ) } , d _ { t - ( T - 2 ) } , \dots , d _ { t } ] = [ r _ { t - ( T - 1 ) } , r _ { t - ( T - 2 ) } - r _ { t - ( T - 1 ) } , \dots , r _ { t } - r _ { t - 1 } ] .
+$$
+
+Then we re-order the sequence by flipping 1 with $f _ { n } = d _ { t + 1 - n }$ :
+
+$$
+\vec { \mathbf { f } } = [ f _ { 1 } , f _ { 2 } , \dotsc , f _ { T } ] = [ d _ { t } , d _ { t - 1 } , \dotsc , d _ { t - ( T - 1 ) } ] .
+$$
+
+Next we append $f _ { 0 } = 1$ to the head of sequence $\vec { \mathbf { f } }$ and take the normalized cumulative sum to obtain the post-processed reward sequence as $\begin{array} { r } { \vec { \mathcal { R } } = [ \mathcal { R } _ { 0 } , \mathcal { R } _ { 1 } , \ldots , \mathcal { R } _ { T } ] = \frac { 1 } { T + 1 } [ f _ { 0 } , f _ { 0 } + f _ { 1 } , \ldots , \sum _ { i = 0 } ^ { T } f _ { i } ] } \end{array}$ . Under such processing, numerical instability (see Eq. 4) when all rewards in the sequence are zero can be alleviated, while the averaging term $\\frac { 1 } { T + 1 }$ mitigates the effect of introducing the artificial $f _ { 0 }$ .
+
+The resulting $\vec { \mathcal { R } }$ is a reward sequence with $\begin{array} { r } { \mathcal { R } _ { T } - \mathcal { R } _ { 0 } = \frac { 1 } { T + 1 } r _ { t } } \end{array}$ , and $\begin{array} { r } { \mathcal { R } _ { n } - \mathcal { R } _ { n - 1 } = \frac { 1 } { T + 1 } ( r _ { t + 1 - n } - } \end{array}$ $r _ { t - n } )$ . Therefore, the difference between $\mathcal { R } _ { T }$ and $\mathcal { R } _ { 0 }$ represents the immediate reward and the whole sequence $\vec { \mathcal { R } }$ reflects the volatility of past rewards. In Figure 2, three examples of processed sequence are presented in the second row with the corresponding raw rewards shown in the first row. We account for how high the immediate reward is by defining the relative percentage log total return as:
+
+$$
+\mathcal { R } _ { H } = 1 0 0 \times \left( e ^ { \frac { 1 } { T } \ln \frac { \mathcal { R } _ { T } } { \mathcal { R } _ { 0 } } } - 1 \right) = \frac { { \mathcal { R } _ { T } } ^ { 1 / T } - { \mathcal { R } _ { 0 } } ^ { 1 / T } } { { \mathcal { R } _ { 0 } } ^ { 1 / T } } \times 1 0 0 .
+$$
+
+To account for how varied past rewards were, we first define a smooth zero-variability reference as: $\vec { \mathcal { R } } ^ { z e r o } = [ \mathcal { R } _ { 0 } ^ { z e r o } , \mathcal { R } _ { 1 } ^ { z e r o } , \ldots , \mathcal { R } _ { T } ^ { z e r o } ] = \mathcal { R } _ { 0 } [ e ^ { 0 \times \widetilde { \mathcal { R } } } , e ^ { 1 \times \widetilde { \mathcal { R } } } , \ldots , e ^ { T \widetilde { \mathcal { R } } } ]$ with $\begin{array} { r } { \widetilde { \mathcal { R } } = \frac { 1 } { T } \ln \frac { \mathcal { R } _ { T } } { \mathcal { R } _ { 0 } } } \end{array}$ , represent a smooth monotonic reference sequence from $\mathcal { R } _ { 0 }$ to $\mathcal { R } _ { T }$ . Then we define the reward differential $\delta _ { \mathcal { R } }$ as the differential reward versus its zero-variability reference as $\begin{array} { r } { \delta _ { \mathcal { R } } ( n ) = \frac { \mathcal { R } _ { n } - \mathcal { R } _ { n } ^ { z e r o } } { \mathcal { R } _ { n } ^ { z e r o } } } \end{array}$ , whose statistics are sketched in the third row of Figure 2. With maximally allowed volatility as $\sigma _ { m a x }$ , the variability weights can be defined as: $\begin{array} { r } { \omega = 1 - \big [ { \frac { \sigma ( \delta _ { \mathcal { R } } ) } { \sigma _ { m a x } } } \big ] ^ { \tau } } \end{array}$ , where $\sigma ( \cdot )$ is the standard deviation and $\tau$ controls the rate to penalize highly volatile reward distribution. Finally we can derive the variability-weighted past reward indicator $r ^ { v w r }$ for the characterization of past reward statistics:
+
+$$
+r ^ { v w r } = \left. \begin{array} { c c } { \mathcal { R } _ { H } ( 1 - [ \frac { \sigma ( \delta _ { \mathcal { R } } ) } { \sigma _ { m a x } } ] ^ { \tau } ) } & { \mathrm { i f } \sigma ( \delta _ { \mathcal { R } } ) < \sigma _ { m a x } , \mathcal { R } _ { T } > 0 } \\ { 0 } & { \mathrm { o t h e r w i s e } } \end{array} \right.
+$$
+
+The formulation of Equation 5 share principled themes as in Sharpe (1994) and Dowd (2000):
+
+1. Dowd (2000) compares the newly obtained $\mathbf { S R } ^ { n e w }$ with the previous $\mathbf { S R } ^ { o l d }$ in choosing new assets; we derive $\mathcal { R } _ { H }$ in Eq. 4 by comparing the latest reward $\mathcal { R } _ { T }$ with $\mathcal { R } _ { 0 }$ to explicitly encourage the agent to aim for reward improvements in “choosing new actions”; 2. Both the Sharpe Ratio (SR) and Eq. 5 involve “variability weights” to adjust for the unit risk of return $\mathbb { E } [ \mathcal { R } ]$ Sharpe (1994) (i.e., $\scriptstyle { \frac { 1 } { \sigma _ { r } } }$ for SR and $\begin{array} { r } { 1 - \big [ \frac { \sigma ( \delta \mathcal { R } ) } { \sigma _ { m a x } } \big ] ^ { \tau } } \end{array}$ [ σ(δR) ]τ for rvwr ); 3. Whereas Dowd (2000) introduces the concept of “minimum required return” based on the elasticity of value at risk (VaR), we consider the maximum tolerance level $\sigma _ { m a x }$ with elasticity controlled by $\tau$ for improved learning stability of $r ^ { v w r }$ (see also Appendix H).
+
+Example computed values of $r ^ { v w r }$ for the characterization of different reward statistics are shown in Figure 2 and we show strong empirical results (in Section 6) to confirm the validity and robustness of the proposed formulation in multiple reinforcement learning domains.
+
+# 4.2 MULTI-CRITIC ARCHITECTURE
+
+A higher value of $r ^ { v w r }$ indicates better agent performance as the result of the historical sequence of actions. The same set of optimization procedures for conventional value function (i.e., via maximization of immediate reward signal $r$ ) update can be applied accordingly. The actual returns computed from both the “long-term” and “short-term” rewards are discounted by the same factor $\gamma$ In particular, for standard $N$ -step look-ahead approaches, we have:
+
+$$
+R _ { t } ^ { \mathrm { { s h o r t . e r m } } } = \sum _ { n = 0 } ^ { N - 1 } \gamma ^ { n } r _ { t + n } + \gamma ^ { N } V ( s _ { t + N } ) , \ : \ : \ : R _ { t } ^ { \mathrm { l o n g . e r m } } = \sum _ { n = 0 } ^ { N - 1 } \gamma ^ { n } r _ { t + n } ^ { v w r } + \gamma ^ { N } V ^ { v w r } ( s _ { t + N } )
+$$
+
+Similar to the standard state value function $V ( s )$ , we further define $V ^ { v w r } ( s )$ as the value function w.r.t the variability-weighted reward $r ^ { v w r }$ . These value functions form multiple critics judging a given state $s$ . The gradients w.r.t. the critics then become:
+
+$$
+\nabla _ { \theta ^ { \mathrm { s h o r i c m } } } [ ( R _ { t } ^ { \mathrm { s h o r t - e r m } } - V ( s _ { t } ; \theta ^ { \mathrm { s h o r t - e r m } } ) ) ^ { 2 } ] + \nabla _ { \theta ^ { \mathrm { l o r g - t e r m } } } [ ( R _ { t } ^ { \mathrm { l o n g - t e r m } } - V ^ { v w r } ( s _ { t } ; \theta ^ { \mathrm { l o n g - t e r m } } ) ) ^ { 2 } ]
+$$
+
+![](images/fd2a20fd68d11f839066eb2b4cb98f37deca225e98926d444892f991d6494b10.jpg)  
+Figure 3: Performance of A2MC on Atari games. “Hot-Wiring” exploration makes the agent easier to figure out how to play challenging games like “Robotank” and “WizardOfWor”, and for most games, it provides a better initial state for the agent to start off at a game and hence to obtain better final results. The number in figure legend shows the average reward among the last 100 episodes and the percentage shows the performance margin as compared to ACKTR. The shaded region denotes the standard deviation over 2 random seeds.
+
+where the standard grading clipping approach can be applied in Eq. 7 for enhanced stability. More advanced methods for estimating $R _ { t } ^ { \mathrm { s h o r t - t e r m } }$ and $R _ { t } ^ { \mathrm { { l o n g - t e r m } } }$ above, such as the online variant of generalized advantage estimation (GAE) using eligibility traces Schulman et al. (2016) can be adopted in place of Eq. 6, as shown below (see also Appendix $\mathbf { G }$ ):
+
+$$
+\begin{array} { r l } & { A _ { t } ^ { \mathrm { s h o r t . t e r m } } = \displaystyle \sum _ { n = 0 } ^ { \infty } ( \gamma \lambda ) ^ { n } \delta _ { t + n } ^ { v w r } , \mathrm { w i t h } \delta _ { t } = r _ { t } + \gamma V ( s _ { t + 1 } ) - V ( s _ { t } ) } \\ & { A _ { t } ^ { \mathrm { l o n g . t e r m } } = \displaystyle \sum _ { n = 0 } ^ { \infty } ( \gamma \lambda ) ^ { n } \delta _ { t + n } ^ { v w r } , \mathrm { w i t h } \delta _ { t } ^ { v w r } = r _ { t } ^ { v w r } + \gamma V ^ { v w r } ( s _ { t + 1 } ) - V ^ { v w r } ( s _ { t } ) } \end{array}
+$$
+
+where the generalized estimator of the advantage function $A _ { t } ^ { \mathrm { s h o r t - t e r m } }$ and $A _ { t } ^ { \mathrm { l o n g - t e r m } }$ allows a trade-off of bias $\nu . s .$ . variance using the parameter $0 \leq \lambda \leq 1$ , similar to the $\mathrm { T D } ( \lambda )$ approach for eligibility traces. We show the effectiveness of the proposed characterization of past reward statistics in multiple advantage actor-critic frameworks (i.e., ACKTR and PPO), where the two different value functions can share the same low-level feature representation, enabling a single agent to learn multiple critics parameterized by $\theta ^ { j } , j \in \{ \mathrm { s h o r t - t e r m } , \mathrm { l o n g - t e r m } \}$ . (See also Appendix I for the full algorithm).
+
+# 5 HOT-WIRE $\epsilon$ -EXPLORATION
+
+Being handed a game-stick, a human most likely would try out all the available buttons on it to see which particular button entails whatever actions on the game screen, hence receiving useful feedbacks. Inspired by this, we propose to hot-wire the agent to perform an identical sequence of randomly chosen actions in the N-step look-ahead during the initial stage (randomly pressing down a game-stick button for a while):
+
+$$
+a _ { t + k } = \left\{ \begin{array} { l l } { { \mathrm { ~ a ~ r a n d o m ~ a c t i o n ~ i d e n t i c a l ~ f o r ~ a l l ~ k ~ } } } & { { \mathrm { w i t h ~ p r o b ~ } \epsilon } } \\ { { \pi ( a _ { t + k } | s _ { t + k } ) ~ \mathrm { f o r } ~ k = 0 , 1 , 2 , . . . , N - 1 } } & { { \mathrm { w i t h ~ p r o b ~ } 1 - \epsilon } } \end{array} \right.
+$$
+
+We show that by enabling the “hot-wiring” mechanism2, a seemingly trapped agent can be boosted to learn to quickly solve problems where rewards can only be triggered by particular action sequences, as shown in games like “Robotank” and “WizardOfWor” in Figure 3.
+
+# 6 EXPERIMENTS
+
+We use the same network architecture and natural gradient optimization method as in the ACKTR model Wu et al. (2017). We set $\sigma _ { m a x } = 1 . 0$ , $\tau = 2 . 0$ and $T = 2 0$ in the computation of variabilityweighted reward (see Appendix C for hyperparameter studies). For hot-wiring exploration, we choose $\epsilon = 0 . 2 0$ and initial stage to be first $\scriptstyle { \frac { 1 } { 4 0 } }$ of the total training period for all experiments. Other hyperparameters such as learning rate and gradient clipping remain the same as in the ACKTR model Wu et al. (2017), in addition to adopting GAE Schulman et al. (2016) for a stronger ACKTR baseline (see Sec 4.2). We first present results of evaluating the proposed A2MC model in two standard benchmarks, the discrete Atari experiments and the continuous MuJoCo domain. Then we show ablation studies on the robustness of the hyper-parameters involved as well as evaluating the extensibility of the proposed long/short-term reward characterizations to other on-policy methods. Further extensions to off-policy domains are presented in Appendix E and Appendix F.
+
+# 6.1 ATARI 2600 GAMES
+
+We follow standard evaluation protocol to evaluate A2MC in a variety of Atari game environments (starting with 30 no-op actions). We train our models for 15 million timesteps for each game environment and score each game based on the average episode rewards obtained among the last 100 episodes as in Wu et al. (2017). The learning results on 12 Atari games are shown in Figure 3 where we also included an ablation experiment of A2MC without hot-wiring. We observe that on average A2MC improves upon ACKTR in terms of final performance under the same training budget. Our A2MC is able to consistently improve agent performance based on the proposed characterization of reward statistics, hence the agent is able to get out of local minima in less time (higher sample efficiency) compared to ACKTR. The complete learning results on all games are attached in the Appendix B.
+
+Table 1: Comparison of average episode rewards at the end of 50 million timesteps in Atari experiments. The reward scores and the first episodes reaching human-level performance Mnih et al. (2015) are reported as in Wu et al. (2017). A2MC is able to solve games that are challenging to ACKTR and also retain comparable performance in the rest of games.   
+
+<table><tr><td colspan="2"></td><td colspan="2">ACKTR</td><td colspan="2">A2MC</td></tr><tr><td>Domain</td><td>Human Level</td><td>Rewards</td><td>Episode</td><td>Rewards</td><td>Episode</td></tr><tr><td>Asteroids</td><td>47388.7</td><td>34171.0</td><td>N/A</td><td>830232.5</td><td>11314</td></tr><tr><td>Beamrider</td><td>5775.0</td><td>13581.4</td><td>3279</td><td>13564.3</td><td>3012</td></tr><tr><td>Boxing</td><td>12.1</td><td>1.5</td><td>N/A</td><td>99.1</td><td>158</td></tr><tr><td>Breakout</td><td>31.8</td><td>735.7</td><td>4097</td><td>411.4</td><td>3664</td></tr><tr><td>Double Dunk</td><td>-16.4</td><td>-0.5</td><td>742</td><td>21.3</td><td>544</td></tr><tr><td>Enduro</td><td>860.5</td><td>0.0</td><td>N/A</td><td>3492.2</td><td>730</td></tr><tr><td>Freeway</td><td>29.6</td><td>0.0</td><td>N/A</td><td>32.7</td><td>1058</td></tr><tr><td>Pong</td><td>9.3</td><td>20.9</td><td>904</td><td>19.4</td><td>804</td></tr><tr><td>Q-bert</td><td>13455.0</td><td>21500.3</td><td>6422</td><td>25229.0</td><td>7259</td></tr><tr><td>Robotank</td><td>11.9</td><td>16.5</td><td>-</td><td>25.7</td><td>4158</td></tr><tr><td>Seaquest</td><td>20182.0</td><td>1776.0</td><td>N/A</td><td>1798.6</td><td>N/A</td></tr><tr><td>Space Invaders</td><td>1652.0</td><td>19723.0</td><td>14696</td><td>11774.0</td><td>11064</td></tr><tr><td>Wizard of Wor</td><td>4756.5</td><td>702</td><td>N/A</td><td>7471.0</td><td>8119</td></tr></table>
+
+We further expand the training budget and continue learning the games until 50 million timesteps as in Wu et al. (2017). As shown in Table 1, our A2MC model can solve games like “Boxing”, “Freeway” and “Enduro” that are challenging for the baseline ACKTR model. For a full picture of model performance in Atari games, A2MC has a human-level performance rate of $7 4 . 5 \%$ (38 out of 51 games) in the Atari benchmarks, compared to $6 3 . 6 \%$ reached by ACKTR. Individual game scores for all the Atari games are reported in the Appendix B.
+
+# 6.2 CONTINUOUS CONTROL
+
+For the evaluations on continuous control tasks simulated in MuJoCo environment, we first follow $\mathrm { W u }$ et al. (2017) and tune a different set of hyper-parameters from Atari experiments. Specifically, all
+
+![](images/3a06f904da805d4c7acb1d86247f9e70b0ea241d1cad9dbdc73b865f57ba7291.jpg)  
+Figure 4: Performance on the MuJoCo benchmark. A2MC is also competitive on MuJoCo continuous domain when compared to ACKTR. The shaded region denotes std over 3 random seeds.
+
+MuJoCo experiments are trained with a larger batch size of 2500. The results of eight MuJoCo environments trained for 1 million timesteps are shown in Figure 4. We observe that A2MC also performs well in all MuJoCo continuous control tasks. In particular, A2MC has brought significant improvement on the tasks of HalfCheetah, Swimmer and Walker2d (see Table 2).
+
+To test the robustness of A2MC, we perform another set of evaluations on MuJoCo tasks by keeping an identical set of hyper-parameters used in the Atari experiments. Figure 7 in Appendix C shows this ablation result. We observe that even under sub-optimal hyper-parameters, our A2MC model can still learn to solve the MuJoCo control tasks in the long run. Moreover, it is less prone to overfitting when compared to ACKTR under such “stress testing”. Additional hyper-parameter studies can be found in Appendix C.
+
+We also evaluate a multi-critics variant of the proximal policy optimization (PPO) model on the MuJoCo tasks with our proposed long/short-term rewards. In particular, we observe that our proposed variability-weighted reward generalizes well with the vanilla PPO, and our multi-critics PPO variant (MC-PPO) shows more favorable performance, as shown in Table 2. Specifically, MC-PPO shows the best performance on Hopper and Walker- $_ { 2 d }$ among all models under the 1-million timesteps training budget. Both of our multi-critics variants (A2MC and MC-PPO) have won 6 out of the 8 MuJoCo tasks with relative performance margins (percentages in parentheses) larger than $2 5 \%$ (see Table 2).
+
+Table 2: Average episode rewards obtained among the last 10 episodes upon 1 million timesteps of training in MuJoCo experiments.   
+
+<table><tr><td>GAMES</td><td>ACKTR</td><td colspan="2">Our A2MC</td><td>PPO</td><td colspan="2">Our MC-PPO</td></tr><tr><td>Ant</td><td>1671.6</td><td>2216.1</td><td>(32.5%)</td><td>411.4 (± 107.7)</td><td>618.9</td><td>(50.4%)</td></tr><tr><td>HalfCheetah</td><td>1676.2</td><td>2696.6</td><td>(60.8%)</td><td>1433.7 (± 83.9)</td><td>2473.4</td><td>(72.5%)</td></tr><tr><td>Hopper</td><td>2259.1</td><td>2835.7</td><td>(25.5%)</td><td>2055.8 (± 274.6)</td><td>3131.3</td><td>(52.3%)</td></tr><tr><td>InvertedDoublePendulum 6295.4</td><td></td><td>7872.6</td><td>(25.0%)</td><td>4454.1 (± 1098.1)</td><td>7648.7</td><td>(71.7%)</td></tr><tr><td>InvertedPendulum</td><td>1000.0</td><td>957.2</td><td>(-4.2%)</td><td>839.7 (± 127.1)</td><td>777.4</td><td>(-7.4%)</td></tr><tr><td>Reacher</td><td>-4.2</td><td>-3.9</td><td>(0.4%)</td><td>-5.47 (± 0.3)</td><td>-10.3</td><td>(-8.5%)</td></tr><tr><td>Swimmer</td><td>43.2</td><td></td><td>187.4 (333.7%)</td><td>79.1 (± 31.2)</td><td>102.9</td><td>(30.2%)</td></tr><tr><td>Walker2d</td><td>1090.8</td><td>2405.9 (120.5%)</td><td></td><td>2300.8 (± 397.6)</td><td>3718.1</td><td>(61.6%)</td></tr><tr><td>Win—Fair—Lose</td><td>N/A</td><td>6-2-0</td><td></td><td>N/A</td><td>6—2-0</td><td></td></tr></table>
+
+# 7 CONCLUSION
+
+In this work, we introduce an effective auxiliary reward signal to remedy the deficiencies of learning solely from the standard environment rewards. Our proposed characterization of past reward statistics results in improved learning and higher sample efficiencies for on-policy methods, especially in challenging tasks with sparse rewards. Experiments on both discrete tasks in Atari environment and MuJoCo continuous control tasks validate the effectiveness of utilizing the proposed long/short-term reward statistics for on-policy methods using multi-critic architectures. This suggests that expanding the form of reward feedbacks in reinforcement learning is a promising research direction.
+
+# REFERENCES
+
+Marcin Andrychowicz, Filip Wolski, Alex Ray, Jonas Schneider, Rachel Fong, Peter Welinder, Bob McGrew, Josh Tobin, OpenAI Pieter Abbeel, and Wojciech Zaremba. Hindsight experience replay. In Advances in Neural Information Processing Systems, pp. 5048–5058, 2017.
+
+Marc G Bellemare, Will Dabney, and Remi Munos. A distributional perspective on reinforcement ´ learning. arXiv preprint arXiv:1707.06887, 2017.
+
+Kevin Dowd. Adjusting for risk:: An improved sharpe ratio. International review of economics & finance, 9(3):209–222, 2000.
+
+Matteo Hessel, Joseph Modayil, Hado Van Hasselt, Tom Schaul, Georg Ostrovski, Will Dabney, Dan Horgan, Bilal Piot, Mohammad Azar, and David Silver. Rainbow: Combining improvements in deep reinforcement learning. 2018.
+
+Max Jaderberg, Volodymyr Mnih, Wojciech Marian Czarnecki, Tom Schaul, Joel Z Leibo, David Silver, and Koray Kavukcuoglu. Reinforcement learning with unsupervised auxiliary tasks. arXiv preprint arXiv:1611.05397, 2016.
+
+Junqi Jin, Chengru Song, Han Li, Kun Gai, Jun Wang, and Weinan Zhang. Real-time bidding with multi-agent reinforcement learning in display advertising. arXiv preprint arXiv:1802.09756, 2018.
+
+George Konidaris and Andrew G Barto. Skill discovery in continuous reinforcement learning domains using skill chaining. In Advances in neural information processing systems, pp. 1015–1023, 2009.
+
+Guillaume Lample and Devendra Singh Chaplot. Playing fps games with deep reinforcement learning. In AAAI, 2017.
+
+Marc Lanctot, Vinicius Zambaldi, Audrunas Gruslys, Angeliki Lazaridou, Julien Perolat, David Silver, Thore Graepel, et al. A unified game-theoretic approach to multiagent reinforcement learning. In Advances in Neural Information Processing Systems, pp. 4193–4206, 2017.
+
+Ryan Lowe, Yi Wu, Aviv Tamar, Jean Harb, OpenAI Pieter Abbeel, and Igor Mordatch. Multi-agent actor-critic for mixed cooperative-competitive environments. In Advances in Neural Information Processing Systems, pp. 6382–6393, 2017.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529, 2015.
+
+Volodymyr Mnih, Adria Puigdomenech Badia, Mehdi Mirza, Alex Graves, Timothy Lillicrap, Tim Harley, David Silver, and Koray Kavukcuoglu. Asynchronous methods for deep reinforcement learning. In International Conference on Machine Learning, pp. 1928–1937, 2016.
+
+John Schulman, Philipp Moritz, Sergey Levine, Michael Jordan, and Pieter Abbeel. High-dimensional continuous control using generalized advantage estimation. ICLR, 2016.
+
+John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347, 2017.
+
+William F Sharpe. The sharpe ratio. Journal of portfolio management, 21(1):49–58, 1994.
+
+David Silver and Kamil Ciosek. Compositional planning using optimal option models. arXiv preprint arXiv:1206.6473, 2012.
+
+David Silver, Julian Schrittwieser, Karen Simonyan, Ioannis Antonoglou, Aja Huang, Arthur Guez, Thomas Hubert, Lucas Baker, Matthew Lai, Adrian Bolton, et al. Mastering the game of go without human knowledge. Nature, 550(7676):354, 2017.
+
+Richard S Sutton and Andrew G Barto. Reinforcement learning: An introduction. MIT press, 2018.
+
+Yee Teh, Victor Bapst, Wojciech M Czarnecki, John Quan, James Kirkpatrick, Raia Hadsell, Nicolas Heess, and Razvan Pascanu. Distral: Robust multitask reinforcement learning. In Advances in Neural Information Processing Systems, pp. 4499–4509, 2017.
+
+Harm Van Seijen, Mehdi Fatemi, Joshua Romoff, Romain Laroche, Tavian Barnes, and Jeffrey Tsang. Hybrid reward architecture for reinforcement learning. In NIPS, pp. 5392–5402, 2017.
+
+Ziyu Wang, Victor Bapst, Nicolas Heess, Volodymyr Mnih, Remi Munos, Koray Kavukcuoglu, and Nando de Freitas. Sample efficient actor-critic with experience replay. arXiv preprint arXiv:1611.01224, 2016.
+
+Ronald J Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. In Reinforcement Learning, pp. 5–32. Springer, 1992.
+
+Yuhuai Wu, Elman Mansimov, Roger B Grosse, Shun Liao, and Jimmy Ba. Scalable trust-region method for deep reinforcement learning using kronecker-factored approximation. In Advances in neural information processing systems, pp. 5285–5294, 2017.
+
+# APPENDIX
+
+# A EFFECTS OF FLIPPING
+
+While introducing the variability-weighted reward, a flipping operation is conducted in the preprocessing of the reward sequence as formulated in Eq. (3). In Figure 5 and 6, we construct 4 reward sequences to show that the flipping operation can further penalize the oscillation in the recent past rewards while encourage recent stable rewards. (a1, a2, b1, b2) share the same value of immediate reward at $t = 9$ and thus the $\mathcal { R } _ { H }$ of all reward sequences are the same. Therefore, the variability-weighted reward only depends on the volatility statistics of $\delta _ { R }$ , i.e., how varied past rewards were.
+
+![](images/b8c96c2bfb2986a8131744bff4f87fb64d6ad7d6ab6465c97ddc8d0c4bc5483f.jpg)  
+Figure 5: Calculation without flipping.
+
+![](images/03f318fa74dc2f857ea0e3562e3d4f2c6896c003afc641c8b8400191574d409c.jpg)  
+Figure 6: Calculation with flipping.
+
+Without flipping. In Figure 5, sequence $( a l )$ and $( a 2 )$ are mirror symmetrical to the $y$ -axis, and the only difference between them is that the recent past rewards $( t = 5 , 6 , 7 , 8 )$ ) of $( a 2 )$ are more stable than (a1). Intuitively, we want to encourage stable past rewards like $( a 2 )$ while penalizing oscillation in (a1). As presented in the third row of Figure 5, the $r ^ { v w r }$ difference of $( a I )$ and $( a 2 )$ is less than 1 without flipping in the pre-processing.
+
+With flipping. In Figure 6, (b1, b2) exactly have the same reward sequence as $( a l , a 2 )$ , respectively. However, flipping is performed as a step of pre-processing, largely increasing the $r ^ { v w r }$ gap (from less than 1 to nearly 4) between the two constructed sequences. Comparing $( b l , b 2 )$ with $( a l , a 2 )$ , the post-processed sequences $\vec { \mathcal { R } }$ (shown in green) become centrosymmetric to those without flipping. Specifically, the recent reward drops at $t = 6 , 7 , 8$ are reflected as high values at the beginning of $\vec { \mathcal { R } }$ as shown in $( b l )$ , while oscillations long ago are transformed into high values at the end of $\vec { \mathcal { R } }$ as presented in $( b 2 )$ . When compared to the zero-variability reference (shown in orange), which is designed as an exponential function, the flipping leads to a higher variability for the former sequence while a lower variability for the latter one, enlarging the $r ^ { v w r }$ gap between those two sequences.
+
+# B COMPLETE RESULTS IN ATARI 2600 GAMES
+
+We show the learning curves for 15 million timesteps on all Atari games in Figure 12 and in Table 3 we show the complete results of training til 50 million timesteps. report the mean episode reward as in Wu et al. (2017). Entries with $\sim$ indicates approximated value as retrieved from learning figures published by Wu et al. (2017). Results from other models are taken from Wu et al. (2017) and Mnih et al. (2015). We show that A2MC has reached a human-level performance rate of $7 4 . 5 \%$ (38 out of 51 games) as compared to $6 3 . 6 \%$ reached by ACKTR. The relative performance margin of A2MC as compared to ACKTR is also shown.
+
+# C HYPER-PARAMETER STUDIES
+
+The proposed variability-weighted reward mechanism considers the volatility of rewards by keeping a $T$ -step history of agent’s performance. The hyper-parameter $T = 2 0$ is empirically chosen to be the same as the look-ahead parameter $N$ in standard on-policy methods, so as to keep the same period $\textstyle T = N = 2 0$ ) in “T-step history” and “N-step forward”. And $\sigma _ { m a x } = 1$ is chosen as the maximum of the observed volatility based on statistics in the $\mathrm { T }$ history rewards of the ACKTR models. As parameter choices could be vital, we perform an additional ablation study shown below. The result shows that the performance of A2MC is robust across different parameters of choice and is not too sensitive to changes on either of the hyper-params.
+
+<table><tr><td>Games</td><td>ACKTR</td><td>A2MC w/</td><td>T=20 Omax=1</td><td>T=10 Omax=1</td><td>T=10 0max=2</td><td>T=40 Omax=1</td><td>T=40 Omax=2</td></tr><tr><td>Boxing</td><td>1.23</td><td></td><td>99.19</td><td>94.76</td><td>98.51</td><td>99.18</td><td>98.07</td></tr><tr><td>Jamesbond</td><td>409.50</td><td></td><td>453.50</td><td>438.50</td><td>470.00</td><td>442.25</td><td>457.75</td></tr><tr><td>Wizard of Wor</td><td>744.50</td><td></td><td>5448.00</td><td>5601.00</td><td>5363.50</td><td>2528.50</td><td>3287.50</td></tr></table>
+
+![](images/162bf3e0520ec61e2d4440c63fcb2a71cb0c9e75a49eabbe055eb3df783697fa.jpg)  
+Figure 7: “Stress testing” ablation study on the MuJoCo continuous benchmark using hyperparameters tuned in Atari discrete control. Although this set of hyperparameters is suboptimal for the MuJoCo continuous control tasks, A2MC still obtain reasonable performance in the long run and it is less prone to overfitting.
+
+Table 3: Raw scores across all games, starting with 30 no-op actions. Scores are reported by averaging the last 500 episodes upon 50 million timesteps of training as in Wu et al. (2017). A relative margin comparing A2MC to ACKTR is shown. Scores from other models are taken from Wu et al. (2017) and Mnih et al. (2015).   
+
+<table><tr><td>GAME</td><td>Human</td><td>DQN</td><td>DDQN Prior. Duel</td><td></td><td>ACKTR OurA2MC</td><td></td><td>(Margin)</td></tr><tr><td>Alien</td><td>7127.7</td><td>1620</td><td>3747.7</td><td>3941</td><td>3197.1</td><td>2986.3</td><td>-6.6%</td></tr><tr><td>Amidar</td><td>1719.5</td><td>978</td><td>1793.3</td><td>2296.8</td><td>1059.4</td><td>2040.1</td><td>92.6%</td></tr><tr><td>Assault</td><td>742.0</td><td>4280.4</td><td>5393.2</td><td>11477</td><td>10777.7</td><td>9892.4</td><td>-8.2%</td></tr><tr><td>Asterix</td><td>8503.3</td><td>4359</td><td>17356.5</td><td>375080</td><td>31583.0</td><td>32671.0</td><td>3.4%</td></tr><tr><td>Asteroids</td><td>47388.7</td><td>1364.5</td><td>734.7</td><td>1192.7</td><td>34171.6</td><td>828931.6</td><td>2325.8%</td></tr><tr><td>Atlantis</td><td>29028.1</td><td>279987</td><td>106056</td><td>395762</td><td>3433182.0</td><td>2886274.0</td><td> -15.9%</td></tr><tr><td>Bankheist</td><td>753.1</td><td>455</td><td>1030.6</td><td>1503.1</td><td>1289.7</td><td>1290.6</td><td>0.1%</td></tr><tr><td>Battlezone</td><td>37187.5</td><td>29900</td><td>31700</td><td>35520</td><td>8910.0</td><td>10570.0</td><td>18.6%</td></tr><tr><td>Beamrider</td><td>16926.5</td><td>8627.5</td><td>13772.8</td><td>30276.5</td><td>13581.4</td><td>13715.6</td><td>1.0%</td></tr><tr><td>Berzerk</td><td>2630.4</td><td>585.6</td><td>1225.4</td><td>3409</td><td>927.2</td><td>974.0</td><td>5.0%</td></tr><tr><td>Bowling</td><td>160.7</td><td>50.4</td><td>68.1</td><td>46.7</td><td>24.3</td><td>31.6</td><td>30.0%</td></tr><tr><td>Boxing</td><td>12.1</td><td>88</td><td>91.6</td><td>98.9</td><td>1.5</td><td>93.5</td><td>6344.8%</td></tr><tr><td>Breakout</td><td>30.5</td><td>385.5</td><td>418.5</td><td>366</td><td>735.7</td><td>420.6</td><td>-42.8%</td></tr><tr><td>Centipede</td><td>12017.0</td><td>4657.7</td><td>5409.4</td><td>7687.5</td><td>7125.3</td><td>12096.5</td><td>69.8%</td></tr><tr><td>Choppercommand</td><td>9882.0</td><td>N/A</td><td>N/A</td><td>N/A</td><td>~8000</td><td>12149.0</td><td>~42.5%</td></tr><tr><td>Crazyclimber</td><td>35829.4</td><td>110763</td><td>117282</td><td>162224</td><td>150444.0</td><td>152439.0</td><td>1.3%</td></tr><tr><td>Demonattack</td><td>1971.0</td><td>12149.4</td><td>58044.2</td><td>72878.6</td><td>274176.7</td><td>361807.1</td><td>32.0%</td></tr><tr><td>Doubledunk</td><td>-16.4</td><td>-6.6</td><td>-5.5</td><td>-12.5</td><td>-0.5</td><td>20.6</td><td>3907.5%</td></tr><tr><td>Enduro</td><td>860.5</td><td>729</td><td>1211.8</td><td>2306.4</td><td>0.0</td><td>3550.6</td><td>8%</td></tr><tr><td>Fishingderby</td><td>-38.7</td><td>-4.9</td><td>15.5</td><td>41.3</td><td>33.7</td><td>38.4</td><td>13.9%</td></tr><tr><td>Freeway</td><td>29.6</td><td>30.8</td><td>33.3</td><td>33</td><td>0.0</td><td>32.7</td><td>0%</td></tr><tr><td>Frostbite</td><td>4335.0</td><td>N/A</td><td>N/A</td><td>N/A</td><td>~280</td><td>293.7</td><td>~5.1%</td></tr><tr><td>Gopher</td><td>2412.5</td><td>8777.4</td><td>14840.8</td><td>104368.2</td><td>47730.8</td><td>86101.4</td><td>80.4%</td></tr><tr><td>Gravitar</td><td>2672.0</td><td>N/A</td><td>N/A</td><td>N/A</td><td>~300</td><td>995.0</td><td>-2.9%</td></tr><tr><td>Icehockey</td><td>0.9</td><td>-1.9</td><td>-2.7</td><td>-0.4</td><td>-4.2</td><td>-2.1</td><td>16.3%</td></tr><tr><td>Jamesbond</td><td>302.8</td><td>768.5</td><td>1358</td><td>812</td><td>490.0</td><td>545.0</td><td>11.2%</td></tr><tr><td>Kangaroo</td><td>3035.0</td><td>7259</td><td>12992</td><td>1792</td><td>3150.0</td><td>11269.0</td><td>257.7%</td></tr><tr><td>Krull</td><td>2665.5</td><td>8422.3</td><td>7920.5</td><td>10374.4</td><td>9686.9</td><td>10245.4</td><td>5.8%</td></tr><tr><td>Kungfumaster</td><td>22736.3</td><td>26059</td><td>29710</td><td>48375</td><td>34954.0</td><td>39773.0</td><td>13.8%</td></tr><tr><td>Mspacman</td><td>15693.0</td><td>N/A</td><td>N/A</td><td>N/A</td><td>~3500</td><td>5006.1</td><td>~34.5%</td></tr><tr><td>Namethisgame</td><td>4076.0</td><td>N/A</td><td>N/A</td><td>N/A</td><td>~12500</td><td>12569.9</td><td>~0.6%</td></tr><tr><td>Phoenix</td><td>7242.6</td><td>8485.2</td><td>12252.5</td><td>70324.3</td><td>133433.7</td><td>221288.3</td><td>65.8%</td></tr><tr><td>Pitfall</td><td>6463.7</td><td>-286.1</td><td>-29.9</td><td>0</td><td>-1.1</td><td>-2.5</td><td>-0.3%</td></tr><tr><td>Pong</td><td>14.6</td><td>20.9</td><td>21</td><td>20.9</td><td>20.9</td><td>19.7</td><td>-5.9%</td></tr><tr><td>Privateeye</td><td>69571.0</td><td>N/A</td><td>N/A</td><td>N/A</td><td>~560</td><td>507.0</td><td>-9.5%</td></tr><tr><td>Qbert</td><td>13455.0</td><td>13117.3</td><td>15088.5</td><td>18760.3</td><td>23151.5</td><td>24075.8</td><td>4.0%</td></tr><tr><td>Riverraid</td><td>17118.0</td><td>7377.6</td><td>14884.5</td><td>20607.6</td><td>17762.8</td><td>18671.9</td><td>5.1%</td></tr><tr><td>Roadrunner</td><td>7845.0</td><td>39544</td><td>44127</td><td>62151</td><td>53446.0</td><td>50071.0</td><td>-6.3%</td></tr><tr><td>Robotank</td><td>11.9</td><td>63.9</td><td>65.1</td><td>27.5</td><td>16.5</td><td>26.5</td><td>60.5%</td></tr><tr><td>Seaquest</td><td>42054.7</td><td>5860.6</td><td>16452.7</td><td>931.6</td><td>1776.0</td><td>1805.6</td><td>1.7%</td></tr><tr><td>Solaris</td><td>12326.7</td><td>3482.8</td><td>3067.8</td><td>133.4</td><td>2368.6</td><td>2277.2</td><td>-3.9%</td></tr><tr><td>Spaceinvaders</td><td>1668.7</td><td>1692.3</td><td>2525.5</td><td>15311.5</td><td>19723.0</td><td>13544.2</td><td>-31.3%</td></tr><tr><td>Stargunner</td><td>10250.0</td><td>54282</td><td>60142</td><td>125117</td><td>82920.0</td><td>89616.0</td><td>8.1%</td></tr><tr><td>Tennis</td><td>-8.9</td><td>N/A</td><td>N/A</td><td>N/A</td><td>~-12</td><td>-4.7</td><td>~20.4%</td></tr><tr><td>Timepilot</td><td>5229.2</td><td>4870</td><td>8339</td><td>7553</td><td>22286.0</td><td>21992.0</td><td>-1.3%</td></tr><tr><td>Tutankham</td><td>167.6</td><td>68.1</td><td>218.4</td><td>245.9</td><td>314.3</td><td>193.7</td><td>-38.4%</td></tr><tr><td>Upndown</td><td>11693.2</td><td>9989.9</td><td>22972.2</td><td>33879.1</td><td>436665.8</td><td>563659.3</td><td>29.1%</td></tr><tr><td>Videopinball</td><td>17667.9</td><td>196760.4</td><td>309941.9</td><td>479197</td><td>100496.0</td><td>127452.4</td><td>26.8%</td></tr><tr><td>Wizardofwor YarsRevenge</td><td>4756.5</td><td>2704</td><td>7492</td><td>12352</td><td>702.0 125169.0</td><td>7864.0 143141.5</td><td>1020.2% 14.4%</td></tr></table>
+
+# D EXTENSION TO MULTI-CRITIC PPO (MC-PPO)
+
+The learning results of the proposed MC-PPO model on the MuJoCo tasks are shown in Figure 8. MC-PPO shows the best performance on Hopper and Walker- $_ { 2 d }$ among all models under the 1-million timesteps training budget. Both of our multi-critics variants (A2MC and MC-PPO) have won 6 out of the 8 MuJoCo tasks with relative performance margins (percentages in parentheses) larger than $2 5 \%$ .
+
+![](images/47b1442f99fadd4e266ec71e7ffe602454c89c06ae82dbdc9f5bc465cc0f2b12.jpg)  
+Figure 8: Performance on the MuJoCo continuous control benchmarks using PPO-based methods. Our proposed long/short-term reward characterization can be extended to the PPO method, i.e., the proposed multi-critic variant of PPO (MC-PPO). The shaded region denotes the standard deviation over 3 random seeds.
+
+# E EXTENSION TO OFF-POLICY METHODS
+
+Methods involving experience replay belong to the family of off-policy methods as they learn from off-policy trajectories. They were considered to be beyond the scope of this work, as we set out to improve the family of “on-policy” methods and we try to present as complete the analyses as possible (on both Atari and MuJoCo) in the main text.
+
+Notwithstanding this, we have been actively exploring the potential of applying the proposed reward mechanism with off-policy methods (in particular, on the strong baseline Rainbow Hessel et al. (2018). For consistencies in comparisons, all hyperparameters (e.g., learning rate, distributional atoms, noisy net $\sigma _ { 0 }$ ) are kept identical as in Hessel et al. (2018) except that we used a smaller replay buffer size of 50,000 for both the baseline and our method (due to limited compute). Moreover, we use the same experiment settings as in Sec 6 and we have NOT further tuned any parameters in VWR. We show preliminary results at 10 million time steps on Atari games in Figure 9 and we observe it is promising that introducing the proposed characterization of variability-weighted reward mechanism improves off-policy methods as well.
+
+The robustness of our proposed reward mechanism across both on-policy and off-policy frameworks suggests that the concept of “risk-adjusted return” Sharpe (1994) should apply in reinforcement learning in general, as it brings the desired property in faciliating better sample efficiency and learning stability. Given limited time and computing resources we are not able to present a full analysis on all the off-policy frameworks as we did for the on-policy methods within this paper (since training off-policy models takes significantly longer time). Potentially we aim to have the complete results in an additional paper in our future works.
+
+![](images/49950388de336cc09e187e4bf97c4e8d8151b5317eb9c6ae2d692622fb39fa69.jpg)  
+Figure 9: Performance of applying the variability-weighted reward to the Rainbow model on the Atari benchmark. We observe that introducing the proposed reward characterizations significantly expediate the learning in games such as “Jamesbond” and “NameThisName”, while showing consistent improvement towards the rest. The shaded region denotes the standard deviation over 2 random seeds.
+
+# F CASE STUDY: PLAYING DOOM WITH REWARD SHAPING
+
+It is worth investigating whether the proposed auxiliary reward signal VWR can work “side-by-side” with carefully shaped rewards specific to some particular game scenario – for example, the FPS game Doom Lample & Chaplot (2017). As our proposed reward characterization is generic in design and orthogonal to reward shaping, we aim to validate that the concept of risk-adjusted return and variability weights can be equally applied under such shaping settings.
+
+To this end, we adopt the off-policy agent “Arnold” Lample & Chaplot (2017) with experience replay as our baseline and we calculate VWR (see Section 4]) based on the historical sequence of the shaped rewards defined in Lample & Chaplot (2017) (See the Table 4). For VWR parameters, we set $\sigma _ { m a x } = 5$ since the maximum (minimum) attainable reward is $5 . 0 \ : ( - 5 . 0 )$ under such reward shaping3. The rest of the game setup and bot numbers are defaulted to the code released by Lample & Chaplot (2017).
+
+Table 4: Reward shaping settings as in Arnold Lample & Chaplot (2017)   
+
+<table><tr><td>Type</td><td>Base /Dist Kill</td><td></td><td></td><td></td><td> Suicide Death Injured Use ammo Weapon /Ammo /Medkit /Armor</td></tr><tr><td>Value</td><td>0.0 5.0 -5.0</td><td>-5.0 -1.0</td><td></td><td>-0.2</td><td>1.0 / 1.0/ 1.0 /1.0</td></tr></table>
+
+We follow the evaluation criterion of Track-1 in ViZDoom AI Competition 2016 using “Frags per episode”, i.e., the number of kills minus the number of suicides for the agent in one round of game (higher is better). The result under 50 training hours is shown in Figure 10 and we consistently observe that the Arnold agent can be significantly boosted with the help of VWR. This confirms that our proposed reward characterization is able to bring further improvements on top of both reward shaping and experience replay methods across domains.
+
+<table><tr><td colspan="3">(a) Game statistics in 50 hours</td></tr><tr><td>After 24 hours</td><td>Arnold</td><td>Arnod + VWR</td></tr><tr><td>Kills</td><td>105</td><td>183</td></tr><tr><td>Frags</td><td>87</td><td>173</td></tr><tr><td>K/D ratio</td><td>1.48</td><td>2.08</td></tr><tr><td>After 50 hours</td><td></td><td></td></tr><tr><td>Kills</td><td>116</td><td>244</td></tr><tr><td>Frags</td><td>113</td><td>223</td></tr><tr><td>K/D ratio</td><td>2.00</td><td>2.65</td></tr></table>
+
+![](images/db55751aa06be9678b9b3cbbc236a6556fe7f569ecf88f6d40f94b718c84ff35.jpg)  
+Figure 10: Doom - Limited Deathmatch (Track-1)
+
+(b) Learning results averaged over 2 random seeds
+
+# G ABLATION STUDY: VWR V.S. ELIGIBILITY TRACE
+
+Eligibility traces $\mathrm { T D } ( \lambda )$ is widely used in bridging TD algorithms to Monte Carlo (MC) methods.   
+Essentially, the discounted cumulative return can be formulated by not just toward “any n-step” return (using n-step look ahead), but toward any average of n-step look-ahead returns Sutton & Barto (2018).   
+The online variant of generalized advantage estimation using eligibility traces (GAE) Schulman et al.   
+(2016) confirms that on-policy methods can benefit from $\mathrm { T D } ( \lambda )$ learning.
+
+For the proposed variability-weighted reward, the design theme is to look explicitly backward and to assess the past performance of the agent via the “risk-adjusted return” concept. These two mechanisms can be combined seamlessly via Eq. 8 and our empirical results suggest VWR brings further improvements on top of eligibility traces.
+
+As VWR and eligibility traces are thematically similar in some sense, we further perform an ablation study to contrast the contributions brought by VWR. As shown in Figure 11, we compare three different settings: (1) ACKTR $^ +$ GAE, (2) ACKTR $^ +$ vwr and (3) $\mathbf { A C K T R } + \mathbf { G A E } + \mathbf { v w r }$ (i.e., the proposed A2MC). We observe that on average VWR brings greater improvements compared to eligibility traces, and the combination of both (i.e., A2MC) results in consistently good performance across the Atari testbed.
+
+![](images/07967da42241a720cc821748d81b04ae5e04c2e52c7cff56b270943ae05ee01a.jpg)  
+Figure 11: Ablation study of separately applying the (1) the eligibility traces (GAE) and (2) variabilityweighted reward (VWR) to the ACKTR model on the Atari benchmark. We observe that the combination of both (i.e., A2MC) results in consistently good performance across the Atari testbed. The shaded region denotes the standard deviation over 2 random seeds.
+
+# H THE SHARPE RATIO ITSELF
+
+We have explored other forms of reward that fits the general idea of introducing variability weights to the reward shaping mechanism. One example is the “Sharpe Ratio” itself, which is defined as $\begin{array} { r } { r ^ { S R } \ = \ \frac { \mathbb { E } [ r ] } { \sigma ( r ) } } \end{array}$ . In our initial studies, we found it only improved upon the baseline marginally, as rSR could end up emphasizing on penalizing high-variations and it might discourage the agent too intensively (see Figure below). Thats why we have sought an alternative formulation using the proposed $r ^ { v w r }$ and found that $A 2 M C _ { V \bar { W } R } ~ > ~ A 2 M \bar { C _ { S R } } ~ > ~ A C K T R$ . An example highlighting the vwr benefit is provided in Appendix A and a more thorough survey on key components in reward designs/formulations will be included in our future works.
+
+# I ALGORITHM
+
+The learning algorithm of A2MC is shown in Algorithm 1.
+
+![](images/253d4905e0b1e4bda4a2e88e4a8861653c091bb27f95f978262ed8fdd7f93806.jpg)
+
+# Algorithm 1 Advantage Actor Multi-Critic Learning (A2MC)
+
+1: Initialize parameters: $\theta _ { a } , \theta _ { v } ^ { j } , j \in \{ \mathrm { s h o r t - t e r m } , \mathrm { l o n g - t e r m } \}$   
+2: Initialize look-ahead steps: $N$ , step counter: $T = 0$ , maximum step: $T _ { m a x }$   
+3: Initialize hot-wire probability: $\epsilon$   
+4: Initialize environment: Env   
+5: Initialize reward history: \~r   
+6: repeat   
+7: Reset gradients: $d \theta \gets 0$ and $d \theta _ { v } ^ { j } \gets 0 , j \in \{ \mathrm { s h o r t } \mathrm { - t e r m } , \mathrm { l o n g } \mathrm { - t e r m } \}$   
+8: Get state: $s _ { t } \gets E n v$   
+9: $f l a g = 1$ , $a _ { r a n d }$ is uniformly sampled in action space with probability $\epsilon$ , otherwise $f l a g = 0$   
+10: for $t = 0 : N - 1$ do   
+11: Perform $a _ { t }$ according to policy $\pi ( a _ { t } | s _ { t } ; \theta _ { a } )$ if not f lag else $a _ { t } = a _ { r a n d }$   
+12: Received reward $r _ { t }$ and new state $s _ { t + 1 }$ , append $r _ { t }$ to $\vec { \bf r }$   
+13: Calculate $r _ { t } ^ { v w r }$ from $\vec { \mathbf { r } }$ based on Eq. (2-7)   
+14: $T \gets T + \dot { 1 }$   
+15: end for   
+16: $R ^ { \mathrm { s h o r t - t e r m } } = V ( s _ { N } ; \theta _ { v } ^ { \mathrm { s h o r t - t e r m } } )$   
+17: $R ^ { \mathrm { { l o n g - t e r m } } } = V ( s _ { N } ; \theta _ { v } ^ { \mathrm { { l o n g - t e r m } } } )$   
+18: for $i = N - 1$ to 0 step $- 1$ do   
+19: $\begin{array} { l } { { R _ { } ^ { \mathrm { s h o r t - t e r m } }  r _ { i } + \bar { \gamma } R ^ { \mathrm { s h o r t - t e r m } } } } \\ { { R _ { } ^ { \mathrm { l o n g - t e r m } }  r _ { i } ^ { v w r } + \gamma R ^ { \mathrm { l o n g - t e r m } } } } \end{array}$   
+20:   
+21: Advantange gradients wrt $\begin{array} { r } { \theta _ { a } : d \theta _ { a } \gets d \theta _ { a } + \nabla _ { \theta _ { a } } \log \pi ( a _ { i } | s _ { i } ; \theta _ { a } ) \sum _ { j } ( R ^ { j } - V ( s _ { i } ; \theta _ { v } ^ { j } ) ) } \end{array}$   
+22: for $j \in$ {short-term, long-term} do   
+23: Accumulate gradients wrt $\dot { \theta } _ { v } ^ { j } : d \theta _ { v } ^ { j }  d \theta _ { v } ^ { j } + \partial ( R ^ { j } - V ( s _ { i } ; \theta _ { v } ^ { j } ) ) ^ { 2 } / \partial \theta _ { v } ^ { j }$   
+24: end for   
+25: end for   
+26: until $T \geq T _ { m a x }$
+
+![](images/9fd25f5ccbc9cf96954f6fdd9cbc44a1bd0277357795eda6b54b4793ba59308d.jpg)  
+Figure 12: Performance of A2MC on Atari games. The number in figure legend shows the average reward among the last 100 episodes upon 15 million timesteps and the percentage shows the performance margin as compared to ACKTR. The shaded region denotes the standard deviation over 2 random seeds.

parse/train/S1en0sRqKm/S1en0sRqKm.md

@@ -0,0 +1,200 @@
+# ON THE COMPUTATIONAL INEFFICIENCY OF LARGE BATCH SIZES FOR STOCHASTIC GRADIENT DESCENT
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Increasing the mini-batch size for stochastic gradient descent offers significant opportunities to reduce wall-clock training time, but there are a variety of theoretical and systems challenges that impede the widespread success of this technique (Das et al., 2016; Keskar et al., 2016). We investigate these issues, with an emphasis on time to convergence and total computational cost, through an extensive empirical analysis of network training across several architectures and problem domains, including image classification, image segmentation, and language modeling. Although it is common practice to increase the batch size in order to fully exploit available computational resources, we find a substantially more nuanced picture. Our main finding is that across a wide range of network architectures and problem domains, increasing the batch size beyond a certain point yields no decrease in wall-clock time to convergence for either train or test loss. This batch size is usually substantially below the capacity of current systems. We show that popular training strategies for large batch size optimization begin to fail before we can populate all available compute resources, and we show that the point at which these methods break down depends more on attributes like model architecture and data complexity than it does directly on the size of the dataset.
+
+# 1 INTRODUCTION
+
+Mini-batch stochastic gradient descent (SGD) is the dominant optimization method for training deep neural networks (DNNs) (Bengio & LeCun, 2007; Bottou, 2010). In the face of unprecedented growth in dataset size, a large body of work has attempted to scale SGD to train DNN models on increasingly large datasets, while keeping wall-clock time manageable (Iandola et al., 2015; Goyal et al., 2017; Smith & Le, 2018; Devarakonda et al., 2017). The most common approach to train large models at scale is distributed synchronous mini-batch SGD, which exploits additional computational resources through data parallelism. This technique reduces wall-clock training time by increasing the mini-batch size, i.e., the number of examples used to compute a stochastic estimate of the gradient of the loss function at each training iteration, while holding the number of epochs constant. Proponents of large batch size training often argue that the merits stem from its ability to decrease wall-clock training time while maintaining final model performance. Indeed, an enormous amount of work has gone into designing systems that seem to operate under an assumption that equates large batch size training with machine learning at scale (Goyal et al., 2017; Jia et al., 2018; Puri et al., 2018).
+
+Increasing the batch size improves the scaling performance of SGD per epoch, and there are significant challenges in building efficient distributed systems that are able to exploit additional computational resources to use large batch sizes (Jia et al., 2018). However, even if we were able to address these systems challenges, there are still more fundamental limitations to this approach. Large batch sizes often negatively impact important performance metrics of interest, including total computational cost (which usually determines monetary cost) and prediction quality.
+
+In this paper, we will measure the total computational cost as the number of training iterations times the work done per iteration—in order to simplify measurements, we use the number of training iterations as a proxy for the wall-clock time. We do this because the implementation of parallel algorithms depends on software and hardware choices, and our goal is to draw more general conclusions about the performance of SGD-based methods.
+
+Based on this model for total computational cost and wall-clock time, the following should be clear: unless increasing the batch size leads to a commensurate decrease in the total number of training iterations needed to find a good model, large batch training will result in greater total computational cost with little-to-no decrease in wall-clock training time.
+
+Based on our empirical results across a range of datasets and architectures, we find that as the batch size becomes larger, there are three main phases of scaling behavior for convergence speed: (1) there is a small regime of batch sizes in which increasing the batch size results in linear gains in convergence speed; (2) there is a larger regime of batch sizes that results in sublinear gains in convergence speed—in this regime, increasing the batch size can improve wall-clock training time at the expense of greater total computational cost; (3) eventually, we reach a third regime where a higher batch size results in marginal or non-existent reductions in convergence speed. In our experiments, we find that this third regime begins at a batch size that is too small to let us fully utilize available compute. Training past this batch size increases the total computational cost without reducing wall-clock training time or prediction quality. While there has been considerable excitement around heuristics that have been shown to make large batch training practical for certain problems (Goyal et al., 2017; Smith & Le, 2018), we demonstrate that these techniques still suffer from the same convergence trends we observe, and they often decrease stability of the training process.
+
+Recent work has observed that the final test performance of models trained with large batch sizes degrades after training for a fixed number of epochs (Yao et al., 2018; Keskar et al., 2016). This phenomenon is known as the generalization gap. Previous work addressing this problem has focused on training for more iterations in the large batch case (Hoffer et al., 2017) or adopting various heuristics to select a learning rate for larger batch sizes (Goyal et al., 2017; Smith & Le, 2018). Based on our empirical results, we find that existing techniques to mitigate the generalization gap do not work on some problems, and for other problems they only work for batch sizes that do not allow us to fully utilize our available compute. Perhaps more importantly, they do little to affect the diminishing returns in rates of convergence for training loss as batch size increases.
+
+Our objective is to understand the behavior of SGD and existing large batch techniques for many network architectures and problem domains, e.g., image classification/segmentation and natural language processing (NLP). We observe markedly worse performance for these techniques in domains other than image classification, where large batch optimization has received the most attention (Jia et al., 2018; You et al., 2017b). Because we eschew the challenges of an efficient distributed implementation by measuring number of iterations instead of wall-clock time, our results assume the most optimistic circumstances for large batch training. Our key observations are:
+
+• Increasing the batch size beyond a certain point yields no improvement in wall-clock time to convergence, even for a system with perfect parallelism. We observe that larger batch sizes result in a limited reduction in the number of training iterations needed to achieve low training or test error, and that eventually these gains become near-zero. Increasing the batch size leads to a significant increase in generalization error, which cannot be mitigated by existing techniques. We observe that these techniques often result in divergent training behavior or that they only mitigate degradation in test performance for small batch sizes relative to available compute. Dataset size is not the only factor determining the computational efficiency of large batch training. We observe that both the diminishing returns in convergence speed and the failure of existing methods correlate more with factors like model architecture and data complexity than dataset size alone. As a result, training time may significantly increase with dataset size in spite of increasingly available compute resources.
+
+In Section 2, we review the formulation of SGD as well as existing strategies to train with large batch sizes. In Section 3, we review recent theoretical results regarding the convergence rates of SGD in highly over-parameterized settings and discuss the potential impact of these results on the computational efficiency of SGD for deep learning. Section 4 presents our empirical results that demonstrate the inefficiencies of training SGD with large batch sizes, and we show that these persist when using existing large batch optimization techniques.
+
+# 2 BACKGROUND AND RELATED WORK
+
+Stochastic Gradient Descent. SGD is the most widely used algorithm to train DNN models. The model is parameterized by weights $\mathbf { w } \in \mathbb { R } ^ { d }$ , and the objective is to minimize the empirical loss over $n$ data points $\mathbf { x } _ { i }$ :
+
+$$
+L ( \mathbf { w } ) = \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \ell ( \mathbf { w } , \mathbf { x } _ { i } ) ,
+$$
+
+where $\ell ( \cdot , \cdot )$ is a loss, e.g., cross-entropy or squared error. This loss gives a corresponding gradient
+
+$$
+\mathbf { g } ( \mathbf { w } ) : = \nabla L ( \mathbf { w } ) = \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \nabla \ell ( \mathbf { w } , \mathbf { x } _ { i } ) .
+$$
+
+A mini-batch $B _ { m }$ of size $m < n$ is a collection of $m$ indices randomly drawn from the set $\{ 1 , \ldots , n \}$ , and we can use it to form an unbiased estimate of the gradient at iteration $k$ , as well as the corresponding SGD update:
+
+$$
+\mathbf { g } _ { m } ( \mathbf { w } _ { k } ) = \frac { 1 } { m } \sum _ { i \in \mathcal { B } _ { m } } \nabla \ell ( \mathbf { w } _ { k } , \mathbf { x } _ { i } ) \quad \mathrm { ~ a n d ~ } \quad \mathbf { w } _ { k + 1 } = \mathbf { w } _ { k } - \eta _ { k } \mathbf { g } _ { m } ( \mathbf { w } _ { k } ) ,
+$$
+
+where $\eta _ { k } > 0$ is the learning rate for iteration $k$ . One iteration of training for SGD corresponds to a single gradient computation / weight update. One epoch corresponds to $n / m$ iterations of training. This constitutes a single pass over the dataset, assuming the dataset is sampled without replacement.
+
+Efficient distributed systems reduce wall-clock training time by parallelizing gradient calculations across many machines. When the batch size is large enough to populate all available compute resources, this allows us to amortize the cost of coordination for each weight update.
+
+Existing large batch techniques. With the hope of keeping training times manageable as dataset sizes escalate, recent work has focused on the development of techniques that allow practitioners to increase the batch size to make use of growing computational resources (Jin et al., 2016; Jia et al., 2018; You et al., 2017a). However, there is a growing body of theoretical and empirical results suggesting that large batch sizes adversely affect the generalization performance of the final model (Yao et al., 2018; Keskar et al., 2016; Devarakonda et al., 2017).
+
+In response to this, recent work has proposed changing two parameters in relation to batch size: the number of training iterations and the learning rate. However, they also make assumptions that limit the effectiveness of their proposals as useful heuristics for practitioners.
+
+• Training longer: Hoffer et al. (2017) suggest increasing the number of training iterations. Even if this does reduce the generalization gap, it significantly increases both wall-clock training time and computational cost. Moreover, in some problems it does not lead to minima with better generalization performance (as we found when running our experiments). • Square root LR scaling: Scaling the learning rate as $\eta _ { 0 } \propto \sqrt { m }$ attempts to keep the weight increment length statistics constant, but the distance between SGD iterates is governed more by properties of the objective function than the ratio of learning rate to batch size (Chaudhari & Soatto, 2017; Zhu et al., 2018). This rule has also been found to be empirically sub-optimal in various problem domains (Krizhevsky, 2014). Linear LR scaling: The performance of large batch training can also be improved by using the linear scaling rule, which suggests choosing a learning rate proportional to the batch size $( \eta _ { 0 } \propto m )$ (Goyal et al., 2017). There are two motivations for this rule: the first assumes that one large-batch gradient step should resemble a series of small-batch gradient steps in order for convergence rates to improve linearly (Goyal et al., 2017); the other regards the SGD update equation as the Euler-Maruyama discretization of a stochastic differential equation (Sauer, 2012; Xing et al., 2018), and attempts to maintain a constant level of minibatch noise to help SGD explore the loss landscape (Chaudhari & Soatto, 2017; Zhu et al., 2018; Smith & Le, 2018).
+
+Both justifications for the linear scaling rule implicitly impose strong conditions on the loss function by requiring that it behave linearly near SGD iterates; therefore, if the loss function is highly nonlinear along the SGD trajectory or the step size is not small enough, then we should not expect these rules to provide useful guidance for many problems. Whereas several groups have successfully used this rule to train on the ImageNet dataset in under an hour, e.g. (Goyal et al., 2017; You et al., 2017b), applying this heuristic to other datasets has not led to similarly impressive results so far (Puri et al., 2018).
+
+The focus of this paper, however, is on more fundamental limitations of large batch training, and we empirically show that the above approaches fail to prevent diminishing returns in the rate of convergence for large batch sizes. We believe that these diminishing returns are of more immediate concern than the generalization gap and warrant more careful examination: if we cannot even minimize training error quickly, there is no real opportunity to minimize test error quickly, regardless of the difference in final test error across batch sizes by the time the model has converged.
+
+# 3 CRITICAL BATCH SIZES AND DIMINISHING RETURNS
+
+The convergence rate of SGD, denoted by $k _ { \epsilon } ( m )$ , is the number of iterations needed to achieve training error less than a fixed constant $\epsilon > 0$ by using SGD with batch size $m$ (we will drop the subscript $\epsilon$ when it is unambiguous). In order to guarantee that large batch sizes speed up training, $k ( m )$ should continue to decrease near-linearly with $m$ . Otherwise, a larger batch size increases computational cost with only limited reductions in wall-clock training time. For near-constant $k ( m )$ , the benefit of large batch sizes becomes near-zero.
+
+Ma et al. (2017) showed theoretically that in convex, over-parameterized settings, the reduction in convergence time obtained by increasing the batch size decays dramatically to a near-constant level after a critical batch size that is independent of the dataset size. This speedup is measured with respect to the number of SGD iterations required to reach some fixed loss error for some baseline batch size $m _ { 0 }$ , and for this purpose we define the speedup ratio $s ( m ; m _ { 0 } ) = k ( m _ { 0 } ) / k ( m )$ . The speedup ratio represents the amount of time we save by increasing the batch size to $m$ . Beyond the critical batch size mentioned above, even with no communication overhead and unlimited resources (where each batch size requires the same amount of wall-clock time to process) we would prefer to use the critical batch size because it requires less overall computation.
+
+This result is surprising because researchers have asserted that it should be possible to achieve linear gains in convergence speed so long as the batch size is small relative to dataset size (Smith & Le, 2018). This will present significant difficulties for future optimization work (large mini-batch training) because it prevents us from using large batch sizes as a catch-all approach to quickly train models on large datasets.
+
+# 4 EMPIRICAL EVALUATION
+
+Recent work studying large batch training has looked primarily at image classification (Jastrzebski et al., 2018; Yao et al., 2018), especially on the ImageNet dataset (Deng et al., 2009). We perform large batch size experiments across both traditional image classification (IC) tasks (such as on CIFAR-10/100 (Krizhevsky & Hinton, 2009)), as well as previously unexplored tasks like image segmentation (IS) using the Cityscapes dataset (Cordts et al., 2016), and natural language processing (NLP) using the WikiText-2 dataset (Merity et al., 2016). We also test how these results vary across other modern DNN architectures, namely ResNets (He et al., 2016), LSTMs (Hochreiter & Schmidhuber, 1997; Gers et al., 2000), AlexNet (Krizhevsky et al., 2012), VGG (Simonyan & Zisserman, 2014), Dilated Residual Networks (Yu et al., 2017), and MobileNetV2 (Sandler et al., 2014). We tested all of the large batch training techniques described in Section 2. We tried training longer based on the work of Hoffer et al. (2017), but we found that this necessarily cannot improve the convergence speed and often does not improve final test performance. The two other techniques include the square root scaling rule strategy (SRSR) and the linear scaling rule strategy (LSR). For the latter, we used a warm-up period at the start of training as suggested by Goyal et al. (2017). Table 1 reports our datasets, models and different training strategies. For each model, we evaluated against a base learning rate strategy (BLR) that used the same learning rate across all batch sizes. We selected this learning rate based on its performance on a small baseline batch size.
+
+![](images/b45c386a5ec3b1dee617dd3ed5dfe50c26a309dd84ec1efd0f4dcdac283a893c.jpg)  
+Figure 1: Contour plots of training losses for various problem domains on a log scale. Lighter colors indicate lower loss values. Since we train each batch size for a fixed number of epochs, the total number of training iterations scales down linearly. For each loss value, we can observe how many iterations it takes to converge to that value given a particular batch size, by tracing the level curve for the associated color. For all problems, there is a batch size after which the number of training iterations necessary to converge does not decrease.
+
+# 4.1 DIMINISHING RETURNS IN RATES OF CONVERGENCE
+
+We demonstrate the rapidly diminishing returns in rates of convergence across various problem domains and network configurations. Researchers increase the batch size in an attempt to achieve nearly linear speedups in convergence compared to a small mini-batch size. In particular, if the speedup is near-linear, i.e. $s ( m ; \bar { m } _ { 0 } ) = k ( \bar { m } _ { 0 } ) / k ( m ) \approx m / m _ { 0 }$ , then the computational cost remains nearly constant for large and small mini-batch SGD. However, if $s ( m ) \ \bar { \ll } \ m / m _ { 0 }$ , then the benefit of using large batch size training is negligible.
+
+In Figure 1, we show contour plots of training loss as a function of both the batch size and the number of training iterations of ResNet34 on CIFAR-10, an LSTM on WikiText-2, and DRN-D-22 on Cityscapes. Consider, for example, the contour plot for ResNet34 trained on CIFAR-10. We can see that as the batch size increases from 16 to 2048, the number of SGD iterations needed to achieve a particular loss value decreases linearly. Exceeding this regime, however, the speedup ratio becomes increasingly sublinear and soon we have $s ( m ; \bar { m _ { 0 } } ) \ll \bar { m } / m _ { 0 }$ . For batch size 8196, the training procedure does not achieve the lowest training loss, and from this perspective, even if we did not care about computational cost or training time, we would not be able to find an accurate model. We observe even worse scaling behavior for test performance (please see Figure 5 for details).
+
+Table 1: A description of the problem configurations and training strategies used in this paper. $\eta _ { 0 }$ is the initial learning rate, $W$ is the number of epochs used for warm-up in the linear scaling rule, $E$ is the total number of epochs trained   
+
+<table><tr><td>Dataset</td><td>Task</td><td>Architecture</td><td>Training Strategy</td><td>BS range</td></tr><tr><td> MNIST</td><td>IC</td><td>ResNet34</td><td>BLR,LSR (no = 0.1, W = 10, E = 200)</td><td>26 -214</td></tr><tr><td>CIFAR-10</td><td>IC</td><td>AlexNet, MobileNetV2 ResNet34, VGG16</td><td>BLR,LSR, SRSR (mo = 0.1,W=10,E= 200)</td><td>26-214</td></tr><tr><td>CIFAR-100</td><td>IC</td><td>ResNet34</td><td>BLR,LSR (no = 0.1,W = 10, E = 200)</td><td>2 -214</td></tr><tr><td>SVHN</td><td>IC</td><td>ResNet34</td><td>BLR,LSR (no =0.1,W =10,E= 200)</td><td>26-214</td></tr><tr><td> WikiText-2</td><td> NLP</td><td>LSTM</td><td>BLR,LSR (no = 20,W = 3,E = 40)</td><td>2³ -210</td></tr><tr><td>Cityscapes</td><td>IS</td><td>DRN-D-22</td><td>BLR,LSR (no = 0.01,W = 10,E= 100)</td><td>23 -211</td></tr></table>
+
+![](images/2f39da181bbafada9ee2bf61d16e3221282ee2f410345f6758d773bf18d978e5.jpg)  
+Figure 2: On the left: speedup curves when applying several popular techniques to avoid the generalization gap. Base LR uses a single learning rate for all batch sizes. On the right: the effect of the linear approximation error on final test accuracy when using the linear LR scaling rule.
+
+For NLP and IS, note that the gain from large batch training diminishes even faster. Neither the LSTM on WikiText-2 nor DRN-D-22 on Cityscapes can reach their respective baseline performances after reasonably small batch sizes of about 32 and 64, respectively. Although Puri et al. (2018) showed that training on the Amazon Reviews dataset (McAuley et al., 2015) can be done within 4 hours, they tune hyper-parameters heavily. This poses an issue for many practical deployments because these problems are often already slow to train.
+
+# 4.2 EXISTING STRATEGIES BREAK DOWN FOR LARGE BATCH SIZES
+
+We further explore how training with the linear and square root scaling rules compares to training with a fixed baseline learning rate (BLR) that does not change with batch size. In the left subfigure of Figure 2, we show the speedup curves of BLR, LSR, and SRSR strategies for ResNet34 on CIFAR10. Note that LSR and SRSR outperform BLR from batch size 256 to 2048 which implies that LSR and SRSR can help the model train for small-to-medium batch sizes. However, the speedup of LSR and SRSR is still worse than the ideal linear case, and the curves plateau quickly after a batch size of 2048, at which point BLR becomes better than LSR and SRSR. This means that for certain problems, scaling up the learning rate to compensate for an increased batch size hurts performance.
+
+In the right subfigure of Figure 2, we plot the test performance and the approximation error for LSR of ResNet34 on CIFAR-10. We measure the approximation error at the end of training, with final weights $\mathbf { w } ^ { * }$ . We take this error to be the absolute difference between the true loss value $L ( \mathbf { w } )$ and the linear approximation at $\mathbf { w } ^ { * }$ , given by $\hat { L } ( \mathbf { w } ) = L ( \mathbf { w } ^ { * } ) + \langle \mathbf { g } _ { m } ( \mathbf { w } ^ { * } ) , \mathbf { w } - \mathbf { w } ^ { * } \rangle$ . The approximation is calculated for $\mathbf { w } = \mathbf { w } ^ { * } - \eta \frac { m } { m _ { 0 } } \mathbf { g } _ { m } \big ( \mathbf { w } ^ { * } \big )$ to understand the behavior of the approximation along the trajectory for a single SGD iterate using the LSR. It appears that there exists a strong relationship between linear approximation error and test accuracy: as the linear approximation error increases, the test accuracy drops. Note the transition that happens at the critical batch size of 2048. After this point, the test accuracy drops significantly and the linear approximation error exceeds 1, showing that we quickly exit the regime in which the linear approximation is valid.
+
+![](images/8e5a9c2868609d6811e018f9aa938f74636a8e7c872b18be0773d9a10cb99683.jpg)  
+Figure 3: Speedup curves across different problem configurations. Left: different architectures result in different rates of convergence on CIFAR-10. Right: ResNet34 exhibits different rates of convergence on CIFAR-10, CIFAR-100, and SVHN. Loss thresholds are obtained by computing the lower quartile of loss values achieved by the largest batch size.
+
+# 4.3 CONVERGENCE SPEED HAS A WEAK DEPENDENCE ON DATASET SIZE
+
+Previous works have conjectured that the maximum batch size that can result in a good model is proportional to the size of the whole dataset (Smith et al., 2017; Smith & Le, 2018). However, for convex, over-parameterized problems, Ma et al. (2017) show that there is a model-dependent critical batch size after which we observe rapidly diminishing returns in convergence speed. In this section, to observe if a similar critical batch size exists in the non-convex case, we compare how changing model architecture or data complexity affects the shapes of speedup curves compared to changing the dataset size alone.
+
+First, in order to show that these diminishing returns depend on data complexity and DNN architecture, we plot speedup curves in Figure 3 to compare the scaling behaviors across different models and dataset configurations. For the error threshold , we chose the lowest quartile loss value reached by the largest batch size to make a fair comparison across configurations. This setup actually favors the large batch case, because there are lower loss thresholds that are attainable only in the small batch case. On the left, for the CIFAR-10 dataset, we compared four model architectures. For each architecture, we plotted the speedup curve obtained by training this model on the dataset for various batch sizes. The variety of speedup curve shapes indicates that model architecture is an important factor in determining the convergence speed of training for large batch sizes. For MobileNetV2/AlexNet, the diminishing returns become visible when batch size is 1024. However, for VGG16/ResNet34, the speedup does not flatten out until batch size 8196. Hence, in practice, the choice of model strongly affects our ability to use large batch sizes in SGD.
+
+On the right, in order to investigate the effect of problem complexity, we compared the performance of ResNet34 on four datasets of the same size: CIFAR-10, CIFAR-100, MNIST, and the SVHN dataset (we cut off MNIST and SVHN to $5 0 k$ training examples each). Although all problems display diminishing returns in rates of convergence, the point at which the curves plateau varies according to problem complexity. It is not hard to see that, for simpler problems such as SVHN, the curves flatten out later than for harder problems (e.g. CIFAR-10/100).
+
+In all of the above cases, the diminishing rates of return in convergence speed become visible after only moderate increases in the batch size. Previous works have only studied convergence behavior for a fairly limited range of batch sizes (e.g., up to 4096 for CIFAR-10) (Hoffer et al., 2017; Keskar et al., 2016). By increasing the batch size past this point, it becomes immediately apparent that the primary issue with large batch size optimization is training speed, not the generalization gap.
+
+![](images/96bab39fb3c982480548f52bd526a04980c2093b687c837893866a29eef23e63.jpg)  
+Figure 4: Speedup curves as dataset size varies for different datasets. Even as dataset size increases back up to the baseline of $1 0 0 \%$ , there is no noticeable improvement in convergence speed.
+
+In order to test whether the sublinear behavior of $s ( m ; m _ { 0 } )$ depends primarily on dataset size, we compare the speedup curves obtained when training a single model on different fractions of the original training data. We trained ResNet34 models on the CIFAR-10 and SVHN datasets (for SVHN in this experiment, we train on all $6 0 0 k$ available training images). For each dataset, we trained on $1 0 0 \%$ , $5 0 \%$ , and then $2 5 \%$ of the available training data.
+
+In Figure 4, we plot the resulting speedup curves for the various partitions. In order to maintain a fair comparison (as baseline loss values change for different dataset sizes), we again choose the loss threshold to be the lower quartile of loss values obtained by the largest batch size.1 Notably, the batch size at which the curves begin to plateau remains constant as dataset size changes. For ResNet34 on CIFAR-10, the linear speedup behavior breaks around batch size 128 for all three curves. By a batch size of 1024, all curves have flattened. We can see similar behavior for ResNet34 on SVHN. Overall, looking back to Figure 3, the choice of model and the complexity of the dataset appear to be more related to the shape of speedup curve than dataset size alone.
+
+# 5 CONCLUSION
+
+By experimenting across a wide range of network architectures and problem domains, we find that, after a certain point, increasing the batch size fails to decrease wall-clock time to convergence and results in low computational efficiency, even assuming perfect parallelism. The critical batch size after which these returns diminish tends to be small relative to existing system capabilities. These trends present impediments to progress in developing effective machine learning systems that are capable of handling growing data demands.
+
+Recent works also suggest heuristics to decrease the generalization gap, but we find that these heuristics cannot be used to solve the underlying issue of training convergence speed. Moreover, we find that they usually only help decrease the generalization error in a small-to-medium batch size regime. There does not seem to be a simple training heuristic to improve large batch performance in general.
+
+These results suggest that we should not assume that increasing the batch size for larger datasets will keep training times manageable for all problems. Even though it is a natural form of data parallelism for large-scale optimization, alternative forms of parallelism should be explored to utilize all of our data more efficiently.
+
+# REFERENCES
+
+Yoshua Bengio and Yann LeCun. Scaling Learning Algorithms Towards AI. In Large Scale Kernel Machines. MIT Press, 2007.
+
+Leon Bottou. Large-scale machine learning with stochastic gradient descent. In ´ Proceedings of COMPSTAT’2010, pp. 177–186. Springer, 2010.
+
+Pratik Chaudhari and Stefano Soatto. Stochastic gradient descent performs variational inference, converges to limit cycles for deep networks. arXiv:1710.11029, 10 2017.
+
+Marius Cordts, Mohamed Omran, Sebastian Ramos, Timo Rehfeld, Markus Enzweiler, Rodrigo Benenson, Uwe Franke, Stefan Roth, and Bernt Schiele. The Cityscapes Dataset for Semantic Urban Scene Understanding. In Proc. of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2016.
+
+Dipankar Das, Sasikanth Avancha, Dheevatsa Mudigere, Karthikeyan Vaidyanathan, Srinivas Sridharan, Dhiraj D. Kalamkar, Bharat Kaul, and Pradeep Dubey. Distributed Deep Learning Using Synchronous Stochastic Gradient Descent. arXiv:1602.06709, 2016.
+
+Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. ImageNet: A large-scale hierarchical image database. In Computer Vision and Pattern Recognition, 2009. CVPR 2009. IEEE Conference on, pp. 248–255. IEEE, 2009.
+
+Aditya Devarakonda, Maxim Naumov, and Michael Garland. AdaBatch: Adaptive Batch Sizes for Training Deep Neural Networks. arXiv:1712.02029, 2017.
+
+Felix A. Gers, Jurgen A. Schmidhuber, and Fred A. Cummins. Learning to Forget: Continual ¨ Prediction with LSTM. Neural Computing, 12(10):2451–2471, 10 2000.
+
+Priya Goyal, Piotr Dollar, Ross Girshick, Pieter Noordhuis, Lukasz Wesolowski, Aapo Kyrola, An-´ drew Tulloch, Yangqing Jia, and Kaiming He. Accurate, large minibatch SGD: training ImageNet in 1 hour. arXiv:1706.02677, 2017.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long Short-Term Memory. ¨ Neural Computing, 9(8): 1735–1780, 11 1997.
+
+Elad Hoffer, Itay Hubara, and Daniel Soudry. Train longer, generalize better: closing the generalization gap in large batch training of neural networks. In Advances in Neural Information Processing Systems, pp. 1731–1741, 2017.
+
+Forrest N. Iandola, Khalid Ashraf, Matthew W. Moskewicz, and Kurt Keutzer. FireCaffe: near-linear acceleration of deep neural network training on compute clusters. arXiv:1511.00175, 11 2015.
+
+Stanislaw Jastrzebski, Zachary Kenton, Devansh Arpit, Nicolas Ballas, Asja Fischer, Yoshua Bengio, and Amos J. Storkey. Three Factors Influencing Minima in SGD. arXiv:1711.04623, 11 2018.
+
+Xianyan Jia, Shutao Song, Wei He, Yangzihao Wang, Haidong Rong, Feihu Zhou, Liqiang Xie, Zhenyu Guo, Yuanzhou Yang, Liwei Yu, Tiegang Chen, Guangxiao Hu, Shaohuai Shi, and Xiaowen Chu. Highly Scalable Deep Learning Training System with Mixed-Precision: Training ImageNet in Four Minutes. arXiv:1807.11205, 07 2018.
+
+Peter H. Jin, Qiaochu Yuan, Forrest N. Iandola, and Kurt Keutzer. How to scale distributed deep learning? arXiv:1611.04581, 11 2016.
+
+Nitish Shirish Keskar, Dheevatsa Mudigere, Jorge Nocedal, Mikhail Smelyanskiy, and Ping Tak Peter Tang. On large-batch training for deep learning: Generalization gap and sharp minima. arXiv:1609.04836, 2016.
+
+Alex Krizhevsky. One weird trick for parallelizing convolutional neural networks. arXiv:1404.5997, 04 2014.
+
+Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. Technical report, Citeseer, 2009.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E. Hinton. ImageNet Classification with Deep Convolutional Neural Networks. In Proceedings of the 25th International Conference on Neural Information Processing Systems - Volume 1, NIPS’12, pp. 1097–1105. Curran Associates Inc., 2012.
+
+Siyuan Ma, Raef Bassily, and Mikhail Belkin. The Power of Interpolation: Understanding the Effectiveness of SGD in Modern Over-parametrized Learning. arXiv:1712.06559, 2017.
+
+Julian McAuley, Christopher Targett, Qinfeng Shi, and Anton van den Hengel. Image-Based Recommendations on Styles and Substitutes. In Proceedings of the 38th International ACM SIGIR Conference on Research and Development in Information Retrieval, SIGIR ’15, pp. 43–52. ACM, 2015.
+
+Stephen Merity, Caiming Xiong, James Bradbury, and Richard Socher. Pointer Sentinel Mixture Models. arXiv:1609.07843, 09 2016.
+
+Raul Puri, Robert Kirby, Nikolai Yakovenko, and Bryan Catanzaro. Large Scale Language Modeling: Converging on 40GB of Text in Four Hours. arXiv:1808.01371, 08 2018.
+
+Mark Sandler, Andrew G. Howard, Menglong Zhu, Andrey Zhmoginov, and Liang-Chieh Chen. Very Deep Convolutional Networks for Large-Scale Image Recognition. arXiv:1801.04381, 09 2014.
+
+Timothy Sauer. Numerical solution of stochastic differential equations in finance. In Handbook of computational finance, pp. 529–550. Springer, 2012.
+
+Karen Simonyan and Andrew Zisserman. Very Deep Convolutional Networks for Large-Scale Image Recognition. arXiv:1409.1556, 09 2014.
+
+Samuel L. Smith and Quoc V. Le. A Bayesian Perspective on Generalization and Stochastic Gradient Descent. In International Conference on Learning Representations, 2018.
+
+Samuel L Smith, Pieter-Jan Kindermans, and Quoc V Le. Don’t Decay the Learning Rate, Increase the Batch Size. arXiv:1711.00489, 2017.
+
+Chen Xing, Devansh Arpit, Christos Tsirigotis, and Yoshua Bengio. A Walk with SGD. arXiv:1802.08770, 2018.
+
+Zhewei Yao, Amir Gholami, Qi Lei, Kurt Keutzer, and Michael W Mahoney. Hessian-based Analysis of Large Batch Training and Robustness to Adversaries. arXiv:1802.08241, 2018.
+
+Yang You, Igor Gitman, and Boris Ginsburg. Large Batch Training of Convolutional Networks. arXiv:1708.03888, 2017a.
+
+Yang You, Zhao Zhang, Cho-Jui Hsieh, and James Demmel. 100-epoch ImageNet Training with AlexNet in 24 Minutes. arXiv:1709.05011, 2017b.
+
+Fisher Yu, Vladlen Koltun, and Thomas Funkhouser. Dilated Residual Networks. In 2017 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 636–644, 07 2017.
+
+Zhanxing Zhu, Jingfeng Wu, Bing Yu, Lei Wu, and Jinwen Ma. The Anisotropic Noise in Stochastic Gradient Descent: Its Behavior of Escaping from Minima and Regularization Effects. arXiv:1803.00195, 2018.
+
+![](images/e2d22d36762c86eb7114a858df3deb4cc64fe830391fe3ba4a35dd5954e98afa.jpg)  
+Figure 5: Contour plots of test losses for various problem domains on a log scale. The test losses for BLR are on the left, while the losses for the LSR strategy are on the right. Lighter colors indicate lower loss values. Since we train each batch size for a fixed number of epochs, the total number of training iterations scales down linearly. For each loss value, we can observe how many iterations it takes to converge to that value given a particular batch size, by tracing the level curve for the associated color. For all problems, there is a batch size after which the number of training iterations necessary to converge does not decrease.

parse/train/S1en0sRqKm/S1en0sRqKm_content_list.json

@@ -0,0 +1,1122 @@
+[
+    {
+        "type": "text",
+        "text": "ON THE COMPUTATIONAL INEFFICIENCY OF LARGE BATCH SIZES FOR STOCHASTIC GRADIENT DESCENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            823,
+            147
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            184,
+            170,
+            400,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Increasing the mini-batch size for stochastic gradient descent offers significant opportunities to reduce wall-clock training time, but there are a variety of theoretical and systems challenges that impede the widespread success of this technique (Das et al., 2016; Keskar et al., 2016). We investigate these issues, with an emphasis on time to convergence and total computational cost, through an extensive empirical analysis of network training across several architectures and problem domains, including image classification, image segmentation, and language modeling. Although it is common practice to increase the batch size in order to fully exploit available computational resources, we find a substantially more nuanced picture. Our main finding is that across a wide range of network architectures and problem domains, increasing the batch size beyond a certain point yields no decrease in wall-clock time to convergence for either train or test loss. This batch size is usually substantially below the capacity of current systems. We show that popular training strategies for large batch size optimization begin to fail before we can populate all available compute resources, and we show that the point at which these methods break down depends more on attributes like model architecture and data complexity than it does directly on the size of the dataset. ",
+        "bbox": [
+            233,
+            266,
+            764,
+            502
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            530,
+            334,
+            546
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Mini-batch stochastic gradient descent (SGD) is the dominant optimization method for training deep neural networks (DNNs) (Bengio & LeCun, 2007; Bottou, 2010). In the face of unprecedented growth in dataset size, a large body of work has attempted to scale SGD to train DNN models on increasingly large datasets, while keeping wall-clock time manageable (Iandola et al., 2015; Goyal et al., 2017; Smith & Le, 2018; Devarakonda et al., 2017). The most common approach to train large models at scale is distributed synchronous mini-batch SGD, which exploits additional computational resources through data parallelism. This technique reduces wall-clock training time by increasing the mini-batch size, i.e., the number of examples used to compute a stochastic estimate of the gradient of the loss function at each training iteration, while holding the number of epochs constant. Proponents of large batch size training often argue that the merits stem from its ability to decrease wall-clock training time while maintaining final model performance. Indeed, an enormous amount of work has gone into designing systems that seem to operate under an assumption that equates large batch size training with machine learning at scale (Goyal et al., 2017; Jia et al., 2018; Puri et al., 2018). ",
+        "bbox": [
+            174,
+            563,
+            825,
+            756
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Increasing the batch size improves the scaling performance of SGD per epoch, and there are significant challenges in building efficient distributed systems that are able to exploit additional computational resources to use large batch sizes (Jia et al., 2018). However, even if we were able to address these systems challenges, there are still more fundamental limitations to this approach. Large batch sizes often negatively impact important performance metrics of interest, including total computational cost (which usually determines monetary cost) and prediction quality. ",
+        "bbox": [
+            174,
+            763,
+            823,
+            847
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we will measure the total computational cost as the number of training iterations times the work done per iteration—in order to simplify measurements, we use the number of training iterations as a proxy for the wall-clock time. We do this because the implementation of parallel algorithms depends on software and hardware choices, and our goal is to draw more general conclusions about the performance of SGD-based methods. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Based on this model for total computational cost and wall-clock time, the following should be clear: unless increasing the batch size leads to a commensurate decrease in the total number of training iterations needed to find a good model, large batch training will result in greater total computational cost with little-to-no decrease in wall-clock training time. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            159
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Based on our empirical results across a range of datasets and architectures, we find that as the batch size becomes larger, there are three main phases of scaling behavior for convergence speed: (1) there is a small regime of batch sizes in which increasing the batch size results in linear gains in convergence speed; (2) there is a larger regime of batch sizes that results in sublinear gains in convergence speed—in this regime, increasing the batch size can improve wall-clock training time at the expense of greater total computational cost; (3) eventually, we reach a third regime where a higher batch size results in marginal or non-existent reductions in convergence speed. In our experiments, we find that this third regime begins at a batch size that is too small to let us fully utilize available compute. Training past this batch size increases the total computational cost without reducing wall-clock training time or prediction quality. While there has been considerable excitement around heuristics that have been shown to make large batch training practical for certain problems (Goyal et al., 2017; Smith & Le, 2018), we demonstrate that these techniques still suffer from the same convergence trends we observe, and they often decrease stability of the training process. ",
+        "bbox": [
+            174,
+            166,
+            825,
+            361
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Recent work has observed that the final test performance of models trained with large batch sizes degrades after training for a fixed number of epochs (Yao et al., 2018; Keskar et al., 2016). This phenomenon is known as the generalization gap. Previous work addressing this problem has focused on training for more iterations in the large batch case (Hoffer et al., 2017) or adopting various heuristics to select a learning rate for larger batch sizes (Goyal et al., 2017; Smith & Le, 2018). Based on our empirical results, we find that existing techniques to mitigate the generalization gap do not work on some problems, and for other problems they only work for batch sizes that do not allow us to fully utilize our available compute. Perhaps more importantly, they do little to affect the diminishing returns in rates of convergence for training loss as batch size increases. ",
+        "bbox": [
+            174,
+            367,
+            825,
+            493
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our objective is to understand the behavior of SGD and existing large batch techniques for many network architectures and problem domains, e.g., image classification/segmentation and natural language processing (NLP). We observe markedly worse performance for these techniques in domains other than image classification, where large batch optimization has received the most attention (Jia et al., 2018; You et al., 2017b). Because we eschew the challenges of an efficient distributed implementation by measuring number of iterations instead of wall-clock time, our results assume the most optimistic circumstances for large batch training. Our key observations are: ",
+        "bbox": [
+            174,
+            500,
+            825,
+            597
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• Increasing the batch size beyond a certain point yields no improvement in wall-clock time to convergence, even for a system with perfect parallelism. We observe that larger batch sizes result in a limited reduction in the number of training iterations needed to achieve low training or test error, and that eventually these gains become near-zero. Increasing the batch size leads to a significant increase in generalization error, which cannot be mitigated by existing techniques. We observe that these techniques often result in divergent training behavior or that they only mitigate degradation in test performance for small batch sizes relative to available compute. Dataset size is not the only factor determining the computational efficiency of large batch training. We observe that both the diminishing returns in convergence speed and the failure of existing methods correlate more with factors like model architecture and data complexity than dataset size alone. As a result, training time may significantly increase with dataset size in spite of increasingly available compute resources. ",
+        "bbox": [
+            215,
+            613,
+            826,
+            818
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In Section 2, we review the formulation of SGD as well as existing strategies to train with large batch sizes. In Section 3, we review recent theoretical results regarding the convergence rates of SGD in highly over-parameterized settings and discuss the potential impact of these results on the computational efficiency of SGD for deep learning. Section 4 presents our empirical results that demonstrate the inefficiencies of training SGD with large batch sizes, and we show that these persist when using existing large batch optimization techniques. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 BACKGROUND AND RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            513,
+            118
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Stochastic Gradient Descent. SGD is the most widely used algorithm to train DNN models. The model is parameterized by weights $\\mathbf { w } \\in \\mathbb { R } ^ { d }$ , and the objective is to minimize the empirical loss over $n$ data points $\\mathbf { x } _ { i }$ : ",
+        "bbox": [
+            173,
+            133,
+            825,
+            175
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/887595ea6a4113fb0007840a5a7f971572079b5726c91bec59fd88f90a821b85.jpg",
+        "text": "$$\nL ( \\mathbf { w } ) = \\frac { 1 } { n } \\sum _ { i = 1 } ^ { n } \\ell ( \\mathbf { w } , \\mathbf { x } _ { i } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            415,
+            172,
+            581,
+            215
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\ell ( \\cdot , \\cdot )$ is a loss, e.g., cross-entropy or squared error. This loss gives a corresponding gradient ",
+        "bbox": [
+            176,
+            217,
+            820,
+            233
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5ce375a0c0b4eba72df983bc418c05ba2ee824ff817e740a7b4a68960b2471aa.jpg",
+        "text": "$$\n\\mathbf { g } ( \\mathbf { w } ) : = \\nabla L ( \\mathbf { w } ) = \\frac { 1 } { n } \\sum _ { i = 1 } ^ { n } \\nabla \\ell ( \\mathbf { w } , \\mathbf { x } _ { i } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            370,
+            238,
+            627,
+            280
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A mini-batch $B _ { m }$ of size $m < n$ is a collection of $m$ indices randomly drawn from the set $\\{ 1 , \\ldots , n \\}$ , and we can use it to form an unbiased estimate of the gradient at iteration $k$ , as well as the corresponding SGD update: ",
+        "bbox": [
+            174,
+            286,
+            825,
+            329
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/83e3f1f25ec3b8d3387d926f3bff0f8c4141099ab08b61b4c0c318b9c7452052.jpg",
+        "text": "$$\n\\mathbf { g } _ { m } ( \\mathbf { w } _ { k } ) = \\frac { 1 } { m } \\sum _ { i \\in \\mathcal { B } _ { m } } \\nabla \\ell ( \\mathbf { w } _ { k } , \\mathbf { x } _ { i } ) \\quad \\mathrm { ~ a n d ~ } \\quad \\mathbf { w } _ { k + 1 } = \\mathbf { w } _ { k } - \\eta _ { k } \\mathbf { g } _ { m } ( \\mathbf { w } _ { k } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            266,
+            334,
+            730,
+            373
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\eta _ { k } > 0$ is the learning rate for iteration $k$ . One iteration of training for SGD corresponds to a single gradient computation / weight update. One epoch corresponds to $n / m$ iterations of training. This constitutes a single pass over the dataset, assuming the dataset is sampled without replacement. ",
+        "bbox": [
+            176,
+            378,
+            825,
+            421
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Efficient distributed systems reduce wall-clock training time by parallelizing gradient calculations across many machines. When the batch size is large enough to populate all available compute resources, this allows us to amortize the cost of coordination for each weight update. ",
+        "bbox": [
+            176,
+            428,
+            821,
+            470
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Existing large batch techniques. With the hope of keeping training times manageable as dataset sizes escalate, recent work has focused on the development of techniques that allow practitioners to increase the batch size to make use of growing computational resources (Jin et al., 2016; Jia et al., 2018; You et al., 2017a). However, there is a growing body of theoretical and empirical results suggesting that large batch sizes adversely affect the generalization performance of the final model (Yao et al., 2018; Keskar et al., 2016; Devarakonda et al., 2017). ",
+        "bbox": [
+            173,
+            477,
+            825,
+            561
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In response to this, recent work has proposed changing two parameters in relation to batch size: the number of training iterations and the learning rate. However, they also make assumptions that limit the effectiveness of their proposals as useful heuristics for practitioners. ",
+        "bbox": [
+            176,
+            568,
+            823,
+            609
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "• Training longer: Hoffer et al. (2017) suggest increasing the number of training iterations. Even if this does reduce the generalization gap, it significantly increases both wall-clock training time and computational cost. Moreover, in some problems it does not lead to minima with better generalization performance (as we found when running our experiments). • Square root LR scaling: Scaling the learning rate as $\\eta _ { 0 } \\propto \\sqrt { m }$ attempts to keep the weight increment length statistics constant, but the distance between SGD iterates is governed more by properties of the objective function than the ratio of learning rate to batch size (Chaudhari & Soatto, 2017; Zhu et al., 2018). This rule has also been found to be empirically sub-optimal in various problem domains (Krizhevsky, 2014). Linear LR scaling: The performance of large batch training can also be improved by using the linear scaling rule, which suggests choosing a learning rate proportional to the batch size $( \\eta _ { 0 } \\propto m )$ (Goyal et al., 2017). There are two motivations for this rule: the first assumes that one large-batch gradient step should resemble a series of small-batch gradient steps in order for convergence rates to improve linearly (Goyal et al., 2017); the other regards the SGD update equation as the Euler-Maruyama discretization of a stochastic differential equation (Sauer, 2012; Xing et al., 2018), and attempts to maintain a constant level of minibatch noise to help SGD explore the loss landscape (Chaudhari & Soatto, 2017; Zhu et al., 2018; Smith & Le, 2018). ",
+        "bbox": [
+            215,
+            622,
+            825,
+            882
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Both justifications for the linear scaling rule implicitly impose strong conditions on the loss function by requiring that it behave linearly near SGD iterates; therefore, if the loss function is highly nonlinear along the SGD trajectory or the step size is not small enough, then we should not expect these rules to provide useful guidance for many problems. Whereas several groups have successfully used this rule to train on the ImageNet dataset in under an hour, e.g. (Goyal et al., 2017; You et al., 2017b), applying this heuristic to other datasets has not led to similarly impressive results so far (Puri et al., 2018). ",
+        "bbox": [
+            176,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            172
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The focus of this paper, however, is on more fundamental limitations of large batch training, and we empirically show that the above approaches fail to prevent diminishing returns in the rate of convergence for large batch sizes. We believe that these diminishing returns are of more immediate concern than the generalization gap and warrant more careful examination: if we cannot even minimize training error quickly, there is no real opportunity to minimize test error quickly, regardless of the difference in final test error across batch sizes by the time the model has converged. ",
+        "bbox": [
+            174,
+            180,
+            825,
+            263
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 CRITICAL BATCH SIZES AND DIMINISHING RETURNS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            292,
+            650,
+            309
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The convergence rate of SGD, denoted by $k _ { \\epsilon } ( m )$ , is the number of iterations needed to achieve training error less than a fixed constant $\\epsilon > 0$ by using SGD with batch size $m$ (we will drop the subscript $\\epsilon$ when it is unambiguous). In order to guarantee that large batch sizes speed up training, $k ( m )$ should continue to decrease near-linearly with $m$ . Otherwise, a larger batch size increases computational cost with only limited reductions in wall-clock training time. For near-constant $k ( m )$ , the benefit of large batch sizes becomes near-zero. ",
+        "bbox": [
+            174,
+            329,
+            825,
+            412
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Ma et al. (2017) showed theoretically that in convex, over-parameterized settings, the reduction in convergence time obtained by increasing the batch size decays dramatically to a near-constant level after a critical batch size that is independent of the dataset size. This speedup is measured with respect to the number of SGD iterations required to reach some fixed loss error for some baseline batch size $m _ { 0 }$ , and for this purpose we define the speedup ratio $s ( m ; m _ { 0 } ) = k ( m _ { 0 } ) / k ( m )$ . The speedup ratio represents the amount of time we save by increasing the batch size to $m$ . Beyond the critical batch size mentioned above, even with no communication overhead and unlimited resources (where each batch size requires the same amount of wall-clock time to process) we would prefer to use the critical batch size because it requires less overall computation. ",
+        "bbox": [
+            174,
+            420,
+            825,
+            545
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "This result is surprising because researchers have asserted that it should be possible to achieve linear gains in convergence speed so long as the batch size is small relative to dataset size (Smith & Le, 2018). This will present significant difficulties for future optimization work (large mini-batch training) because it prevents us from using large batch sizes as a catch-all approach to quickly train models on large datasets. ",
+        "bbox": [
+            174,
+            553,
+            823,
+            622
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 EMPIRICAL EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            651,
+            415,
+            666
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Recent work studying large batch training has looked primarily at image classification (Jastrzebski et al., 2018; Yao et al., 2018), especially on the ImageNet dataset (Deng et al., 2009). We perform large batch size experiments across both traditional image classification (IC) tasks (such as on CIFAR-10/100 (Krizhevsky & Hinton, 2009)), as well as previously unexplored tasks like image segmentation (IS) using the Cityscapes dataset (Cordts et al., 2016), and natural language processing (NLP) using the WikiText-2 dataset (Merity et al., 2016). We also test how these results vary across other modern DNN architectures, namely ResNets (He et al., 2016), LSTMs (Hochreiter & Schmidhuber, 1997; Gers et al., 2000), AlexNet (Krizhevsky et al., 2012), VGG (Simonyan & Zisserman, 2014), Dilated Residual Networks (Yu et al., 2017), and MobileNetV2 (Sandler et al., 2014). We tested all of the large batch training techniques described in Section 2. We tried training longer based on the work of Hoffer et al. (2017), but we found that this necessarily cannot improve the convergence speed and often does not improve final test performance. The two other techniques include the square root scaling rule strategy (SRSR) and the linear scaling rule strategy (LSR). For the latter, we used a warm-up period at the start of training as suggested by Goyal et al. (2017). Table 1 reports our datasets, models and different training strategies. For each model, we evaluated against a base learning rate strategy (BLR) that used the same learning rate across all batch sizes. We selected this learning rate based on its performance on a small baseline batch size. ",
+        "bbox": [
+            174,
+            688,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/b45c386a5ec3b1dee617dd3ed5dfe50c26a309dd84ec1efd0f4dcdac283a893c.jpg",
+        "image_caption": [
+            "Figure 1: Contour plots of training losses for various problem domains on a log scale. Lighter colors indicate lower loss values. Since we train each batch size for a fixed number of epochs, the total number of training iterations scales down linearly. For each loss value, we can observe how many iterations it takes to converge to that value given a particular batch size, by tracing the level curve for the associated color. For all problems, there is a batch size after which the number of training iterations necessary to converge does not decrease. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            107,
+            810,
+            667
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 DIMINISHING RETURNS IN RATES OF CONVERGENCE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            776,
+            584,
+            791
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We demonstrate the rapidly diminishing returns in rates of convergence across various problem domains and network configurations. Researchers increase the batch size in an attempt to achieve nearly linear speedups in convergence compared to a small mini-batch size. In particular, if the speedup is near-linear, i.e. $s ( m ; \\bar { m } _ { 0 } ) = k ( \\bar { m } _ { 0 } ) / k ( m ) \\approx m / m _ { 0 }$ , then the computational cost remains nearly constant for large and small mini-batch SGD. However, if $s ( m ) \\ \\bar { \\ll } \\ m / m _ { 0 }$ , then the benefit of using large batch size training is negligible. ",
+        "bbox": [
+            174,
+            804,
+            825,
+            888
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In Figure 1, we show contour plots of training loss as a function of both the batch size and the number of training iterations of ResNet34 on CIFAR-10, an LSTM on WikiText-2, and DRN-D-22 on Cityscapes. Consider, for example, the contour plot for ResNet34 trained on CIFAR-10. We can see that as the batch size increases from 16 to 2048, the number of SGD iterations needed to achieve a particular loss value decreases linearly. Exceeding this regime, however, the speedup ratio becomes increasingly sublinear and soon we have $s ( m ; \\bar { m _ { 0 } } ) \\ll \\bar { m } / m _ { 0 }$ . For batch size 8196, the training procedure does not achieve the lowest training loss, and from this perspective, even if we did not care about computational cost or training time, we would not be able to find an accurate model. We observe even worse scaling behavior for test performance (please see Figure 5 for details). ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/6850766aebd7ac2141d3cf5d090844fbc7e2c84a240d31b09a191a647538a886.jpg",
+        "table_caption": [
+            "Table 1: A description of the problem configurations and training strategies used in this paper. $\\eta _ { 0 }$ is the initial learning rate, $W$ is the number of epochs used for warm-up in the linear scaling rule, $E$ is the total number of epochs trained "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>Task</td><td>Architecture</td><td>Training Strategy</td><td>BS range</td></tr><tr><td> MNIST</td><td>IC</td><td>ResNet34</td><td>BLR,LSR (no = 0.1, W = 10, E = 200)</td><td>26 -214</td></tr><tr><td>CIFAR-10</td><td>IC</td><td>AlexNet, MobileNetV2 ResNet34, VGG16</td><td>BLR,LSR, SRSR (mo = 0.1,W=10,E= 200)</td><td>26-214</td></tr><tr><td>CIFAR-100</td><td>IC</td><td>ResNet34</td><td>BLR,LSR (no = 0.1,W = 10, E = 200)</td><td>2 -214</td></tr><tr><td>SVHN</td><td>IC</td><td>ResNet34</td><td>BLR,LSR (no =0.1,W =10,E= 200)</td><td>26-214</td></tr><tr><td> WikiText-2</td><td> NLP</td><td>LSTM</td><td>BLR,LSR (no = 20,W = 3,E = 40)</td><td>2³ -210</td></tr><tr><td>Cityscapes</td><td>IS</td><td>DRN-D-22</td><td>BLR,LSR (no = 0.01,W = 10,E= 100)</td><td>23 -211</td></tr></table>",
+        "bbox": [
+            174,
+            151,
+            823,
+            273
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/2f39da181bbafada9ee2bf61d16e3221282ee2f410345f6758d773bf18d978e5.jpg",
+        "image_caption": [
+            "Figure 2: On the left: speedup curves when applying several popular techniques to avoid the generalization gap. Base LR uses a single learning rate for all batch sizes. On the right: the effect of the linear approximation error on final test accuracy when using the linear LR scaling rule. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            194,
+            297,
+            803,
+            462
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            542,
+            825,
+            640
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For NLP and IS, note that the gain from large batch training diminishes even faster. Neither the LSTM on WikiText-2 nor DRN-D-22 on Cityscapes can reach their respective baseline performances after reasonably small batch sizes of about 32 and 64, respectively. Although Puri et al. (2018) showed that training on the Amazon Reviews dataset (McAuley et al., 2015) can be done within 4 hours, they tune hyper-parameters heavily. This poses an issue for many practical deployments because these problems are often already slow to train. ",
+        "bbox": [
+            174,
+            647,
+            825,
+            731
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 EXISTING STRATEGIES BREAK DOWN FOR LARGE BATCH SIZES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            751,
+            660,
+            765
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We further explore how training with the linear and square root scaling rules compares to training with a fixed baseline learning rate (BLR) that does not change with batch size. In the left subfigure of Figure 2, we show the speedup curves of BLR, LSR, and SRSR strategies for ResNet34 on CIFAR10. Note that LSR and SRSR outperform BLR from batch size 256 to 2048 which implies that LSR and SRSR can help the model train for small-to-medium batch sizes. However, the speedup of LSR and SRSR is still worse than the ideal linear case, and the curves plateau quickly after a batch size of 2048, at which point BLR becomes better than LSR and SRSR. This means that for certain problems, scaling up the learning rate to compensate for an increased batch size hurts performance. ",
+        "bbox": [
+            174,
+            776,
+            825,
+            888
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In the right subfigure of Figure 2, we plot the test performance and the approximation error for LSR of ResNet34 on CIFAR-10. We measure the approximation error at the end of training, with final weights $\\mathbf { w } ^ { * }$ . We take this error to be the absolute difference between the true loss value $L ( \\mathbf { w } )$ and the linear approximation at $\\mathbf { w } ^ { * }$ , given by $\\hat { L } ( \\mathbf { w } ) = L ( \\mathbf { w } ^ { * } ) + \\langle \\mathbf { g } _ { m } ( \\mathbf { w } ^ { * } ) , \\mathbf { w } - \\mathbf { w } ^ { * } \\rangle$ . The approximation is calculated for $\\mathbf { w } = \\mathbf { w } ^ { * } - \\eta \\frac { m } { m _ { 0 } } \\mathbf { g } _ { m } \\big ( \\mathbf { w } ^ { * } \\big )$ to understand the behavior of the approximation along the trajectory for a single SGD iterate using the LSR. It appears that there exists a strong relationship between linear approximation error and test accuracy: as the linear approximation error increases, the test accuracy drops. Note the transition that happens at the critical batch size of 2048. After this point, the test accuracy drops significantly and the linear approximation error exceeds 1, showing that we quickly exit the regime in which the linear approximation is valid. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/8e5a9c2868609d6811e018f9aa938f74636a8e7c872b18be0773d9a10cb99683.jpg",
+        "image_caption": [
+            "Figure 3: Speedup curves across different problem configurations. Left: different architectures result in different rates of convergence on CIFAR-10. Right: ResNet34 exhibits different rates of convergence on CIFAR-10, CIFAR-100, and SVHN. Loss thresholds are obtained by computing the lower quartile of loss values achieved by the largest batch size. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            236,
+            113,
+            759,
+            258
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            352,
+            825,
+            468
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 CONVERGENCE SPEED HAS A WEAK DEPENDENCE ON DATASET SIZE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            487,
+            686,
+            501
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Previous works have conjectured that the maximum batch size that can result in a good model is proportional to the size of the whole dataset (Smith et al., 2017; Smith & Le, 2018). However, for convex, over-parameterized problems, Ma et al. (2017) show that there is a model-dependent critical batch size after which we observe rapidly diminishing returns in convergence speed. In this section, to observe if a similar critical batch size exists in the non-convex case, we compare how changing model architecture or data complexity affects the shapes of speedup curves compared to changing the dataset size alone. ",
+        "bbox": [
+            174,
+            513,
+            825,
+            609
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "First, in order to show that these diminishing returns depend on data complexity and DNN architecture, we plot speedup curves in Figure 3 to compare the scaling behaviors across different models and dataset configurations. For the error threshold \u000f, we chose the lowest quartile loss value reached by the largest batch size to make a fair comparison across configurations. This setup actually favors the large batch case, because there are lower loss thresholds that are attainable only in the small batch case. On the left, for the CIFAR-10 dataset, we compared four model architectures. For each architecture, we plotted the speedup curve obtained by training this model on the dataset for various batch sizes. The variety of speedup curve shapes indicates that model architecture is an important factor in determining the convergence speed of training for large batch sizes. For MobileNetV2/AlexNet, the diminishing returns become visible when batch size is 1024. However, for VGG16/ResNet34, the speedup does not flatten out until batch size 8196. Hence, in practice, the choice of model strongly affects our ability to use large batch sizes in SGD. ",
+        "bbox": [
+            173,
+            617,
+            825,
+            784
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "On the right, in order to investigate the effect of problem complexity, we compared the performance of ResNet34 on four datasets of the same size: CIFAR-10, CIFAR-100, MNIST, and the SVHN dataset (we cut off MNIST and SVHN to $5 0 k$ training examples each). Although all problems display diminishing returns in rates of convergence, the point at which the curves plateau varies according to problem complexity. It is not hard to see that, for simpler problems such as SVHN, the curves flatten out later than for harder problems (e.g. CIFAR-10/100). ",
+        "bbox": [
+            174,
+            791,
+            825,
+            875
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In all of the above cases, the diminishing rates of return in convergence speed become visible after only moderate increases in the batch size. Previous works have only studied convergence behavior for a fairly limited range of batch sizes (e.g., up to 4096 for CIFAR-10) (Hoffer et al., 2017; Keskar et al., 2016). By increasing the batch size past this point, it becomes immediately apparent that the primary issue with large batch size optimization is training speed, not the generalization gap. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/96bab39fb3c982480548f52bd526a04980c2093b687c837893866a29eef23e63.jpg",
+        "image_caption": [
+            "Figure 4: Speedup curves as dataset size varies for different datasets. Even as dataset size increases back up to the baseline of $1 0 0 \\%$ , there is no noticeable improvement in convergence speed. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            251,
+            113,
+            745,
+            261
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            330,
+            823,
+            358
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In order to test whether the sublinear behavior of $s ( m ; m _ { 0 } )$ depends primarily on dataset size, we compare the speedup curves obtained when training a single model on different fractions of the original training data. We trained ResNet34 models on the CIFAR-10 and SVHN datasets (for SVHN in this experiment, we train on all $6 0 0 k$ available training images). For each dataset, we trained on $1 0 0 \\%$ , $5 0 \\%$ , and then $2 5 \\%$ of the available training data. ",
+        "bbox": [
+            174,
+            364,
+            825,
+            435
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In Figure 4, we plot the resulting speedup curves for the various partitions. In order to maintain a fair comparison (as baseline loss values change for different dataset sizes), we again choose the loss threshold to be the lower quartile of loss values obtained by the largest batch size.1 Notably, the batch size at which the curves begin to plateau remains constant as dataset size changes. For ResNet34 on CIFAR-10, the linear speedup behavior breaks around batch size 128 for all three curves. By a batch size of 1024, all curves have flattened. We can see similar behavior for ResNet34 on SVHN. Overall, looking back to Figure 3, the choice of model and the complexity of the dataset appear to be more related to the shape of speedup curve than dataset size alone. ",
+        "bbox": [
+            174,
+            443,
+            825,
+            554
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            574,
+            318,
+            589
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "By experimenting across a wide range of network architectures and problem domains, we find that, after a certain point, increasing the batch size fails to decrease wall-clock time to convergence and results in low computational efficiency, even assuming perfect parallelism. The critical batch size after which these returns diminish tends to be small relative to existing system capabilities. These trends present impediments to progress in developing effective machine learning systems that are capable of handling growing data demands. ",
+        "bbox": [
+            174,
+            604,
+            825,
+            689
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Recent works also suggest heuristics to decrease the generalization gap, but we find that these heuristics cannot be used to solve the underlying issue of training convergence speed. Moreover, we find that they usually only help decrease the generalization error in a small-to-medium batch size regime. There does not seem to be a simple training heuristic to improve large batch performance in general. ",
+        "bbox": [
+            174,
+            695,
+            825,
+            752
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "These results suggest that we should not assume that increasing the batch size for larger datasets will keep training times manageable for all problems. Even though it is a natural form of data parallelism for large-scale optimization, alternative forms of parallelism should be explored to utilize all of our data more efficiently. ",
+        "bbox": [
+            174,
+            758,
+            823,
+            815
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            287,
+            118
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yoshua Bengio and Yann LeCun. Scaling Learning Algorithms Towards AI. In Large Scale Kernel Machines. MIT Press, 2007. ",
+        "bbox": [
+            173,
+            126,
+            825,
+            155
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Leon Bottou. Large-scale machine learning with stochastic gradient descent. In ´ Proceedings of COMPSTAT’2010, pp. 177–186. Springer, 2010. ",
+        "bbox": [
+            171,
+            165,
+            825,
+            194
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Pratik Chaudhari and Stefano Soatto. Stochastic gradient descent performs variational inference, converges to limit cycles for deep networks. arXiv:1710.11029, 10 2017. ",
+        "bbox": [
+            171,
+            203,
+            823,
+            232
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Marius Cordts, Mohamed Omran, Sebastian Ramos, Timo Rehfeld, Markus Enzweiler, Rodrigo Benenson, Uwe Franke, Stefan Roth, and Bernt Schiele. The Cityscapes Dataset for Semantic Urban Scene Understanding. In Proc. of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2016. ",
+        "bbox": [
+            173,
+            241,
+            826,
+            297
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Dipankar Das, Sasikanth Avancha, Dheevatsa Mudigere, Karthikeyan Vaidyanathan, Srinivas Sridharan, Dhiraj D. Kalamkar, Bharat Kaul, and Pradeep Dubey. Distributed Deep Learning Using Synchronous Stochastic Gradient Descent. arXiv:1602.06709, 2016. ",
+        "bbox": [
+            174,
+            308,
+            825,
+            351
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. ImageNet: A large-scale hierarchical image database. In Computer Vision and Pattern Recognition, 2009. CVPR 2009. IEEE Conference on, pp. 248–255. IEEE, 2009. ",
+        "bbox": [
+            173,
+            359,
+            825,
+            404
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Aditya Devarakonda, Maxim Naumov, and Michael Garland. AdaBatch: Adaptive Batch Sizes for Training Deep Neural Networks. arXiv:1712.02029, 2017. ",
+        "bbox": [
+            173,
+            412,
+            825,
+            441
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Felix A. Gers, Jurgen A. Schmidhuber, and Fred A. Cummins. Learning to Forget: Continual ¨ Prediction with LSTM. Neural Computing, 12(10):2451–2471, 10 2000. ",
+        "bbox": [
+            173,
+            450,
+            825,
+            481
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Priya Goyal, Piotr Dollar, Ross Girshick, Pieter Noordhuis, Lukasz Wesolowski, Aapo Kyrola, An-´ drew Tulloch, Yangqing Jia, and Kaiming He. Accurate, large minibatch SGD: training ImageNet in 1 hour. arXiv:1706.02677, 2017. ",
+        "bbox": [
+            174,
+            489,
+            823,
+            532
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016. ",
+        "bbox": [
+            173,
+            541,
+            823,
+            584
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jurgen Schmidhuber. Long Short-Term Memory. ¨ Neural Computing, 9(8): 1735–1780, 11 1997. ",
+        "bbox": [
+            173,
+            594,
+            821,
+            623
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Elad Hoffer, Itay Hubara, and Daniel Soudry. Train longer, generalize better: closing the generalization gap in large batch training of neural networks. In Advances in Neural Information Processing Systems, pp. 1731–1741, 2017. ",
+        "bbox": [
+            173,
+            632,
+            825,
+            676
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Forrest N. Iandola, Khalid Ashraf, Matthew W. Moskewicz, and Kurt Keutzer. FireCaffe: near-linear acceleration of deep neural network training on compute clusters. arXiv:1511.00175, 11 2015. ",
+        "bbox": [
+            173,
+            685,
+            821,
+            714
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Stanislaw Jastrzebski, Zachary Kenton, Devansh Arpit, Nicolas Ballas, Asja Fischer, Yoshua Bengio, and Amos J. Storkey. Three Factors Influencing Minima in SGD. arXiv:1711.04623, 11 2018. ",
+        "bbox": [
+            173,
+            723,
+            825,
+            766
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Xianyan Jia, Shutao Song, Wei He, Yangzihao Wang, Haidong Rong, Feihu Zhou, Liqiang Xie, Zhenyu Guo, Yuanzhou Yang, Liwei Yu, Tiegang Chen, Guangxiao Hu, Shaohuai Shi, and Xiaowen Chu. Highly Scalable Deep Learning Training System with Mixed-Precision: Training ImageNet in Four Minutes. arXiv:1807.11205, 07 2018. ",
+        "bbox": [
+            174,
+            776,
+            825,
+            833
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Peter H. Jin, Qiaochu Yuan, Forrest N. Iandola, and Kurt Keutzer. How to scale distributed deep learning? arXiv:1611.04581, 11 2016. ",
+        "bbox": [
+            166,
+            843,
+            823,
+            872
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Nitish Shirish Keskar, Dheevatsa Mudigere, Jorge Nocedal, Mikhail Smelyanskiy, and Ping Tak Peter Tang. On large-batch training for deep learning: Generalization gap and sharp minima. arXiv:1609.04836, 2016. ",
+        "bbox": [
+            174,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky. One weird trick for parallelizing convolutional neural networks. arXiv:1404.5997, 04 2014. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. Technical report, Citeseer, 2009. ",
+        "bbox": [
+            173,
+            141,
+            823,
+            170
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Ilya Sutskever, and Geoffrey E. Hinton. ImageNet Classification with Deep Convolutional Neural Networks. In Proceedings of the 25th International Conference on Neural Information Processing Systems - Volume 1, NIPS’12, pp. 1097–1105. Curran Associates Inc., 2012. ",
+        "bbox": [
+            174,
+            178,
+            825,
+            234
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Siyuan Ma, Raef Bassily, and Mikhail Belkin. The Power of Interpolation: Understanding the Effectiveness of SGD in Modern Over-parametrized Learning. arXiv:1712.06559, 2017. ",
+        "bbox": [
+            176,
+            243,
+            821,
+            273
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Julian McAuley, Christopher Targett, Qinfeng Shi, and Anton van den Hengel. Image-Based Recommendations on Styles and Substitutes. In Proceedings of the 38th International ACM SIGIR Conference on Research and Development in Information Retrieval, SIGIR ’15, pp. 43–52. ACM, 2015. ",
+        "bbox": [
+            173,
+            281,
+            825,
+            338
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Stephen Merity, Caiming Xiong, James Bradbury, and Richard Socher. Pointer Sentinel Mixture Models. arXiv:1609.07843, 09 2016. ",
+        "bbox": [
+            174,
+            347,
+            823,
+            376
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Raul Puri, Robert Kirby, Nikolai Yakovenko, and Bryan Catanzaro. Large Scale Language Modeling: Converging on 40GB of Text in Four Hours. arXiv:1808.01371, 08 2018. ",
+        "bbox": [
+            173,
+            385,
+            821,
+            414
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mark Sandler, Andrew G. Howard, Menglong Zhu, Andrey Zhmoginov, and Liang-Chieh Chen. Very Deep Convolutional Networks for Large-Scale Image Recognition. arXiv:1801.04381, 09 2014. ",
+        "bbox": [
+            173,
+            422,
+            826,
+            464
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Timothy Sauer. Numerical solution of stochastic differential equations in finance. In Handbook of computational finance, pp. 529–550. Springer, 2012. ",
+        "bbox": [
+            174,
+            474,
+            823,
+            503
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan and Andrew Zisserman. Very Deep Convolutional Networks for Large-Scale Image Recognition. arXiv:1409.1556, 09 2014. ",
+        "bbox": [
+            174,
+            511,
+            823,
+            541
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Samuel L. Smith and Quoc V. Le. A Bayesian Perspective on Generalization and Stochastic Gradient Descent. In International Conference on Learning Representations, 2018. ",
+        "bbox": [
+            174,
+            549,
+            823,
+            579
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Samuel L Smith, Pieter-Jan Kindermans, and Quoc V Le. Don’t Decay the Learning Rate, Increase the Batch Size. arXiv:1711.00489, 2017. ",
+        "bbox": [
+            173,
+            587,
+            823,
+            616
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chen Xing, Devansh Arpit, Christos Tsirigotis, and Yoshua Bengio. A Walk with SGD. arXiv:1802.08770, 2018. ",
+        "bbox": [
+            174,
+            625,
+            823,
+            654
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zhewei Yao, Amir Gholami, Qi Lei, Kurt Keutzer, and Michael W Mahoney. Hessian-based Analysis of Large Batch Training and Robustness to Adversaries. arXiv:1802.08241, 2018. ",
+        "bbox": [
+            173,
+            662,
+            825,
+            693
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yang You, Igor Gitman, and Boris Ginsburg. Large Batch Training of Convolutional Networks. arXiv:1708.03888, 2017a. ",
+        "bbox": [
+            173,
+            700,
+            823,
+            729
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yang You, Zhao Zhang, Cho-Jui Hsieh, and James Demmel. 100-epoch ImageNet Training with AlexNet in 24 Minutes. arXiv:1709.05011, 2017b. ",
+        "bbox": [
+            171,
+            738,
+            825,
+            767
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Fisher Yu, Vladlen Koltun, and Thomas Funkhouser. Dilated Residual Networks. In 2017 IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 636–644, 07 2017. ",
+        "bbox": [
+            169,
+            776,
+            823,
+            806
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zhanxing Zhu, Jingfeng Wu, Bing Yu, Lei Wu, and Jinwen Ma. The Anisotropic Noise in Stochastic Gradient Descent: Its Behavior of Escaping from Minima and Regularization Effects. arXiv:1803.00195, 2018. ",
+        "bbox": [
+            174,
+            814,
+            823,
+            857
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/e2d22d36762c86eb7114a858df3deb4cc64fe830391fe3ba4a35dd5954e98afa.jpg",
+        "image_caption": [
+            "Figure 5: Contour plots of test losses for various problem domains on a log scale. The test losses for BLR are on the left, while the losses for the LSR strategy are on the right. Lighter colors indicate lower loss values. Since we train each batch size for a fixed number of epochs, the total number of training iterations scales down linearly. For each loss value, we can observe how many iterations it takes to converge to that value given a particular batch size, by tracing the level curve for the associated color. For all problems, there is a batch size after which the number of training iterations necessary to converge does not decrease. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            146,
+            810,
+            705
+        ],
+        "page_idx": 10
+    }
+]

parse/train/SJl3h2EYvS/SJl3h2EYvS.md

@@ -0,0 +1,224 @@
+# CLAREL: CLASSIFICATION VIA RETRIEVAL LOSS FOR ZERO-SHOT LEARNING
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+We address the problem of learning fine-grained cross-modal representations. We propose an instance-based deep metric learning approach in joint visual and textual space. The key novelty of this paper is that it shows that using per-image semantic supervision leads to substantial improvement in zero-shot performance over using class-only supervision. On top of that, we provide a probabilistic justification for a metric rescaling approach that solves a very common problem in the generalized zero-shot learning setting, i.e., classifying test images from unseen classes as one of the classes seen during training. We evaluate our approach on two finegrained zero-shot learning datasets: CUB and FLOWERS. We find that on the generalized zero-shot classification task CLAREL consistently outperforms the existing approaches on both datasets.
+
+# 1 INTRODUCTION
+
+Deep learning-based approaches have demonstrated superior flexibility and generalization capabilities in information processing on a wide variety of tasks, such as vision, speech and language (LeCun et al., 2015). However, it has been widely realized that the transfer of deep representations to real-world applications is challenging due to the typical reliance on massive hand-labeled datasets. Learning in the low-labeled data regime, especially in the zero-shot (Wang et al., 2019) and the few-shot (Wang & Yao, 2019) setups, have recently received significant attention in the literature. In the problem of zero-shot learning (ZSL), the objective is to recognize categories that have not been seen during the training (Larochelle et al., 2008). This is typically done by relying on anchor embeddings learned in one modality as prototypes and by associating a query embedding from the other modality with the closest prototype. In the generalized ZSL (GZSL) case (Xian et al., 2018c), the objective is more challenging as recognition is performed in the joint space of seen and unseen categories. ZSL, as well as its generalized counterpart, provide a viable framework to learn cross-modal representations that are flexible and adaptive. For example, in this paradigm, the adaptation to a new classification task based on text/image representation space alignment could be as easy as defining/appending/modifying a set of text sentences to define classes of new classifiers. This is an especially relevant problem as machine learning is challenged with the long tail of classes, and the idea of learning from pairs of images and sentences, abundant on the web, looks like a natural solution. Therefore, in this paper we specifically target the fine-grained scenario of paired images and their respective text descriptions. The uniqueness of this scenario is in the fact that the co-occurance of image and text provides a rich source of information. The ways of leveraging this source have not been sufficiently explored in the context of GZSL. Although we focus exclusively on the GZSL recognition setup in this paper, we believe that the research in this direction has potential to enable zero-shot flexibility in a wider array of high-level tasks such as segmentation or conditional image generation (Zhang et al., 2018). The contributions of this work can be characterized under the following two themes.
+
+Instance-based training loss. Most prominent zero-shot learning approaches rely heavily on classlevel modality alignment (Xian et al., 2018c). We propose a new composite loss function that balances instance-based pairwise image/text retrieval loss and the usual classifier loss. The retrieval loss term does not use class labels. We demonstrate that the class-level information is important, but in the fine-grained text/image pairing scenarios, most of the GZSL accuracy can be extracted from the instance-based retrieval loss. To the best of our knowledge, this type of training has not been used in the GZSL literature. Its impressive performance opens up new promising research directions.
+
+![](images/c5306e54b7867e3eb7aee45c6499213721005da29ec547a7ed5a3a76968503c1.jpg)  
+Figure 1: The architecture and training diagram describing the proposed method. Each batch consists of randomly sampled instances, i.e. pairs of images and their corresponding texts. Images are embedded via ResNet and texts are embedded via a CNN/LSTM stack. Image and text features are projected via a fully connected layer into the same dimensional space. In this space, distances between text and image features from different instances are computed. The negative distances are fed into softmax to train on both the image and the text retrieval tasks. The image retrieval task consists of retrieving the image corresponding to the given text of the same instance and the text retrieval task is vice versa. In addition to that, image and text embeddings are trained on auxiliary image and text classification tasks on the class labels corresponding to instances.
+
+Metric space rescaling. Metric-based ZSL approaches rely on distances between prototypes and query embeddings during inference. They are known to suffer from imbalanced performance on seen and unseen classes (Liu et al., 2018). Previous work proposed to use a heuristic trick, calibrated stacking (Chao et al., 2016) or calibration (Das & Lee, 2019), to solve the problem. We refer to this technique as metric rescaling in our work, and provide a sound probabilistic justification for it.
+
+# 2 PROPOSED METHOD
+
+In this paper, we specifically target the fine-grained visual description scenario, as defined by Reed et al. (2016). In this setting, the dataset consists of a number of images from a given set of classes and each image is accompanied by a number of textual descriptions. The task is to learn a joint representation space for images and texts that can be used for zero-shot recognition. An instance of the zero-shot multimodal representation learning problem can then be defined as follows. Given a training set $S = \{ ( v _ { n } , t _ { n } , y _ { n } ) \mid v _ { n } \in \mathcal { V }$ , $t _ { n } \in \mathcal { T } , y _ { n } \in \mathcal { V } , n = 1 \ldots N \}$ of image, text and label tuples, we are interested in finding representations $f _ { \phi } : \mathcal { V } \to \mathcal { Z }$ of image, parameterized by $\phi$ , and $f _ { \theta } : \mathcal { T }  \mathcal { Z }$ of text, parameterized by $\theta$ , in a common embedding space $\mathcal { Z }$ . Furthermore, GZSL problem is defined using the sets of seen $\mathcal { V } ^ { t r }$ and unseen $\mathcal { V } ^ { t s }$ classes, such that $\mathcal { V } = \mathcal { V } ^ { t r } \cup \mathcal { V } ^ { t s }$ and $\bar { \mathcal { V } } ^ { t r } \cap \mathcal { V } ^ { t s } = \emptyset$ . The training set will then only contain the seen classes, i.e. $S ^ { t r } = \{ ( v _ { n } , t _ { n } , y _ { n } ) \mid v _ { n } \in$ $\nu$ , $t _ { n } \in \mathcal { T } , y _ { n } \in \mathcal { y } ^ { t r } \}$ and the task is to build a classifier function $g : \mathcal { Z } \times \mathcal { Z }  \mathcal { V }$ . This is different from the ZSL scenario focusing on $g : \mathcal { Z } \times \mathcal { Z }  \mathcal { Y } ^ { t s }$ .
+
+To build $g$ , most approaches to joint representation learning rely on class labeling to train a representation. For example, all the methods reviewed by Xian et al. (2018c) require the access to class labels at train time. We hypothesise that in the fine-grained learning scenario, such as the one described by Reed et al. (2016), a lot of information can be extracted simply from pairwise image/text cooccurrences. The class labels really only become critically necessary when we define class prototypes, i.e. at zero-shot test time. Following this intuition, we define a composite loss function that relies both on the pairwise relationships and on the class labels. The high-level description of the proposed framework is depicted in Figure 1. The framework enables us, among other things, to experiment with the effects of train-time availability of class labels on the quality of zero-shot representations. The framework is based on projecting texts and images into a common space and then learning a representation based on a mixture of four loss functions: a pairwise text retrieval loss, a pairwise image retrieval loss, a text classifier loss and an image classifier loss (see Algorithm 1).
+
+Algorithm 1 Loss calculation for a single optimization iteration of the proposed method. $N$ is the number of instances in the training set ${ \mathcal { S } } ^ { t r }$ , $B$ is the number of instances per batch, $C$ is the number of classes in the train set. $\mathrm { R A N D O M S A M P L E } ( S , B )$ denotes a set of $B$ elements chosen uniformly at random from a set $s$ , without replacement.
+
+<table><tr><td colspan="3">Input: Training set Str = {(U1,t1,yi),...,(UN,tN,yN)},λ ∈ [0,1], κ ∈ [0,1]. Output: The loss J(,θ) for a randomly sampled training batch. I← RANDOMSAMPLE({1,...,N},B) &gt;Select B instance indices for batch</td></tr><tr><td>Jrc(Θ),J1c(Φ)←0,0 foriinZdo</td><td colspan="3">Initialize classification losses Embed images and texts Image classifier probabilities</td></tr><tr><td colspan="3">Zui,Zt←f(Ui）,fθ(ti)</td></tr><tr><td colspan="2">p ← softmax(Wizui +b1) PT ← sOftmax(WTZt +br)</td></tr><tr><td colspan="2">Textclassifierprobabilities JTc(0) ← JTc(0)+ crossentropy(pr,yi) Text classification loss</td></tr><tr><td colspan="2">JIc(𝜙) ← Jic(Φ)+ crossentropy(p1, yi) Image classification loss end for</td></tr><tr><td colspan="2">JTR(Φ,0),J1R(Φ,0)←0,0 Initialize retrieval losses</td></tr><tr><td colspan="2">foriinZdo 1 Text retrieval loss</td></tr><tr><td colspan="2">JTR(Φ,0)←JTR(Φ,0)+ d(zu,Zt）+log∑ exp(-d(Zu,Ztj)) B j∈I</td></tr><tr><td colspan="2">1-B JIR(Φ,0)←JIR(Φ,0)+ d(Zui,Zti) + log∑exp(-d(Zt , Zuj))|&gt; Image retrieval loss</td></tr><tr><td colspan="2">j∈I</td></tr><tr><td colspan="2">J(,θ)←λJTR(𝜙,0)+(1-λ)JIR(Φ,0) Add retrieval loss to the total loss J(Φ,θ)←(1-κ)J(,0)+(Jrc(0)+JIc()) Add classification loss to the total loss</td></tr></table>
+
+# 2.1 RETRIEVAL LOSS FUNCTION
+
+Pairwise cross-modal loss function is based solely on the pairwise relationships between texts and images. We choose to use the metric learning approach to capture the relationship between images and texts. Now, suppose $d$ is a metric $d : \mathcal { Z } \times \mathcal { Z }  \mathbb { R } ^ { + }$ , $v _ { i }$ is an image and $\tau = \{ t _ { j ^ { \prime } } \}$ is a collection of arbitrary texts sampled uniformly at random, of which text $t _ { j }$ belongs to $v _ { i }$ . We propose the following model for the probability of image $v _ { i }$ and text $t _ { j }$ to belong to the same object instance:
+
+$$
+p _ { \phi , \theta } ( i = j | v _ { i } , t _ { j } , \tau ) = \frac { \exp ( - d ( f _ { \phi } ( v _ { i } ) , f _ { \theta } ( t _ { j } ) ) ) } { \sum _ { t _ { j ^ { \prime } } \in \tau } \exp ( - d ( f _ { \phi } ( v _ { i } ) , f _ { \theta } ( t _ { j ^ { \prime } } ) ) ) } \ .
+$$
+
+The learning is then based on the following cross-entropy loss defined on the batch of size $B$ :
+
+$$
+J _ { T R } ( \phi , \theta ) = - \frac { 1 } { B } \sum _ { i , j = 1 } ^ { B } \ell _ { i , j } \log p _ { \phi , \theta } ( i = j | v _ { i } , t _ { j } , \{ t _ { j ^ { \prime } } \} _ { j ^ { \prime } = 1 } ^ { B } ) ,
+$$
+
+where $\ell _ { i , j }$ is a binary indicator of the true match $\mathcal { \ell } _ { i , j } = 1$ , if $i = j$ and 0 otherwise). Note that the expression above has the interpretation of the text retrieval loss. It attains its smallest value when for each image in the batch we manage to assign probability 1 to its respective text and 0 to all other texts. This can be further expanded as:
+
+$$
+J _ { T R } ( \phi , \theta ) = \frac { 1 } { B } \sum _ { i = 1 } ^ { B } \left( d ( f _ { \phi } ( v _ { i } ) , f _ { \theta } ( t _ { i } ) ) + \log \Big [ \sum _ { t _ { j ^ { \prime } } \in \tau } \exp ( - d ( f _ { \phi } ( v _ { i } ) , f _ { \theta } ( t _ { j ^ { \prime } } ) ) ) \Big ] \right) .
+$$
+
+Exchanging the order of image and text in the probability model (1) leads to the image retrieval loss, $J _ { I R } ( \phi , \bar { \theta } )$ . The two losses are mixed using parameter $\lambda \in [ 0 , 1 ]$ as shown in Algorithm 1.
+
+The pairwise retrieval loss functions are responsible for the modality alignment. In addition to those, we propose to include, as mentioned above, the usual image and text classifier losses. These losses are responsible for reducing the intraclass variability of representations. The classifier losses are added to the retrieval losses using a mixing parameter $\kappa \in [ 0 , 1 ]$ as shown in Algorithm 1.
+
+# 2.2 BALANCING ACCURACY ON THE SEEN AND UNSEEN CLASSES
+
+Let us define class prototypes $\mathbf p ( y )$ , each based on the set of texts $\mathcal { T } _ { y }$ belonging to class $y$ , $\mathbf { \{ p ( }  y \mathbf { ) = }$ $\begin{array} { r } { \frac { 1 } { | T _ { y } | } \sum _ { t _ { i } \in \mathcal { T } _ { y } } f _ { \theta } ( t _ { i } ) \ | \ y \in \mathcal { V } \} } \end{array}$ . In the context of GZSL, the nearest neighbor decision rule for a given image $v$ and its features ${ \bf z } _ { v } = f _ { \phi } ( v )$ has the following form:
+
+$$
+\boldsymbol { \widehat { y } } = \arg \operatorname* { m i n } _ { \boldsymbol { y } \in \mathcal { V } } d ( \mathbf { z } _ { v } , \mathbf { p } ( \boldsymbol { y } ) ) .
+$$
+
+The most acute problem faced in this setup is the accuracy imbalance between seen and unseen classes. A very representative case clearly outlining the imbalance problem is presented in Table 6 of (Xian et al., 2018c), where accuracy on the seen classes is always significantly greater than the accuracy on unseen ones. In order to measure and control the imbalance, three metrics are commonly used to assess the classification performance in the GZSL scenario: the Top-1 accuracy on the seen categories (s), the Top-1 accuracy on the unseen categories $\mathbf { \Pi } ^ { ( \mathbf { u } ) }$ and their harmonic mean, $\mathbf { H } = \mathbf { u } \cdot \mathbf { s } / ( \mathbf { u } + \mathbf { s } )$ . The main metric to assess GZSL performance is then $\mathbf { H }$ , which quantifies both $\mathbf { u }$ and s.
+
+To formalize the problem, we first introduce $y _ { v }$ , the true class label of image $v$ . Mathematically, the main GZSL pain point is that $\mathbb { P } \{ \widehat { y } \in \mathcal { y } ^ { t r } | y _ { v } \in \mathcal { y } ^ { t s } \}$ is significantly greater than $\mathbb { P } \{ \widehat { y } \in \mathcal { y } ^ { t s } | y _ { v } \in$ $\mathcal { V } ^ { t r } \}$ b b. In other words, the problem is that a given image is more likely to be confused with one of the seen classes if it belongs to an unseen class than vice versa. Our approach to solving the problem is based on the following probabilistic representation of the event space for the decision rule in Equation (4):
+
+$$
+\mathbb { P } \{ \boldsymbol { { \widehat { y } } } \in { \mathcal { Y } } ^ { t r } | y _ { v } \in { \mathcal { Y } } ^ { t s } \} = \mathbb { P } \left\{ \operatorname* { m i n } _ { y \in { \mathcal { Y } } ^ { t r } } d ( \mathbf { z } _ { v } , \mathbf { p } ( y ) ) < \operatorname* { m i n } _ { y \in { \mathcal { Y } } ^ { t s } } d ( \mathbf { z } _ { v } , \mathbf { p } ( y ) ) \mid y _ { v } \in { \mathcal { Y } } ^ { t s } \right\} .
+$$
+
+Rephrasing, the most acute GZSL error happens when the prototype of one of the seen classes is closer to an image embedding from an unseen class than any of the prototypes of the unseen classes.
+
+To rectify the situation we propose the following very direct solution to balance $\mathbb { P } \{ \widehat { y } \in \mathcal { y } ^ { t r } | y _ { v } \in \mathcal { y } ^ { t s } \}$ and $\mathbb { P } \{ \hat { \mathcal { Y } } \in \mathcal { Y } ^ { t s } | y _ { v } \in \mathcal { Y } ^ { t \bar { r } } \}$ . We introduce a positive scalar $\alpha \in \mathbb { R } ^ { + }$ band scale all the distances bcorresponding to the seen prototypes by $1 + \alpha$ . This gives rise to the following scaled distance $d _ { \alpha }$ :
+
+$$
+d _ { \alpha } ( \mathbf { z } _ { v } , \mathbf { p } ( y ) ) = \left\{ \begin{array} { l l } { ( 1 + \alpha ) d ( \mathbf { z } _ { v } , \mathbf { p } ( y ) ) , } & { \mathrm { i f ~ } y \in \mathcal { Y } ^ { t r } } \\ { d ( \mathbf { z } _ { v } , \mathbf { p } ( y ) ) , } & { \mathrm { o t h e r w i s e } } \end{array} \right. .
+$$
+
+The misclassification between unseen as seen classes for the classifier $\widehat { y } _ { \alpha }$ , based on (6) is then:
+
+$$
+\mathbb { P } \{ \widehat { y } _ { \alpha } \in \mathcal { Y } ^ { t r } | y _ { v } \in \mathcal { Y } ^ { t s } \} = \mathbb { P } \left\{ \left( 1 + \alpha \right) \operatorname* { m i n } _ { y \in \mathcal { Y } ^ { t r } } d ( \mathbf { z } _ { v } , \mathbf { p } ( y ) ) < \operatorname* { m i n } _ { y \in \mathcal { Y } ^ { t s } } d ( \mathbf { z } _ { v } , \mathbf { p } ( y ) ) | y _ { v } \in \mathcal { Y } ^ { t s } \right\} \ ,
+$$
+
+and it has the following property: for any $0 \leq \alpha _ { 1 } \leq \alpha _ { 2 }$ , $\mathbb { P } \{ \widehat { y } _ { \alpha _ { 1 } } ~ \in ~ \mathcal { Y } ^ { t r } | y _ { v } ~ \in ~ \mathcal { Y } ^ { t s } \} ~ \geq ~ \mathbb { P } \{ \widehat { y } _ { \alpha _ { 2 } } ~ \in ~$ $\mathcal { V } ^ { t r } | y _ { v } \in \mathcal { V } ^ { t s } \}$ , i.e. $\mathbb { P } \{ \widehat { y } _ { \alpha } \in \mathcal { V } ^ { t \bar { r } } | y _ { v } \in \mathcal { V } ^ { t s } \}$ b   is a monotone non-increasing function of $\alpha$ b and we bcan reduce it by increasing $\alpha$ (please refer to Appendix A for a proof). Consider now $\mathbb { P } \{ \widehat { y } _ { \alpha } \in$ $\mathcal { V } ^ { t r } | y _ { v } \in \mathcal { V } ^ { t r } \big \}$ , which is a probability that we classify an image $v$ bfrom one of the seen classes as still one of the seen classes. Using exactly the same chain of arguments as in Appendix A, it is straightforward to show that the probability is a non-increasing function of $\alpha$ . Hence the probability $\mathbb { P } \{ \hat { y } _ { \alpha } ^ { \sim } \in \mathcal { V } ^ { t s } | y _ { v } \in \mathcal { V } ^ { t r } \} = 1 - \mathbb { P } \{ \hat { y } _ { \alpha } \in \mathcal { V } ^ { \hat { t r } } | y _ { v } \in \mathcal { V } ^ { t r } \}$ is a non-decreasing function of $\alpha$ . Therefore, as $\alpha$ increases, we expect more classification errors in classifying images from seen classes, because some of them will be classified as one of the unseen classes.
+
+To sum up, given the arguments presented above we expect that by varying $\alpha > 0$ we can balance the error rate $\mathbb { P } \mathbf { \bar { \{ y _ { \alpha } \in \mathcal { V } ^ { t r } \vert y _ { v } \in \mathcal { V } ^ { t s } \} } }$ of leaking the unseen class images into seen class classification bdecision and the error rate $\mathbb { P } \{ \widehat { y } _ { \alpha } ^ { } \in \mathcal { V } ^ { t s } | y _ { v } ^ { - } \in \mathcal { V } ^ { t r } \}$ of leaking the seen class images into unseen bclass classification decision. This is possible as we just showed above that $\mathbb { P } \{ \widehat { y } _ { \alpha } \in \mathcal { V } ^ { t r } | y _ { v } \in \mathcal { V } ^ { t s } \}$ is a non-increasing function of $\alpha$ , while $\mathbb { P } \{ \widehat { y } _ { \alpha } \in \mathcal { V } ^ { t s } | y _ { v } \in \mathcal { V } ^ { t r } \}$ b is a non-decreasing one. It is also important to emphasize that $\alpha$ bis applied only to distances between the query embedding and the prototypes of seen classes and it is constant over seen classes. Therefore, the application of $\alpha$ does not at all affect the classification error rates either within $\mathcal { V } ^ { t r }$ or within $\mathcal { V } ^ { t s }$ . Varying $\alpha$ balances exclusively the classification errors arising from transitions between seen and unseen class labels. We study the empirical aspects of balancing $\alpha$ in Section 4.4.
+
+Table 1: Generalized zero-shot Top-1 classification accuracy.   
+
+<table><tr><td></td><td colspan="3">CUB</td><td colspan="3">FLOWERS</td></tr><tr><td></td><td>u</td><td>S</td><td>H</td><td>u</td><td>s</td><td>H</td></tr><tr><td>CADA-VAE (Schönfeld et al., 2019)</td><td>n/a</td><td>n/a</td><td>53.4</td><td>n/a</td><td>n/a</td><td>n/a</td></tr><tr><td>f-CLSWGAN (Xian et al., 2018d)</td><td>50.3</td><td>58.3</td><td>54.0</td><td>59.0</td><td>73.8</td><td>65.6</td></tr><tr><td>f-VAEGAN-D2 (Xian et al.,2019)</td><td>48.4</td><td>60.1</td><td>53.6</td><td>56.8</td><td>74.9</td><td>64.6</td></tr><tr><td>cycle-(U)WGAN (Felix et al., 2018)</td><td>47.9</td><td>59.3</td><td>53.0</td><td>61.6</td><td>69.2</td><td>65.2</td></tr><tr><td>COSMO+f-CLSWGAN (Atzmon &amp; Chechik, 2019)</td><td>n/a</td><td>n/a</td><td>n/a</td><td>59.6</td><td>81.4</td><td>68.8</td></tr><tr><td>CLAREL (Ours)</td><td>59.3</td><td>52.6</td><td>55.8</td><td>73.0</td><td>73.6</td><td>73.3</td></tr></table>
+
+Table 2: Zero-shot Top-1 classification accuracy.   
+
+<table><tr><td></td><td>CUB</td><td>FLOWERS</td></tr><tr><td>CADA-VAE (Schonfeld et al., 2019)</td><td>n/a</td><td>n/a</td></tr><tr><td>f-CLSWGAN (Xian et al., 2018d)</td><td>57.3</td><td>67.2</td></tr><tr><td>f-VAEGAN-D2 (Xian et al., 2019)</td><td>61.0</td><td>67.7</td></tr><tr><td>cycle-(U)WGAN (Felix et al., 2018)</td><td>58.6</td><td>70.3</td></tr><tr><td>CLAREL (Ours)</td><td>66.7</td><td>76.8</td></tr></table>
+
+# 3 RELATED WORK
+
+ZSL approaches aim at recognizing objects belonging to classes unseen during training (Larochelle et al., 2008; Palatucci et al., 2009). This has been extended to the GZSL framework in which the decision space consists of both seen and unseen classes (Socher et al., 2013; Xian et al., 2018c). The classical zero-shot approaches build a joint visual-semantic space, relying on a linear cross-modal compatibility function (e.g. dot-product between query embedding and semantic prototypes or a variation of a hinge loss) (Frome et al., 2013; Akata et al., 2015; 2016; Reed et al., 2016). Non-linear variants of the compatibility has also been explored (Xian et al., 2016; Socher et al., 2013). Extending previously proposed cross-modal transfer approaches based on auto-encoders (Hubert Tsai et al., 2017) and cross-domain learning (Gretton et al., 2007), more recent line of work (Schönfeld et al., 2019; Xian et al., 2018d; 2019; Felix et al., 2018; Verma et al., 2018) relies on combining these approaches and their variations with dataset augmentation tools such as GAN (Goodfellow et al., 2014) and VAE (Kingma & Welling, 2014). It is argued that the use of those tools helps to resolve one of the prominent problems in GZSL scenario: classifying images from unseen classes as one of the seen classes. There exist approaches that try to tackle this same problem via temperature calibration (Liu et al., 2018) originally proposed by Hinton et al. (2015). Chao et al. (2016); Das & Lee (2019) proposed an approach to seen/unseen accuracy balancing that is very similar to ours, based on heuristic arguments. We extend this line of work here by providing a probabilistic justification for the balancing effect observed when applying metric rescaling. Atzmon & Chechik (2019) propose a more sophisticated way to deal with seen/unseen imbalance via adaptive confidence smoothing and gating, yet as authors note it is much simpler to train than the existing GAN-based zero-shot approaches. In this work, we introduce arguably the simplest zero-shot representation training approach of all, and we demonstrate that when the image level text information is available, it achieves the state-of-the-art results on GZSL task on two well-known datasets.
+
+# 4 EXPERIMENTAL RESULTS
+
+# 4.1 DATASETS
+
+We focus on learning embeddings for fine-grained visual descriptions and test them in ZSL/GZSL scenario. To test the quality of trained embeddings we focus on datasets that provide paired images and text descriptions, such as Caltech-UCSD-Birds (CUB) (Welinder et al., 2010) and Oxford Flowers (FLOWERS) (Nilsback & Zisserman, 2008), that were augmented with textual descriptions by Reed et al. (2016). We use the GZSL splits proposed by Xian et al. (2018c). The attribute-based datasets, such as SUN (Patterson et al., 2014) and AWA (Lampert et al., 2014) do not contain this information and do not have a notion of entity of a class in them. They are out of the scope of the current paper.
+
+![](images/6c68eb4c7e42a907d13836d18bd23fbf8d9cba1c7819eebd0cbae1133409eec9.jpg)  
+Figure 2: Harmonic mean Top-1 accuracy on seen and unseen, $\mathbf { H }$ , against the value of $\alpha$ on the validation set. The curves represent the mean and $9 5 \%$ confidence intervals over 10 optimization runs. Results are stable over different runs. $\mathbf { H }$ exhibits a distinct inverted U-shape w.r.t. $\alpha$ .
+
+# 4.2 ARCHITECTURE AND TRAINING DETAILS
+
+Below, we provide more detailed description of parameters used to build and train the architecture depicted in Figure 1. We use exactly the same hyperparameter settings for CUB and FLOWERS. The text feature extractor is built by cascading two ResNet blocks, followed by a BiLSTM. Each ResNet block has 3 convolutional/batch norm layers. The number of filters in the ResNet blocks is 128 and 256, BiLSTM has 512 filters for forward and backward branches (1024 total). All variables in the convolutional stack (including the batch normalization parameters $\gamma$ and $\beta$ ) are L2-penalized with weight 0.001. The image feature extractor is a ResNet-101 with fixed weights pretrained on the split of ImageNet proposed by Xian et al. (2018c). In this work we use precomputed image features, available in (Xian et al., 2018a) for CUB and in (Xian et al., 2018b) for FLOWERS. Image and text features are projected in the common embedding space of size 1024 with FC layers with no non-linearity. They are preceded with a dropout of 0.25. The trainable components of the model are trained for $1 5 0 \mathrm { k }$ batches of size 32 using SGD with initial learning rate of 0.1 that is annealed by a factor of 10 every $5 0 \mathrm { k }$ batches. For each batch, we sample 32 instances, each instance includes a vector of precomputed ResNet-101 features and 10 text descriptions corresponding to it, according to the original dataset definition Reed et al. (2016). All 10 text descriptions are processed via the CNN/LSTM stack and the resulting embeddings are average pooled to create a vector representation of length 1024.
+
+# 4.3 KEY RESULTS
+
+Our key empirical results are compared in Table 1 and in Table 2 against the latest state of the art. Our results are based on the settings of $\lambda = 0 . 5$ , $\kappa = 0 . 5$ and $\alpha$ selected on the validation sets of CUB and FLOWERS datasets. Please refer to Section 4.5 for the analysis of stability with respect to the choices of $\lambda$ and $\kappa$ and Sections 2.2 and 4.4 for more details on the selection of $\alpha$ . The combination of the proposed training method and the rebalancing of the metric space results in the state-of-the-art performance. Most of the current methods rely on the dataset augmentation techniques based on GANs, VAEs or combinations thereof. Those are clearly complementary w.r.t. our method and their addition to the training procedure is likely to further boost the performance of our proposed approach. However, this is outside of the scope of the current work. Moreover, the proposed method is state-of-the-art on FLOWERS even when compared against (Atzmon & Chechik, 2019) that uses both more sophisticated GAN based embedding learning approach and a more sophisticated seen/unseen error rate balancing based on COSMO. It is important to note that Atzmon & Chechik (2019) did not report the sentence level results on CUB. Yet, when applied on attributes together with f-CLSWGAN (Xian et al., 2018d) COSMO resulted in $0 . 8 \%$ performance drop and when applied with LAGO (Atzmon & Chechik, 2018) it achieved $0 . 5 \%$ improvement over the attribute based state of the art.
+
+![](images/3f384a4e76f0bc5c58077471f4b2954c58239b2f85fada1da5ff845d8c8bbbae.jpg)  
+Figure 3: Harmonic mean Top-1 accuracy on seen and unseen, H, against $\lambda$ , the relative weight of image and text retrieval loss terms. $\lambda = 0$ corresponds to the case of image retrieval loss having weight 1 and text retrieval loss having weight 0. Mean over 10 optimization runs.
+
+![](images/a157ed151bbb217f07fbd4f1af909679c63192783007d447465bf462d40594e9.jpg)  
+Figure 4: The plot of the harmonic mean Top-1 accuracy on seen and unseen, $\mathbf { H }$ , against $\kappa$ , the relative weight of the retrieval and the classification loss terms. $\kappa = 0$ corresponds to the case of classification loss having weight 0. The curves represent the mean over 10 optimization runs.
+
+# 4.4 ON THE SEEN/UNSEEN ACCURACY BALANCING
+
+Figure 2 demonstrates the plot of harmonic mean Top-1 accuracy, $\mathbf { H }$ , against the value of $\alpha$ on the validation sets of CUB and FLOWERS datasets. The validation set is constructed by further splitting the train set on both datasets. For example, CUB has a train set of 5875 images from 100 seen classes and a validation set of 2946 images from 50 unseen classes. We further divide the train set into 4700 train images from 100 seen classes, 1175 seen validation images $( 4 7 0 0 + 1 1 7 5 = 5 8 7 5 )$ and we use all the 2946 images from 50 classes as the unseen validation set. Once the value of $\alpha$ is determined we train the representation on the full train $^ +$ val subset and report results on the test split (the usual practice in GZSL). We confirm on the validation set that H exhibits an inverted U-shape behavior as a function of $\alpha$ , which was theoretically predicted in Section 2.2. Therefore, $\alpha$ can be selected on the validation set and then applied to re-scale the metric space to balance the accuracy on seen and unseen classes during test time as described in Section 2.2.
+
+# 4.5 ABLATION STUDY
+
+Figure 3 presents the results of the ablation study on the importance of image and text retrieval losses. We see that all of the Top-1 accuracies $( \mathbf { H } , \mathbf { s } , \mathbf { u } )$ are stable in the range of $\lambda \in [ 0 . 2 , 0 . 9 ]$ , when both losses have tangible weight. Removing either text or image retrieval losses (setting $\lambda$ to 0 or 1 respectively) leads to performance drop in both cases. Removing the text retrieval loss (case $\lambda = 0$ ) results in the most significant drop. This is due to the fact that the text retrieval task is more tightly related to the GZSL task. At the batch level, retrieving the right text given an image is equivalent to identifying the correct class encoded by a text prototype during ZSL inference step. The image retrieval task is not directly related to solving the ZSL problem and yet it does yield a positive regularizing effect on both CUB and FLOWERS.
+
+Figure 4 shows the results of the ablation study of the interplay between the retrieval loss and the classification loss. We observe, just as in the case with $\lambda$ , that there exists a reasonably flat and stable range of $\kappa \in [ 0 . 2 , 0 . 6 ]$ . The range for $\kappa$ is a bit smaller. $\kappa = 1$ results in the catastrophic performance drop: the classification losses by themselves do not enforce any modality alignment (please refer to Fig. 1 and Algorithm 1 clearly demonstrating this).
+
+Table 3: Generalized zero-shot Top-1 classification accuracy, ablation study.   
+
+<table><tr><td></td><td></td><td></td><td></td><td>CUB</td><td></td><td colspan="3">FLOWERS</td></tr><tr><td>α</td><td>入</td><td>K</td><td>u</td><td>S</td><td>H</td><td>u</td><td>s</td><td>H</td></tr><tr><td>0.0</td><td>0.5</td><td>0.5</td><td>38.3</td><td>65.3</td><td>48.3</td><td>55.1</td><td>84.6</td><td>66.7</td></tr><tr><td>0.0</td><td>0.5</td><td>0.0</td><td>39.3</td><td>57.5</td><td>46.7</td><td>54.0</td><td>78.1</td><td>63.8</td></tr><tr><td>√</td><td>0.5</td><td>0.0</td><td>53.8</td><td>49.6</td><td>51.6</td><td>71.7</td><td>67.2</td><td>69.4</td></tr><tr><td>√</td><td>0.0</td><td>0.5</td><td>47.4</td><td>36.6</td><td>41.3</td><td>51.5</td><td>60.5</td><td>55.6</td></tr><tr><td>√</td><td>1.0</td><td>0.5</td><td>53.9</td><td>53.8</td><td>53.8</td><td>69.5</td><td>73.9</td><td>71.6</td></tr><tr><td>厂</td><td>0.5</td><td>0.5</td><td>59.3</td><td>52.6</td><td>55.8</td><td>73.0</td><td>73.6</td><td>73.3</td></tr></table>
+
+Table 3 studies the effects of different loss terms on the harmonic mean Top-1 accuracy H. The best result is achieved when all loss terms are active and when the metric space rescaling is on (the case of $\lambda = 0 . 5$ , $\kappa = 0 . 5$ and $\alpha$ is checked, the last line in the table). Comparing this with the case when there is no metric space rescaling (first line with $\alpha = 0$ ), we see that the rescaling helps to decrease the gap between seen and unseen classification accuracy. For CUB, the discrepancy reduction is from around $30 \%$ to around $6 \%$ , for FLOWERS it is from around $30 \%$ to around $1 \%$ . We would like to stress that we only use images and texts from the training set to achieve that. Going to the second line in the table (the image/text classification loss is inactive, $\kappa = 0$ ) and comparing it to the first one, we assess the effect of the image/text classification loss. It barely affects the performance on unseen set, but it significantly boosts the classification accuracy on the seen set (around $8 \%$ on both datasets). This is logical: adding a classifier loss results in a better classifier of the test images from the seen classes. This alone does not make it a better GZSL classifier, however. Only when applied together with metric space rescaling, this results in the performance boost (please refer to lines 1 and 6 in Table 3). Our interpretation is that the addition of the image/text classifier loss helps to reduce the intraclass variability in embeddings and provides for tighter clustering. However, this also leads to overfit on the classification task. This is accounted for by metric rescaling that enables the learnings from the image/text classification task be transferred effectively into the GZSL task.
+
+The comparison of the last four rows of Table 3 leads us to believe that all the proposed loss terms outlined in Fig. 1 and Algorithm 1 are important for achieving the state-of-the-art performance. Excluding any one of them (corresponding to the extreme values $\lambda = 0$ , $\lambda = 1$ , $\kappa = 0$ ) leads to performance deterioration. Finally, an interesting observation can be made by comparing line 3 of Table 3 with performance of algorithms in Table 1. In this case our algorithm does not use any class labels and relies on training using exclusively the retrieval losses that can be calculated only based on the pairwise relationships between texts and images. We can see that using this type of supervision alone already results in a very high-quality representation. The representation is competitive against the latest GAN/VAE based approaches on CUB and is state-of-the-art on FLOWERS. This opens up new exploration avenues showing that in the case when very fine-grained modality outputs are available (image and text description pairs being a very prominent example), the high-quality representations may be learned without relying on manually supplied class labels.
+
+# 5 CONCLUSIONS
+
+We propose and empirically validate two improvements to the process of learning fine-grained crossmodal representations. First, we confirm the hypothesis that in the context of paired images and texts, a deep metric learning approach can be driven by an instance-based retrieval loss resulting in competitive generalized zero shot classification results. Combined with an additional class label based image/text crossentropy term this results in state-of-the-art performance on two well known datasets, CUB and FLOWERS. This is an interesting result demonstrating that high-quality deep representations can be trained relying largely on pairwise relationships between modalities. On top of that, we propose a solution to one of the prominent problems in GZSL: classifying instances of unseen classes as seen ones. We mathematically analyze and empirically validate the method of adjusting a single scalar that transcends in its effectiveness advanced dataset augmentation and training approaches based on GANs and VAEs.
+
+# REFERENCES
+
+Zeynep Akata, Scott Reed, Daniel Walter, Honglak Lee, and Bernt Schiele. Evaluation of output embeddings for fine-grained image classification. In CVPR, 2015.
+
+Zeynep Akata, Florent Perronnin, Zaid Harchaoui, and Cordelia Schmid. Label-embedding for image classification. TPAMI, 2016.
+
+Yuval Atzmon and Gal Chechik. Probabilistic AND-OR attribute grouping for zero-shot learning. In UAI, 2018.
+
+Yuval Atzmon and Gal Chechik. Adaptive confidence smoothing for generalized zero-shot learning. In CVPR, 2019.
+
+Wei-Lun Chao, Soravit Changpinyo, Boqing Gong, and Fei Sha. An empirical study and analysis of generalized zero-shot learning for object recognition in the wild. In ECCV (2), pp. 52–68, 2016.
+
+Debasmit Das and C Lee. Zero-shot image recognition using relational matching, adaptation and calibration. In International Joint Conference on Neural Networks, 2019.
+
+Rafael Felix, Vijay Kumar B G, Ian Reid, and Gustavo Carneiro. Multi-modal cycle-consistent generalized zero-shot learning. In ECCV, 2018.
+
+Andrea Frome, Greg S Corrado, Jon Shlens, Samy Bengio, Jeff Dean, Marc Aurelio Ranzato, and Tomas Mikolov. DeViSE: A deep visual-semantic embedding model. In NIPS, pp. 2121–2129, 2013.
+
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In NIPS, pp. 2672–2680, 2014.
+
+Arthur Gretton, Karsten M Borgwardt, Malte Rasch, Bernhard Schölkopf, and Alex J Smola. A kernel method for the two-sample-problem. In NIPS, 2007.
+
+Geoffrey Hinton, Oriol Vinyals, and Jeffrey Dean. Distilling the knowledge in a neural network. In NIPS Workshop, 2015.
+
+Yao-Hung Hubert Tsai, Liang-Kang Huang, and Ruslan Salakhutdinov. Learning robust visualsemantic embeddings. In CVPR, 2017.
+
+Diederik P. Kingma and Max Welling. Auto-encoding variational bayes. In ICLR, 2014.
+
+C. H. Lampert, H. Nickisch, and S. Harmeling. Attribute-based classification for zero-shot visual object categorization. TPAMI, 2014.
+
+Hugo Larochelle, Dumitru Erhan, and Yoshua Bengio. Zero-data learning of new tasks. In AAAI, 2008.
+
+Yann LeCun, Yoshua Bengio, and Geoffrey Hinton. Deep learning. Nature, 2015.
+
+Shichen Liu, Mingsheng Long, Jianmin Wang, and Michael I Jordan. Generalized zero-shot learning with deep calibration network. In NIPS, 2018.
+
+M. Nilsback and A. Zisserman. Automated flower classification over a large number of classes. In 2008 Sixth Indian Conference on Computer Vision, Graphics Image Processing, 2008.
+
+Mark Palatucci, Dean Pomerleau, Geoffrey E Hinton, and Tom M Mitchell. Zero-shot learning with semantic output codes. In NIPS, 2009.
+
+Genevieve Patterson, Chen Xu, Hang Su, and James Hays. The sun attribute database: Beyond categories for deeper scene understanding. IJCV, 2014.
+
+Scott E. Reed, Zeynep Akata, Honglak Lee, and Bernt Schiele. Learning deep representations of fine-grained visual descriptions. In CVPR, 2016.
+
+Edgar Schönfeld, Sayna Ebrahimi, Samarth Sinha, Trevor Darrell, and Zeynep Akata. Generalized zero-and few-shot learning via aligned variational autoencoders. CVPR, 2019.
+
+Richard Socher, Milind Ganjoo, Christopher D Manning, and Andrew Ng. Zero-shot learning through cross-modal transfer. In NIPS, 2013.   
+Vinay Kumar Verma, Gundeep Arora, Ashish Mishra, and Piyush Rai. Generalized zero-shot learning via synthesized examples. In CVPR, 2018.   
+Wei Wang, Vincent W. Zheng, Han Yu, and Chunyan Miao. A survey of zero-shot learning: Settings, methods, and applications. ACM Trans. Intell. Syst. Technol., 2019.   
+Yaqing Wang and Quanming Yao. Few-shot learning: A survey. In arXiv, 2019.   
+P. Welinder, S. Branson, T. Mita, C. Wah, F. Schroff, S. Belongie, and P. Perona. Caltech-UCSD Birds 200. Technical report, California Institute of Technology, 2010.   
+Yongqin Xian, Zeynep Akata, Gaurav Sharma, Quynh N. Nguyen, Matthias Hein, and Bernt Schiele. Latent embeddings for zero-shot classification. In CVPR, 2016.   
+Yongqin Xian, Christoph H. Lampert, Bernt Schiele, and Zeynep Akata. Pretrained CUB features, 2018a. URL http://datasets.d2.mpi-inf.mpg.de/xian/xlsa17.zip.   
+Yongqin Xian, Christoph H. Lampert, Bernt Schiele, and Zeynep Akata. Pretrained FLOWERS features, 2018b. URL http://datasets.d2.mpi-inf.mpg.de/xian/cvpr18xian. zip.   
+Yongqin Xian, H. Christoph Lampert, Bernt Schiele, and Zeynep Akata. Zero-shot learning: A comprehensive evaluation of the good, the bad and the ugly. TPAMI, 2018c.   
+Yongqin Xian, Tobias Lorenz, Bernt Schiele, and Zeynep Akata. Feature generating networks for zero-shot learning. In CVPR, 2018d.   
+Yongqin Xian, Saurabh Sharma, Bernt Schiele, and Zeynep Akata. f-vaegan-d2: A feature generating framework for any-shot learning. CVPR, 2019.   
+H. Zhang, T. Xu, H. Li, S. Zhang, X. Wang, X. Huang, and D. N. Metaxas. StackGAN $^ { + + }$ : Realistic image synthesis with stacked generative adversarial networks. PAMI, 2018.
+
+# A THE ANALYSIS OF ERROR RATES
+
+We show that $\mathbb { P } \{ \widehat { y } ~ \in ~ \mathcal { Y } ^ { t r } | y _ { v } ~ \in ~ \mathcal { Y } ^ { t s } \} ~ \geq ~ \mathbb { P } \{ \widehat { y } _ { \alpha } ~ \in ~ \mathcal { Y } ^ { t r } | y _ { v } ~ \in ~ \mathcal { Y } ^ { t s } \}$ . Let us define $\delta _ { t r } \equiv$ $\begin{array} { r } { \operatorname* { m i n } _ { y \in \mathcal { y } ^ { t r } } d ( \mathbf { z } _ { v } , \mathbf { p } ( y ) ) } \end{array}$ and $\begin{array} { r } { \delta _ { t s } \equiv \operatorname* { m i n } _ { y \in \mathcal { V } ^ { t s } } d ( \mathbf { z } _ { v } , \mathbf { p } ( y ) ) } \end{array}$ , then Equation (7) can be rewritten as:
+
+$$
+\mathbb { P } \{ \widehat { y } _ { \alpha } \in \mathcal { V } ^ { t r } | y _ { v } \in \mathcal { V } ^ { t s } \} = \mathbb { P } \left\{ ( 1 + \alpha ) \delta _ { t r } < \delta _ { t s } | y _ { v } \in \mathcal { V } ^ { t s } \right\} \mathrm { ~ . ~ }
+$$
+
+Let us consider the probability of event $\delta _ { t r } < \delta _ { t s }$ and decompose it as follows:
+
+$$
+\begin{array} { r l } & { \mathbb { P } \left\{ \delta _ { t r } < \delta _ { t s } \middle | y _ { v } \in \mathcal { Y } ^ { t s } \right\} = \mathbb { P } \left\{ ( 1 + \alpha ) \delta _ { t r } < ( 1 + \alpha ) \delta _ { t s } | y _ { v } \in \mathcal { Y } ^ { t s } \right\} } \\ & { = \mathbb { P } \left\{ ( 1 + \alpha ) \delta _ { t r } < \delta _ { t s } \cup \delta _ { t s } \leq ( 1 + \alpha ) \delta _ { t r } < ( 1 + \alpha ) \delta _ { t s } | y _ { v } \in \mathcal { Y } ^ { t s } \right\} } \\ & { = \mathbb { P } \left\{ ( 1 + \alpha ) \delta _ { t r } < \delta _ { t s } | y _ { v } \in \mathcal { Y } ^ { t s } \right\} + \mathbb { P } \left\{ \delta _ { t s } \leq ( 1 + \alpha ) \delta _ { t r } < ( 1 + \alpha ) \delta _ { t s } | y _ { v } \in \mathcal { Y } ^ { t s } \right\} } \\ & { - \mathbb { P } \left\{ ( 1 + \alpha ) \delta _ { t r } < \delta _ { t s } \cap \delta _ { t s } \leq ( 1 + \alpha ) \delta _ { t r } < ( 1 + \alpha ) \delta _ { t s } | y _ { v } \in \mathcal { Y } ^ { t s } \right\} } \\ & { = \mathbb { P } \left\{ ( 1 + \alpha ) \delta _ { t r } < \delta _ { t s } | y _ { v } \in \mathcal { Y } ^ { t s } \right\} + \mathbb { P } \left\{ \delta _ { t s } \leq ( 1 + \alpha ) \delta _ { t r } < ( 1 + \alpha ) \delta _ { t s } | y _ { v } \in \mathcal { Y } ^ { t s } \right\} } \end{array}
+$$
+
+The transitions are based on the relationship between probabilities of arbitrary events $A$ and $B$ , $\mathbb { P } \{ A \cup B \} = \mathbb { P } \{ A \} + \mathbb { P } \{ B \} - \mathbb { P } \{ A \cap B \}$ , and in our case ${ \mathbb { P } } \{ A \cap B \} = 0$ . This implies that:
+
+$$
+\begin{array} { r l r } {  { \mathbb { P } \{ \widehat { y } _ { \alpha } \in \mathcal { Y } ^ { t r } | y _ { v } \in \mathcal { Y } ^ { t s } \} = \mathbb { P } \{ \widehat { y } \in \mathcal { Y } ^ { t r } | y _ { v } \in \mathcal { Y } ^ { t s } \} - \mathbb { P } \{ \frac { \delta _ { t s } } { ( 1 + \alpha ) } \leq \delta _ { t r } < \delta _ { t s } | y _ { v } \in \mathcal { Y } ^ { t s } \} } } \\ & { } & { \leq \mathbb { P } \{ \widehat { y } \in \mathcal { Y } ^ { t r } | y _ { v } \in \mathcal { Y } ^ { t s } \} . } \end{array}
+$$
+
+We have just shown that for a non-negative $\alpha$ the probability of misclassifying an image from an unseen class as one of the seen classes is smaller for the decision rule $\widehat { y } _ { \alpha }$ than for the original decision rule $\widehat { y }$ . In fact, we can make a stronger claim. Since $\delta _ { t s }$ and $\delta _ { t r }$ are non-negative, it is bclear that the length of interval $[ \delta _ { t s } / ( 1 + \alpha ) , \delta _ { t s } \overline { { ) } }$ increases as $\alpha$ increases, and hence probability that $\delta _ { t r }$ falls in this interval is non-decreasing with increasing $\alpha$ . Thus we have for any $0 \leq \alpha _ { 1 } \leq \alpha _ { 2 }$ , $\mathbb { P } \{ \widehat { y } _ { \alpha _ { 1 } } \in \mathcal { Y } ^ { t r } | y _ { v } \in \mathcal { Y } ^ { t s } \} \geq \mathbb { P } \{ \widehat { y } _ { \alpha _ { 2 } } \in \mathcal { Y } ^ { \bar { t } r } | y _ { v } \in \mathcal { Y } ^ { t s } \}$ , i.e. $\mathbb { P } \{ \widehat { y } _ { \alpha } \in \mathcal { V } ^ { t r } | y _ { v } \in \mathcal { V } ^ { t s } \}$ is a monotone bnon-increasing function of $\alpha$ b band we can reduce it by increasing $\alpha$ .

parse/train/SJl3h2EYvS/SJl3h2EYvS_content_list.json

@@ -0,0 +1,1106 @@
+[
+    {
+        "type": "text",
+        "text": "CLAREL: CLASSIFICATION VIA RETRIEVAL LOSS FOR ZERO-SHOT LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            99,
+            823,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            170,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We address the problem of learning fine-grained cross-modal representations. We propose an instance-based deep metric learning approach in joint visual and textual space. The key novelty of this paper is that it shows that using per-image semantic supervision leads to substantial improvement in zero-shot performance over using class-only supervision. On top of that, we provide a probabilistic justification for a metric rescaling approach that solves a very common problem in the generalized zero-shot learning setting, i.e., classifying test images from unseen classes as one of the classes seen during training. We evaluate our approach on two finegrained zero-shot learning datasets: CUB and FLOWERS. We find that on the generalized zero-shot classification task CLAREL consistently outperforms the existing approaches on both datasets. ",
+        "bbox": [
+            233,
+            268,
+            766,
+            421
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            453,
+            336,
+            469
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep learning-based approaches have demonstrated superior flexibility and generalization capabilities in information processing on a wide variety of tasks, such as vision, speech and language (LeCun et al., 2015). However, it has been widely realized that the transfer of deep representations to real-world applications is challenging due to the typical reliance on massive hand-labeled datasets. Learning in the low-labeled data regime, especially in the zero-shot (Wang et al., 2019) and the few-shot (Wang & Yao, 2019) setups, have recently received significant attention in the literature. In the problem of zero-shot learning (ZSL), the objective is to recognize categories that have not been seen during the training (Larochelle et al., 2008). This is typically done by relying on anchor embeddings learned in one modality as prototypes and by associating a query embedding from the other modality with the closest prototype. In the generalized ZSL (GZSL) case (Xian et al., 2018c), the objective is more challenging as recognition is performed in the joint space of seen and unseen categories. ZSL, as well as its generalized counterpart, provide a viable framework to learn cross-modal representations that are flexible and adaptive. For example, in this paradigm, the adaptation to a new classification task based on text/image representation space alignment could be as easy as defining/appending/modifying a set of text sentences to define classes of new classifiers. This is an especially relevant problem as machine learning is challenged with the long tail of classes, and the idea of learning from pairs of images and sentences, abundant on the web, looks like a natural solution. Therefore, in this paper we specifically target the fine-grained scenario of paired images and their respective text descriptions. The uniqueness of this scenario is in the fact that the co-occurance of image and text provides a rich source of information. The ways of leveraging this source have not been sufficiently explored in the context of GZSL. Although we focus exclusively on the GZSL recognition setup in this paper, we believe that the research in this direction has potential to enable zero-shot flexibility in a wider array of high-level tasks such as segmentation or conditional image generation (Zhang et al., 2018). The contributions of this work can be characterized under the following two themes. ",
+        "bbox": [
+            174,
+            487,
+            825,
+            819
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Instance-based training loss. Most prominent zero-shot learning approaches rely heavily on classlevel modality alignment (Xian et al., 2018c). We propose a new composite loss function that balances instance-based pairwise image/text retrieval loss and the usual classifier loss. The retrieval loss term does not use class labels. We demonstrate that the class-level information is important, but in the fine-grained text/image pairing scenarios, most of the GZSL accuracy can be extracted from the instance-based retrieval loss. To the best of our knowledge, this type of training has not been used in the GZSL literature. Its impressive performance opens up new promising research directions. ",
+        "bbox": [
+            174,
+            827,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/c5306e54b7867e3eb7aee45c6499213721005da29ec547a7ed5a3a76968503c1.jpg",
+        "image_caption": [
+            "Figure 1: The architecture and training diagram describing the proposed method. Each batch consists of randomly sampled instances, i.e. pairs of images and their corresponding texts. Images are embedded via ResNet and texts are embedded via a CNN/LSTM stack. Image and text features are projected via a fully connected layer into the same dimensional space. In this space, distances between text and image features from different instances are computed. The negative distances are fed into softmax to train on both the image and the text retrieval tasks. The image retrieval task consists of retrieving the image corresponding to the given text of the same instance and the text retrieval task is vice versa. In addition to that, image and text embeddings are trained on auxiliary image and text classification tasks on the class labels corresponding to instances. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            250,
+            98,
+            753,
+            291
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Metric space rescaling. Metric-based ZSL approaches rely on distances between prototypes and query embeddings during inference. They are known to suffer from imbalanced performance on seen and unseen classes (Liu et al., 2018). Previous work proposed to use a heuristic trick, calibrated stacking (Chao et al., 2016) or calibration (Das & Lee, 2019), to solve the problem. We refer to this technique as metric rescaling in our work, and provide a sound probabilistic justification for it. ",
+        "bbox": [
+            174,
+            457,
+            825,
+            527
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 PROPOSED METHOD ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            549,
+            375,
+            565
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we specifically target the fine-grained visual description scenario, as defined by Reed et al. (2016). In this setting, the dataset consists of a number of images from a given set of classes and each image is accompanied by a number of textual descriptions. The task is to learn a joint representation space for images and texts that can be used for zero-shot recognition. An instance of the zero-shot multimodal representation learning problem can then be defined as follows. Given a training set $S = \\{ ( v _ { n } , t _ { n } , y _ { n } ) \\mid v _ { n } \\in \\mathcal { V }$ , $t _ { n } \\in \\mathcal { T } , y _ { n } \\in \\mathcal { V } , n = 1 \\ldots N \\}$ of image, text and label tuples, we are interested in finding representations $f _ { \\phi } : \\mathcal { V } \\to \\mathcal { Z }$ of image, parameterized by $\\phi$ , and $f _ { \\theta } : \\mathcal { T }  \\mathcal { Z }$ of text, parameterized by $\\theta$ , in a common embedding space $\\mathcal { Z }$ . Furthermore, GZSL problem is defined using the sets of seen $\\mathcal { V } ^ { t r }$ and unseen $\\mathcal { V } ^ { t s }$ classes, such that $\\mathcal { V } = \\mathcal { V } ^ { t r } \\cup \\mathcal { V } ^ { t s }$ and $\\bar { \\mathcal { V } } ^ { t r } \\cap \\mathcal { V } ^ { t s } = \\emptyset$ . The training set will then only contain the seen classes, i.e. $S ^ { t r } = \\{ ( v _ { n } , t _ { n } , y _ { n } ) \\mid v _ { n } \\in$ $\\nu$ , $t _ { n } \\in \\mathcal { T } , y _ { n } \\in \\mathcal { y } ^ { t r } \\}$ and the task is to build a classifier function $g : \\mathcal { Z } \\times \\mathcal { Z }  \\mathcal { V }$ . This is different from the ZSL scenario focusing on $g : \\mathcal { Z } \\times \\mathcal { Z }  \\mathcal { Y } ^ { t s }$ . ",
+        "bbox": [
+            173,
+            583,
+            825,
+            751
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To build $g$ , most approaches to joint representation learning rely on class labeling to train a representation. For example, all the methods reviewed by Xian et al. (2018c) require the access to class labels at train time. We hypothesise that in the fine-grained learning scenario, such as the one described by Reed et al. (2016), a lot of information can be extracted simply from pairwise image/text cooccurrences. The class labels really only become critically necessary when we define class prototypes, i.e. at zero-shot test time. Following this intuition, we define a composite loss function that relies both on the pairwise relationships and on the class labels. The high-level description of the proposed framework is depicted in Figure 1. The framework enables us, among other things, to experiment with the effects of train-time availability of class labels on the quality of zero-shot representations. The framework is based on projecting texts and images into a common space and then learning a representation based on a mixture of four loss functions: a pairwise text retrieval loss, a pairwise image retrieval loss, a text classifier loss and an image classifier loss (see Algorithm 1). ",
+        "bbox": [
+            173,
+            757,
+            826,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Loss calculation for a single optimization iteration of the proposed method. $N$ is the number of instances in the training set ${ \\mathcal { S } } ^ { t r }$ , $B$ is the number of instances per batch, $C$ is the number of classes in the train set. $\\mathrm { R A N D O M S A M P L E } ( S , B )$ denotes a set of $B$ elements chosen uniformly at random from a set $s$ , without replacement. ",
+        "bbox": [
+            173,
+            102,
+            825,
+            160
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/18df0181b501f401a7b2d506b2c75380a51ed2ff3f2b3eb40ec700d88788894d.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"3\">Input: Training set Str = {(U1,t1,yi),...,(UN,tN,yN)},λ ∈ [0,1], κ ∈ [0,1]. Output: The loss J(,θ) for a randomly sampled training batch. I← RANDOMSAMPLE({1,...,N},B) &gt;Select B instance indices for batch</td></tr><tr><td>Jrc(Θ),J1c(Φ)←0,0 foriinZdo</td><td colspan=\"3\">Initialize classification losses Embed images and texts Image classifier probabilities</td></tr><tr><td colspan=\"3\">Zui,Zt←f(Ui）,fθ(ti)</td></tr><tr><td colspan=\"2\">p ← softmax(Wizui +b1) PT ← sOftmax(WTZt +br)</td></tr><tr><td colspan=\"2\">Textclassifierprobabilities JTc(0) ← JTc(0)+ crossentropy(pr,yi) Text classification loss</td></tr><tr><td colspan=\"2\">JIc(𝜙) ← Jic(Φ)+ crossentropy(p1, yi) Image classification loss end for</td></tr><tr><td colspan=\"2\">JTR(Φ,0),J1R(Φ,0)←0,0 Initialize retrieval losses</td></tr><tr><td colspan=\"2\">foriinZdo 1 Text retrieval loss</td></tr><tr><td colspan=\"2\">JTR(Φ,0)←JTR(Φ,0)+ d(zu,Zt）+log∑ exp(-d(Zu,Ztj)) B j∈I</td></tr><tr><td colspan=\"2\">1-B JIR(Φ,0)←JIR(Φ,0)+ d(Zui,Zti) + log∑exp(-d(Zt , Zuj))|&gt; Image retrieval loss</td></tr><tr><td colspan=\"2\">j∈I</td></tr><tr><td colspan=\"2\">J(,θ)←λJTR(𝜙,0)+(1-λ)JIR(Φ,0) Add retrieval loss to the total loss J(Φ,θ)←(1-κ)J(,0)+(Jrc(0)+JIc()) Add classification loss to the total loss</td></tr></table>",
+        "bbox": [
+            174,
+            162,
+            836,
+            487
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 RETRIEVAL LOSS FUNCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            511,
+            411,
+            525
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Pairwise cross-modal loss function is based solely on the pairwise relationships between texts and images. We choose to use the metric learning approach to capture the relationship between images and texts. Now, suppose $d$ is a metric $d : \\mathcal { Z } \\times \\mathcal { Z }  \\mathbb { R } ^ { + }$ , $v _ { i }$ is an image and $\\tau = \\{ t _ { j ^ { \\prime } } \\}$ is a collection of arbitrary texts sampled uniformly at random, of which text $t _ { j }$ belongs to $v _ { i }$ . We propose the following model for the probability of image $v _ { i }$ and text $t _ { j }$ to belong to the same object instance: ",
+        "bbox": [
+            173,
+            536,
+            825,
+            608
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/66c9fefbdd5debf1a919106a675316eaef51240da8ba8bff3384cde5d307f350.jpg",
+        "text": "$$\np _ { \\phi , \\theta } ( i = j | v _ { i } , t _ { j } , \\tau ) = \\frac { \\exp ( - d ( f _ { \\phi } ( v _ { i } ) , f _ { \\theta } ( t _ { j } ) ) ) } { \\sum _ { t _ { j ^ { \\prime } } \\in \\tau } \\exp ( - d ( f _ { \\phi } ( v _ { i } ) , f _ { \\theta } ( t _ { j ^ { \\prime } } ) ) ) } \\ .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            305,
+            612,
+            692,
+            650
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The learning is then based on the following cross-entropy loss defined on the batch of size $B$ : ",
+        "bbox": [
+            169,
+            652,
+            784,
+            667
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2b97ee593256906efa0bca123ca74f839ff6c75fd4f2cca4d9bdd6cf46a14163.jpg",
+        "text": "$$\nJ _ { T R } ( \\phi , \\theta ) = - \\frac { 1 } { B } \\sum _ { i , j = 1 } ^ { B } \\ell _ { i , j } \\log p _ { \\phi , \\theta } ( i = j | v _ { i } , t _ { j } , \\{ t _ { j ^ { \\prime } } \\} _ { j ^ { \\prime } = 1 } ^ { B } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            302,
+            671,
+            694,
+            715
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\ell _ { i , j }$ is a binary indicator of the true match $\\mathcal { \\ell } _ { i , j } = 1$ , if $i = j$ and 0 otherwise). Note that the expression above has the interpretation of the text retrieval loss. It attains its smallest value when for each image in the batch we manage to assign probability 1 to its respective text and 0 to all other texts. This can be further expanded as: ",
+        "bbox": [
+            174,
+            719,
+            825,
+            776
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e94db0ef9c2a0a6f62952bdf1653f0a4f3ffe6247f5fd866035cda9e491a975b.jpg",
+        "text": "$$\nJ _ { T R } ( \\phi , \\theta ) = \\frac { 1 } { B } \\sum _ { i = 1 } ^ { B } \\left( d ( f _ { \\phi } ( v _ { i } ) , f _ { \\theta } ( t _ { i } ) ) + \\log \\Big [ \\sum _ { t _ { j ^ { \\prime } } \\in \\tau } \\exp ( - d ( f _ { \\phi } ( v _ { i } ) , f _ { \\theta } ( t _ { j ^ { \\prime } } ) ) ) \\Big ] \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            223,
+            779,
+            776,
+            829
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Exchanging the order of image and text in the probability model (1) leads to the image retrieval loss, $J _ { I R } ( \\phi , \\bar { \\theta } )$ . The two losses are mixed using parameter $\\lambda \\in [ 0 , 1 ]$ as shown in Algorithm 1. ",
+        "bbox": [
+            174,
+            832,
+            823,
+            862
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The pairwise retrieval loss functions are responsible for the modality alignment. In addition to those, we propose to include, as mentioned above, the usual image and text classifier losses. These losses are responsible for reducing the intraclass variability of representations. The classifier losses are added to the retrieval losses using a mixing parameter $\\kappa \\in [ 0 , 1 ]$ as shown in Algorithm 1. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 BALANCING ACCURACY ON THE SEEN AND UNSEEN CLASSES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            648,
+            118
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Let us define class prototypes $\\mathbf p ( y )$ , each based on the set of texts $\\mathcal { T } _ { y }$ belonging to class $y$ , $\\mathbf { \\{ p ( }  y \\mathbf { ) = }$ $\\begin{array} { r } { \\frac { 1 } { | T _ { y } | } \\sum _ { t _ { i } \\in \\mathcal { T } _ { y } } f _ { \\theta } ( t _ { i } ) \\ | \\ y \\in \\mathcal { V } \\} } \\end{array}$ . In the context of GZSL, the nearest neighbor decision rule for a given image $v$ and its features ${ \\bf z } _ { v } = f _ { \\phi } ( v )$ has the following form: ",
+        "bbox": [
+            173,
+            128,
+            825,
+            180
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3d3a73b561686471c4dfe86df22f349395ea59a86c528b9db4f01ce94ccf5acf.jpg",
+        "text": "$$\n\\boldsymbol { \\widehat { y } } = \\arg \\operatorname* { m i n } _ { \\boldsymbol { y } \\in \\mathcal { V } } d ( \\mathbf { z } _ { v } , \\mathbf { p } ( \\boldsymbol { y } ) ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            410,
+            188,
+            586,
+            212
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The most acute problem faced in this setup is the accuracy imbalance between seen and unseen classes. A very representative case clearly outlining the imbalance problem is presented in Table 6 of (Xian et al., 2018c), where accuracy on the seen classes is always significantly greater than the accuracy on unseen ones. In order to measure and control the imbalance, three metrics are commonly used to assess the classification performance in the GZSL scenario: the Top-1 accuracy on the seen categories (s), the Top-1 accuracy on the unseen categories $\\mathbf { \\Pi } ^ { ( \\mathbf { u } ) }$ and their harmonic mean, $\\mathbf { H } = \\mathbf { u } \\cdot \\mathbf { s } / ( \\mathbf { u } + \\mathbf { s } )$ . The main metric to assess GZSL performance is then $\\mathbf { H }$ , which quantifies both $\\mathbf { u }$ and s. ",
+        "bbox": [
+            173,
+            219,
+            825,
+            319
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To formalize the problem, we first introduce $y _ { v }$ , the true class label of image $v$ . Mathematically, the main GZSL pain point is that $\\mathbb { P } \\{ \\widehat { y } \\in \\mathcal { y } ^ { t r } | y _ { v } \\in \\mathcal { y } ^ { t s } \\}$ is significantly greater than $\\mathbb { P } \\{ \\widehat { y } \\in \\mathcal { y } ^ { t s } | y _ { v } \\in$ $\\mathcal { V } ^ { t r } \\}$ b b. In other words, the problem is that a given image is more likely to be confused with one of the seen classes if it belongs to an unseen class than vice versa. Our approach to solving the problem is based on the following probabilistic representation of the event space for the decision rule in Equation (4): ",
+        "bbox": [
+            173,
+            324,
+            825,
+            410
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c4992af813698d95795db7215aceffe43193c03d6626652d1543fc22759ab44a.jpg",
+        "text": "$$\n\\mathbb { P } \\{ \\boldsymbol { { \\widehat { y } } } \\in { \\mathcal { Y } } ^ { t r } | y _ { v } \\in { \\mathcal { Y } } ^ { t s } \\} = \\mathbb { P } \\left\\{ \\operatorname* { m i n } _ { y \\in { \\mathcal { Y } } ^ { t r } } d ( \\mathbf { z } _ { v } , \\mathbf { p } ( y ) ) < \\operatorname* { m i n } _ { y \\in { \\mathcal { Y } } ^ { t s } } d ( \\mathbf { z } _ { v } , \\mathbf { p } ( y ) ) \\mid y _ { v } \\in { \\mathcal { Y } } ^ { t s } \\right\\} .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            227,
+            416,
+            769,
+            449
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Rephrasing, the most acute GZSL error happens when the prototype of one of the seen classes is closer to an image embedding from an unseen class than any of the prototypes of the unseen classes. ",
+        "bbox": [
+            173,
+            457,
+            825,
+            486
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To rectify the situation we propose the following very direct solution to balance $\\mathbb { P } \\{ \\widehat { y } \\in \\mathcal { y } ^ { t r } | y _ { v } \\in \\mathcal { y } ^ { t s } \\}$ and $\\mathbb { P } \\{ \\hat { \\mathcal { Y } } \\in \\mathcal { Y } ^ { t s } | y _ { v } \\in \\mathcal { Y } ^ { t \\bar { r } } \\}$ . We introduce a positive scalar $\\alpha \\in \\mathbb { R } ^ { + }$ band scale all the distances bcorresponding to the seen prototypes by $1 + \\alpha$ . This gives rise to the following scaled distance $d _ { \\alpha }$ : ",
+        "bbox": [
+            174,
+            492,
+            825,
+            535
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a62834e649aa08ed171d61fabc0cba31952b1b0e4dc94b2e737d501dd6da9e62.jpg",
+        "text": "$$\nd _ { \\alpha } ( \\mathbf { z } _ { v } , \\mathbf { p } ( y ) ) = \\left\\{ \\begin{array} { l l } { ( 1 + \\alpha ) d ( \\mathbf { z } _ { v } , \\mathbf { p } ( y ) ) , } & { \\mathrm { i f ~ } y \\in \\mathcal { Y } ^ { t r } } \\\\ { d ( \\mathbf { z } _ { v } , \\mathbf { p } ( y ) ) , } & { \\mathrm { o t h e r w i s e } } \\end{array} \\right. .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            323,
+            542,
+            676,
+            582
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The misclassification between unseen as seen classes for the classifier $\\widehat { y } _ { \\alpha }$ , based on (6) is then: ",
+        "bbox": [
+            174,
+            588,
+            790,
+            603
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6c11b414afece46ca498ac50b8688e023ff6de855077e8453e68919cc2b737ba.jpg",
+        "text": "$$\n\\mathbb { P } \\{ \\widehat { y } _ { \\alpha } \\in \\mathcal { Y } ^ { t r } | y _ { v } \\in \\mathcal { Y } ^ { t s } \\} = \\mathbb { P } \\left\\{ \\left( 1 + \\alpha \\right) \\operatorname* { m i n } _ { y \\in \\mathcal { Y } ^ { t r } } d ( \\mathbf { z } _ { v } , \\mathbf { p } ( y ) ) < \\operatorname* { m i n } _ { y \\in \\mathcal { Y } ^ { t s } } d ( \\mathbf { z } _ { v } , \\mathbf { p } ( y ) ) | y _ { v } \\in \\mathcal { Y } ^ { t s } \\right\\} \\ ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            192,
+            609,
+            784,
+            643
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "and it has the following property: for any $0 \\leq \\alpha _ { 1 } \\leq \\alpha _ { 2 }$ , $\\mathbb { P } \\{ \\widehat { y } _ { \\alpha _ { 1 } } ~ \\in ~ \\mathcal { Y } ^ { t r } | y _ { v } ~ \\in ~ \\mathcal { Y } ^ { t s } \\} ~ \\geq ~ \\mathbb { P } \\{ \\widehat { y } _ { \\alpha _ { 2 } } ~ \\in ~$ $\\mathcal { V } ^ { t r } | y _ { v } \\in \\mathcal { V } ^ { t s } \\}$ , i.e. $\\mathbb { P } \\{ \\widehat { y } _ { \\alpha } \\in \\mathcal { V } ^ { t \\bar { r } } | y _ { v } \\in \\mathcal { V } ^ { t s } \\}$ b   is a monotone non-increasing function of $\\alpha$ b and we bcan reduce it by increasing $\\alpha$ (please refer to Appendix A for a proof). Consider now $\\mathbb { P } \\{ \\widehat { y } _ { \\alpha } \\in$ $\\mathcal { V } ^ { t r } | y _ { v } \\in \\mathcal { V } ^ { t r } \\big \\}$ , which is a probability that we classify an image $v$ bfrom one of the seen classes as still one of the seen classes. Using exactly the same chain of arguments as in Appendix A, it is straightforward to show that the probability is a non-increasing function of $\\alpha$ . Hence the probability $\\mathbb { P } \\{ \\hat { y } _ { \\alpha } ^ { \\sim } \\in \\mathcal { V } ^ { t s } | y _ { v } \\in \\mathcal { V } ^ { t r } \\} = 1 - \\mathbb { P } \\{ \\hat { y } _ { \\alpha } \\in \\mathcal { V } ^ { \\hat { t r } } | y _ { v } \\in \\mathcal { V } ^ { t r } \\}$ is a non-decreasing function of $\\alpha$ . Therefore, as $\\alpha$ increases, we expect more classification errors in classifying images from seen classes, because some of them will be classified as one of the unseen classes. ",
+        "bbox": [
+            173,
+            651,
+            825,
+            779
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To sum up, given the arguments presented above we expect that by varying $\\alpha > 0$ we can balance the error rate $\\mathbb { P } \\mathbf { \\bar { \\{ y _ { \\alpha } \\in \\mathcal { V } ^ { t r } \\vert y _ { v } \\in \\mathcal { V } ^ { t s } \\} } }$ of leaking the unseen class images into seen class classification bdecision and the error rate $\\mathbb { P } \\{ \\widehat { y } _ { \\alpha } ^ { } \\in \\mathcal { V } ^ { t s } | y _ { v } ^ { - } \\in \\mathcal { V } ^ { t r } \\}$ of leaking the seen class images into unseen bclass classification decision. This is possible as we just showed above that $\\mathbb { P } \\{ \\widehat { y } _ { \\alpha } \\in \\mathcal { V } ^ { t r } | y _ { v } \\in \\mathcal { V } ^ { t s } \\}$ is a non-increasing function of $\\alpha$ , while $\\mathbb { P } \\{ \\widehat { y } _ { \\alpha } \\in \\mathcal { V } ^ { t s } | y _ { v } \\in \\mathcal { V } ^ { t r } \\}$ b is a non-decreasing one. It is also important to emphasize that $\\alpha$ bis applied only to distances between the query embedding and the prototypes of seen classes and it is constant over seen classes. Therefore, the application of $\\alpha$ does not at all affect the classification error rates either within $\\mathcal { V } ^ { t r }$ or within $\\mathcal { V } ^ { t s }$ . Varying $\\alpha$ balances exclusively the classification errors arising from transitions between seen and unseen class labels. We study the empirical aspects of balancing $\\alpha$ in Section 4.4. ",
+        "bbox": [
+            173,
+            784,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/12bbcc390447bbfe9373f37f6f92b9541094bd9ffb0478a62b265d975ef854ee.jpg",
+        "table_caption": [
+            "Table 1: Generalized zero-shot Top-1 classification accuracy. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"3\">CUB</td><td colspan=\"3\">FLOWERS</td></tr><tr><td></td><td>u</td><td>S</td><td>H</td><td>u</td><td>s</td><td>H</td></tr><tr><td>CADA-VAE (Schönfeld et al., 2019)</td><td>n/a</td><td>n/a</td><td>53.4</td><td>n/a</td><td>n/a</td><td>n/a</td></tr><tr><td>f-CLSWGAN (Xian et al., 2018d)</td><td>50.3</td><td>58.3</td><td>54.0</td><td>59.0</td><td>73.8</td><td>65.6</td></tr><tr><td>f-VAEGAN-D2 (Xian et al.,2019)</td><td>48.4</td><td>60.1</td><td>53.6</td><td>56.8</td><td>74.9</td><td>64.6</td></tr><tr><td>cycle-(U)WGAN (Felix et al., 2018)</td><td>47.9</td><td>59.3</td><td>53.0</td><td>61.6</td><td>69.2</td><td>65.2</td></tr><tr><td>COSMO+f-CLSWGAN (Atzmon &amp; Chechik, 2019)</td><td>n/a</td><td>n/a</td><td>n/a</td><td>59.6</td><td>81.4</td><td>68.8</td></tr><tr><td>CLAREL (Ours)</td><td>59.3</td><td>52.6</td><td>55.8</td><td>73.0</td><td>73.6</td><td>73.3</td></tr></table>",
+        "bbox": [
+            173,
+            127,
+            846,
+            250
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/892a986457f15b9754b348d5c3429df71973148b0d2ec102398a7aeb1a84ccab.jpg",
+        "table_caption": [
+            "Table 2: Zero-shot Top-1 classification accuracy. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>CUB</td><td>FLOWERS</td></tr><tr><td>CADA-VAE (Schonfeld et al., 2019)</td><td>n/a</td><td>n/a</td></tr><tr><td>f-CLSWGAN (Xian et al., 2018d)</td><td>57.3</td><td>67.2</td></tr><tr><td>f-VAEGAN-D2 (Xian et al., 2019)</td><td>61.0</td><td>67.7</td></tr><tr><td>cycle-(U)WGAN (Felix et al., 2018)</td><td>58.6</td><td>70.3</td></tr><tr><td>CLAREL (Ours)</td><td>66.7</td><td>76.8</td></tr></table>",
+        "bbox": [
+            282,
+            291,
+            715,
+            387
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            414,
+            344,
+            430
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "ZSL approaches aim at recognizing objects belonging to classes unseen during training (Larochelle et al., 2008; Palatucci et al., 2009). This has been extended to the GZSL framework in which the decision space consists of both seen and unseen classes (Socher et al., 2013; Xian et al., 2018c). The classical zero-shot approaches build a joint visual-semantic space, relying on a linear cross-modal compatibility function (e.g. dot-product between query embedding and semantic prototypes or a variation of a hinge loss) (Frome et al., 2013; Akata et al., 2015; 2016; Reed et al., 2016). Non-linear variants of the compatibility has also been explored (Xian et al., 2016; Socher et al., 2013). Extending previously proposed cross-modal transfer approaches based on auto-encoders (Hubert Tsai et al., 2017) and cross-domain learning (Gretton et al., 2007), more recent line of work (Schönfeld et al., 2019; Xian et al., 2018d; 2019; Felix et al., 2018; Verma et al., 2018) relies on combining these approaches and their variations with dataset augmentation tools such as GAN (Goodfellow et al., 2014) and VAE (Kingma & Welling, 2014). It is argued that the use of those tools helps to resolve one of the prominent problems in GZSL scenario: classifying images from unseen classes as one of the seen classes. There exist approaches that try to tackle this same problem via temperature calibration (Liu et al., 2018) originally proposed by Hinton et al. (2015). Chao et al. (2016); Das & Lee (2019) proposed an approach to seen/unseen accuracy balancing that is very similar to ours, based on heuristic arguments. We extend this line of work here by providing a probabilistic justification for the balancing effect observed when applying metric rescaling. Atzmon & Chechik (2019) propose a more sophisticated way to deal with seen/unseen imbalance via adaptive confidence smoothing and gating, yet as authors note it is much simpler to train than the existing GAN-based zero-shot approaches. In this work, we introduce arguably the simplest zero-shot representation training approach of all, and we demonstrate that when the image level text information is available, it achieves the state-of-the-art results on GZSL task on two well-known datasets. ",
+        "bbox": [
+            173,
+            446,
+            825,
+            766
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            792,
+            418,
+            808
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            825,
+            287,
+            840
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We focus on learning embeddings for fine-grained visual descriptions and test them in ZSL/GZSL scenario. To test the quality of trained embeddings we focus on datasets that provide paired images and text descriptions, such as Caltech-UCSD-Birds (CUB) (Welinder et al., 2010) and Oxford Flowers (FLOWERS) (Nilsback & Zisserman, 2008), that were augmented with textual descriptions by Reed et al. (2016). We use the GZSL splits proposed by Xian et al. (2018c). The attribute-based datasets, such as SUN (Patterson et al., 2014) and AWA (Lampert et al., 2014) do not contain this information and do not have a notion of entity of a class in them. They are out of the scope of the current paper. ",
+        "bbox": [
+            174,
+            854,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/6c68eb4c7e42a907d13836d18bd23fbf8d9cba1c7819eebd0cbae1133409eec9.jpg",
+        "image_caption": [
+            "Figure 2: Harmonic mean Top-1 accuracy on seen and unseen, $\\mathbf { H }$ , against the value of $\\alpha$ on the validation set. The curves represent the mean and $9 5 \\%$ confidence intervals over 10 optimization runs. Results are stable over different runs. $\\mathbf { H }$ exhibits a distinct inverted U-shape w.r.t. $\\alpha$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            220,
+            102,
+            776,
+            229
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            320,
+            823,
+            349
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 ARCHITECTURE AND TRAINING DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            377,
+            500,
+            391
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Below, we provide more detailed description of parameters used to build and train the architecture depicted in Figure 1. We use exactly the same hyperparameter settings for CUB and FLOWERS. The text feature extractor is built by cascading two ResNet blocks, followed by a BiLSTM. Each ResNet block has 3 convolutional/batch norm layers. The number of filters in the ResNet blocks is 128 and 256, BiLSTM has 512 filters for forward and backward branches (1024 total). All variables in the convolutional stack (including the batch normalization parameters $\\gamma$ and $\\beta$ ) are L2-penalized with weight 0.001. The image feature extractor is a ResNet-101 with fixed weights pretrained on the split of ImageNet proposed by Xian et al. (2018c). In this work we use precomputed image features, available in (Xian et al., 2018a) for CUB and in (Xian et al., 2018b) for FLOWERS. Image and text features are projected in the common embedding space of size 1024 with FC layers with no non-linearity. They are preceded with a dropout of 0.25. The trainable components of the model are trained for $1 5 0 \\mathrm { k }$ batches of size 32 using SGD with initial learning rate of 0.1 that is annealed by a factor of 10 every $5 0 \\mathrm { k }$ batches. For each batch, we sample 32 instances, each instance includes a vector of precomputed ResNet-101 features and 10 text descriptions corresponding to it, according to the original dataset definition Reed et al. (2016). All 10 text descriptions are processed via the CNN/LSTM stack and the resulting embeddings are average pooled to create a vector representation of length 1024. ",
+        "bbox": [
+            174,
+            407,
+            825,
+            642
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 KEY RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            671,
+            313,
+            685
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Our key empirical results are compared in Table 1 and in Table 2 against the latest state of the art. Our results are based on the settings of $\\lambda = 0 . 5$ , $\\kappa = 0 . 5$ and $\\alpha$ selected on the validation sets of CUB and FLOWERS datasets. Please refer to Section 4.5 for the analysis of stability with respect to the choices of $\\lambda$ and $\\kappa$ and Sections 2.2 and 4.4 for more details on the selection of $\\alpha$ . The combination of the proposed training method and the rebalancing of the metric space results in the state-of-the-art performance. Most of the current methods rely on the dataset augmentation techniques based on GANs, VAEs or combinations thereof. Those are clearly complementary w.r.t. our method and their addition to the training procedure is likely to further boost the performance of our proposed approach. However, this is outside of the scope of the current work. Moreover, the proposed method is state-of-the-art on FLOWERS even when compared against (Atzmon & Chechik, 2019) that uses both more sophisticated GAN based embedding learning approach and a more sophisticated seen/unseen error rate balancing based on COSMO. It is important to note that Atzmon & Chechik (2019) did not report the sentence level results on CUB. Yet, when applied on attributes together with f-CLSWGAN (Xian et al., 2018d) COSMO resulted in $0 . 8 \\%$ performance drop and when applied with LAGO (Atzmon & Chechik, 2018) it achieved $0 . 5 \\%$ improvement over the attribute based state of the art. ",
+        "bbox": [
+            174,
+            702,
+            825,
+            922
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/3f384a4e76f0bc5c58077471f4b2954c58239b2f85fada1da5ff845d8c8bbbae.jpg",
+        "image_caption": [
+            "Figure 3: Harmonic mean Top-1 accuracy on seen and unseen, H, against $\\lambda$ , the relative weight of image and text retrieval loss terms. $\\lambda = 0$ corresponds to the case of image retrieval loss having weight 1 and text retrieval loss having weight 0. Mean over 10 optimization runs. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            220,
+            102,
+            777,
+            229
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/a157ed151bbb217f07fbd4f1af909679c63192783007d447465bf462d40594e9.jpg",
+        "image_caption": [
+            "Figure 4: The plot of the harmonic mean Top-1 accuracy on seen and unseen, $\\mathbf { H }$ , against $\\kappa$ , the relative weight of the retrieval and the classification loss terms. $\\kappa = 0$ corresponds to the case of classification loss having weight 0. The curves represent the mean over 10 optimization runs. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            220,
+            303,
+            777,
+            431
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.4 ON THE SEEN/UNSEEN ACCURACY BALANCING ",
+        "text_level": 1,
+        "bbox": [
+            179,
+            518,
+            537,
+            531
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Figure 2 demonstrates the plot of harmonic mean Top-1 accuracy, $\\mathbf { H }$ , against the value of $\\alpha$ on the validation sets of CUB and FLOWERS datasets. The validation set is constructed by further splitting the train set on both datasets. For example, CUB has a train set of 5875 images from 100 seen classes and a validation set of 2946 images from 50 unseen classes. We further divide the train set into 4700 train images from 100 seen classes, 1175 seen validation images $( 4 7 0 0 + 1 1 7 5 = 5 8 7 5 )$ and we use all the 2946 images from 50 classes as the unseen validation set. Once the value of $\\alpha$ is determined we train the representation on the full train $^ +$ val subset and report results on the test split (the usual practice in GZSL). We confirm on the validation set that H exhibits an inverted U-shape behavior as a function of $\\alpha$ , which was theoretically predicted in Section 2.2. Therefore, $\\alpha$ can be selected on the validation set and then applied to re-scale the metric space to balance the accuracy on seen and unseen classes during test time as described in Section 2.2. ",
+        "bbox": [
+            173,
+            545,
+            825,
+            698
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.5 ABLATION STUDY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            722,
+            339,
+            734
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Figure 3 presents the results of the ablation study on the importance of image and text retrieval losses. We see that all of the Top-1 accuracies $( \\mathbf { H } , \\mathbf { s } , \\mathbf { u } )$ are stable in the range of $\\lambda \\in [ 0 . 2 , 0 . 9 ]$ , when both losses have tangible weight. Removing either text or image retrieval losses (setting $\\lambda$ to 0 or 1 respectively) leads to performance drop in both cases. Removing the text retrieval loss (case $\\lambda = 0$ ) results in the most significant drop. This is due to the fact that the text retrieval task is more tightly related to the GZSL task. At the batch level, retrieving the right text given an image is equivalent to identifying the correct class encoded by a text prototype during ZSL inference step. The image retrieval task is not directly related to solving the ZSL problem and yet it does yield a positive regularizing effect on both CUB and FLOWERS. ",
+        "bbox": [
+            173,
+            750,
+            825,
+            875
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Figure 4 shows the results of the ablation study of the interplay between the retrieval loss and the classification loss. We observe, just as in the case with $\\lambda$ , that there exists a reasonably flat and stable range of $\\kappa \\in [ 0 . 2 , 0 . 6 ]$ . The range for $\\kappa$ is a bit smaller. $\\kappa = 1$ results in the catastrophic performance drop: the classification losses by themselves do not enforce any modality alignment (please refer to Fig. 1 and Algorithm 1 clearly demonstrating this). ",
+        "bbox": [
+            174,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/a9ed39c401c5a3ac797b5f3447e0276b6810d59aee48a6e4a3f12e525762ff7f.jpg",
+        "table_caption": [
+            "Table 3: Generalized zero-shot Top-1 classification accuracy, ablation study. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td></td><td></td><td></td><td>CUB</td><td></td><td colspan=\"3\">FLOWERS</td></tr><tr><td>α</td><td>入</td><td>K</td><td>u</td><td>S</td><td>H</td><td>u</td><td>s</td><td>H</td></tr><tr><td>0.0</td><td>0.5</td><td>0.5</td><td>38.3</td><td>65.3</td><td>48.3</td><td>55.1</td><td>84.6</td><td>66.7</td></tr><tr><td>0.0</td><td>0.5</td><td>0.0</td><td>39.3</td><td>57.5</td><td>46.7</td><td>54.0</td><td>78.1</td><td>63.8</td></tr><tr><td>√</td><td>0.5</td><td>0.0</td><td>53.8</td><td>49.6</td><td>51.6</td><td>71.7</td><td>67.2</td><td>69.4</td></tr><tr><td>√</td><td>0.0</td><td>0.5</td><td>47.4</td><td>36.6</td><td>41.3</td><td>51.5</td><td>60.5</td><td>55.6</td></tr><tr><td>√</td><td>1.0</td><td>0.5</td><td>53.9</td><td>53.8</td><td>53.8</td><td>69.5</td><td>73.9</td><td>71.6</td></tr><tr><td>厂</td><td>0.5</td><td>0.5</td><td>59.3</td><td>52.6</td><td>55.8</td><td>73.0</td><td>73.6</td><td>73.3</td></tr></table>",
+        "bbox": [
+            292,
+            126,
+            705,
+            248
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            273,
+            821,
+            303
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 3 studies the effects of different loss terms on the harmonic mean Top-1 accuracy H. The best result is achieved when all loss terms are active and when the metric space rescaling is on (the case of $\\lambda = 0 . 5$ , $\\kappa = 0 . 5$ and $\\alpha$ is checked, the last line in the table). Comparing this with the case when there is no metric space rescaling (first line with $\\alpha = 0$ ), we see that the rescaling helps to decrease the gap between seen and unseen classification accuracy. For CUB, the discrepancy reduction is from around $30 \\%$ to around $6 \\%$ , for FLOWERS it is from around $30 \\%$ to around $1 \\%$ . We would like to stress that we only use images and texts from the training set to achieve that. Going to the second line in the table (the image/text classification loss is inactive, $\\kappa = 0$ ) and comparing it to the first one, we assess the effect of the image/text classification loss. It barely affects the performance on unseen set, but it significantly boosts the classification accuracy on the seen set (around $8 \\%$ on both datasets). This is logical: adding a classifier loss results in a better classifier of the test images from the seen classes. This alone does not make it a better GZSL classifier, however. Only when applied together with metric space rescaling, this results in the performance boost (please refer to lines 1 and 6 in Table 3). Our interpretation is that the addition of the image/text classifier loss helps to reduce the intraclass variability in embeddings and provides for tighter clustering. However, this also leads to overfit on the classification task. This is accounted for by metric rescaling that enables the learnings from the image/text classification task be transferred effectively into the GZSL task. ",
+        "bbox": [
+            173,
+            309,
+            825,
+            545
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The comparison of the last four rows of Table 3 leads us to believe that all the proposed loss terms outlined in Fig. 1 and Algorithm 1 are important for achieving the state-of-the-art performance. Excluding any one of them (corresponding to the extreme values $\\lambda = 0$ , $\\lambda = 1$ , $\\kappa = 0$ ) leads to performance deterioration. Finally, an interesting observation can be made by comparing line 3 of Table 3 with performance of algorithms in Table 1. In this case our algorithm does not use any class labels and relies on training using exclusively the retrieval losses that can be calculated only based on the pairwise relationships between texts and images. We can see that using this type of supervision alone already results in a very high-quality representation. The representation is competitive against the latest GAN/VAE based approaches on CUB and is state-of-the-art on FLOWERS. This opens up new exploration avenues showing that in the case when very fine-grained modality outputs are available (image and text description pairs being a very prominent example), the high-quality representations may be learned without relying on manually supplied class labels. ",
+        "bbox": [
+            173,
+            553,
+            825,
+            719
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            739,
+            328,
+            755
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We propose and empirically validate two improvements to the process of learning fine-grained crossmodal representations. First, we confirm the hypothesis that in the context of paired images and texts, a deep metric learning approach can be driven by an instance-based retrieval loss resulting in competitive generalized zero shot classification results. Combined with an additional class label based image/text crossentropy term this results in state-of-the-art performance on two well known datasets, CUB and FLOWERS. This is an interesting result demonstrating that high-quality deep representations can be trained relying largely on pairwise relationships between modalities. On top of that, we propose a solution to one of the prominent problems in GZSL: classifying instances of unseen classes as seen ones. We mathematically analyze and empirically validate the method of adjusting a single scalar that transcends in its effectiveness advanced dataset augmentation and training approaches based on GANs and VAEs. ",
+        "bbox": [
+            174,
+            770,
+            825,
+            922
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            287,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Zeynep Akata, Scott Reed, Daniel Walter, Honglak Lee, and Bernt Schiele. Evaluation of output embeddings for fine-grained image classification. In CVPR, 2015. ",
+        "bbox": [
+            174,
+            126,
+            823,
+            155
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Zeynep Akata, Florent Perronnin, Zaid Harchaoui, and Cordelia Schmid. Label-embedding for image classification. TPAMI, 2016. ",
+        "bbox": [
+            173,
+            162,
+            821,
+            191
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yuval Atzmon and Gal Chechik. Probabilistic AND-OR attribute grouping for zero-shot learning. In UAI, 2018. ",
+        "bbox": [
+            173,
+            199,
+            821,
+            229
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yuval Atzmon and Gal Chechik. Adaptive confidence smoothing for generalized zero-shot learning. In CVPR, 2019. ",
+        "bbox": [
+            173,
+            237,
+            823,
+            266
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Wei-Lun Chao, Soravit Changpinyo, Boqing Gong, and Fei Sha. An empirical study and analysis of generalized zero-shot learning for object recognition in the wild. In ECCV (2), pp. 52–68, 2016. ",
+        "bbox": [
+            173,
+            273,
+            825,
+            304
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Debasmit Das and C Lee. Zero-shot image recognition using relational matching, adaptation and calibration. In International Joint Conference on Neural Networks, 2019. ",
+        "bbox": [
+            174,
+            311,
+            821,
+            342
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Rafael Felix, Vijay Kumar B G, Ian Reid, and Gustavo Carneiro. Multi-modal cycle-consistent generalized zero-shot learning. In ECCV, 2018. ",
+        "bbox": [
+            173,
+            348,
+            823,
+            378
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Andrea Frome, Greg S Corrado, Jon Shlens, Samy Bengio, Jeff Dean, Marc Aurelio Ranzato, and Tomas Mikolov. DeViSE: A deep visual-semantic embedding model. In NIPS, pp. 2121–2129, 2013. ",
+        "bbox": [
+            174,
+            386,
+            825,
+            429
+        ],
+        "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 NIPS, pp. 2672–2680, 2014. ",
+        "bbox": [
+            173,
+            438,
+            825,
+            467
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Arthur Gretton, Karsten M Borgwardt, Malte Rasch, Bernhard Schölkopf, and Alex J Smola. A kernel method for the two-sample-problem. In NIPS, 2007. ",
+        "bbox": [
+            173,
+            474,
+            825,
+            503
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey Hinton, Oriol Vinyals, and Jeffrey Dean. Distilling the knowledge in a neural network. In NIPS Workshop, 2015. ",
+        "bbox": [
+            174,
+            512,
+            823,
+            541
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yao-Hung Hubert Tsai, Liang-Kang Huang, and Ruslan Salakhutdinov. Learning robust visualsemantic embeddings. In CVPR, 2017. ",
+        "bbox": [
+            173,
+            549,
+            825,
+            579
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Diederik P. Kingma and Max Welling. Auto-encoding variational bayes. In ICLR, 2014. ",
+        "bbox": [
+            171,
+            587,
+            753,
+            602
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "C. H. Lampert, H. Nickisch, and S. Harmeling. Attribute-based classification for zero-shot visual object categorization. TPAMI, 2014. ",
+        "bbox": [
+            176,
+            611,
+            825,
+            640
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Hugo Larochelle, Dumitru Erhan, and Yoshua Bengio. Zero-data learning of new tasks. In AAAI, 2008. ",
+        "bbox": [
+            176,
+            647,
+            825,
+            676
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Yoshua Bengio, and Geoffrey Hinton. Deep learning. Nature, 2015. ",
+        "bbox": [
+            176,
+            684,
+            712,
+            700
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Shichen Liu, Mingsheng Long, Jianmin Wang, and Michael I Jordan. Generalized zero-shot learning with deep calibration network. In NIPS, 2018. ",
+        "bbox": [
+            173,
+            708,
+            818,
+            738
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "M. Nilsback and A. Zisserman. Automated flower classification over a large number of classes. In 2008 Sixth Indian Conference on Computer Vision, Graphics Image Processing, 2008. ",
+        "bbox": [
+            173,
+            746,
+            823,
+            775
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mark Palatucci, Dean Pomerleau, Geoffrey E Hinton, and Tom M Mitchell. Zero-shot learning with semantic output codes. In NIPS, 2009. ",
+        "bbox": [
+            174,
+            782,
+            823,
+            813
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Genevieve Patterson, Chen Xu, Hang Su, and James Hays. The sun attribute database: Beyond categories for deeper scene understanding. IJCV, 2014. ",
+        "bbox": [
+            173,
+            820,
+            823,
+            849
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Scott E. Reed, Zeynep Akata, Honglak Lee, and Bernt Schiele. Learning deep representations of fine-grained visual descriptions. In CVPR, 2016. ",
+        "bbox": [
+            173,
+            858,
+            821,
+            887
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Edgar Schönfeld, Sayna Ebrahimi, Samarth Sinha, Trevor Darrell, and Zeynep Akata. Generalized zero-and few-shot learning via aligned variational autoencoders. CVPR, 2019. ",
+        "bbox": [
+            174,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Richard Socher, Milind Ganjoo, Christopher D Manning, and Andrew Ng. Zero-shot learning through cross-modal transfer. In NIPS, 2013.   \nVinay Kumar Verma, Gundeep Arora, Ashish Mishra, and Piyush Rai. Generalized zero-shot learning via synthesized examples. In CVPR, 2018.   \nWei Wang, Vincent W. Zheng, Han Yu, and Chunyan Miao. A survey of zero-shot learning: Settings, methods, and applications. ACM Trans. Intell. Syst. Technol., 2019.   \nYaqing Wang and Quanming Yao. Few-shot learning: A survey. In arXiv, 2019.   \nP. Welinder, S. Branson, T. Mita, C. Wah, F. Schroff, S. Belongie, and P. Perona. Caltech-UCSD Birds 200. Technical report, California Institute of Technology, 2010.   \nYongqin Xian, Zeynep Akata, Gaurav Sharma, Quynh N. Nguyen, Matthias Hein, and Bernt Schiele. Latent embeddings for zero-shot classification. In CVPR, 2016.   \nYongqin Xian, Christoph H. Lampert, Bernt Schiele, and Zeynep Akata. Pretrained CUB features, 2018a. URL http://datasets.d2.mpi-inf.mpg.de/xian/xlsa17.zip.   \nYongqin Xian, Christoph H. Lampert, Bernt Schiele, and Zeynep Akata. Pretrained FLOWERS features, 2018b. URL http://datasets.d2.mpi-inf.mpg.de/xian/cvpr18xian. zip.   \nYongqin Xian, H. Christoph Lampert, Bernt Schiele, and Zeynep Akata. Zero-shot learning: A comprehensive evaluation of the good, the bad and the ugly. TPAMI, 2018c.   \nYongqin Xian, Tobias Lorenz, Bernt Schiele, and Zeynep Akata. Feature generating networks for zero-shot learning. In CVPR, 2018d.   \nYongqin Xian, Saurabh Sharma, Bernt Schiele, and Zeynep Akata. f-vaegan-d2: A feature generating framework for any-shot learning. CVPR, 2019.   \nH. Zhang, T. Xu, H. Li, S. Zhang, X. Wang, X. Huang, and D. N. Metaxas. StackGAN $^ { + + }$ : Realistic image synthesis with stacked generative adversarial networks. PAMI, 2018. ",
+        "bbox": [
+            171,
+            102,
+            828,
+            522
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A THE ANALYSIS OF ERROR RATES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            541,
+            488,
+            558
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We show that $\\mathbb { P } \\{ \\widehat { y } ~ \\in ~ \\mathcal { Y } ^ { t r } | y _ { v } ~ \\in ~ \\mathcal { Y } ^ { t s } \\} ~ \\geq ~ \\mathbb { P } \\{ \\widehat { y } _ { \\alpha } ~ \\in ~ \\mathcal { Y } ^ { t r } | y _ { v } ~ \\in ~ \\mathcal { Y } ^ { t s } \\}$ . Let us define $\\delta _ { t r } \\equiv$ $\\begin{array} { r } { \\operatorname* { m i n } _ { y \\in \\mathcal { y } ^ { t r } } d ( \\mathbf { z } _ { v } , \\mathbf { p } ( y ) ) } \\end{array}$ and $\\begin{array} { r } { \\delta _ { t s } \\equiv \\operatorname* { m i n } _ { y \\in \\mathcal { V } ^ { t s } } d ( \\mathbf { z } _ { v } , \\mathbf { p } ( y ) ) } \\end{array}$ , then Equation (7) can be rewritten as: ",
+        "bbox": [
+            171,
+            570,
+            825,
+            602
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d406a9252d80daf106d9a4cfc77b0b1de57e941418018b7e6ea684fcf96c68c2.jpg",
+        "text": "$$\n\\mathbb { P } \\{ \\widehat { y } _ { \\alpha } \\in \\mathcal { V } ^ { t r } | y _ { v } \\in \\mathcal { V } ^ { t s } \\} = \\mathbb { P } \\left\\{ ( 1 + \\alpha ) \\delta _ { t r } < \\delta _ { t s } | y _ { v } \\in \\mathcal { V } ^ { t s } \\right\\} \\mathrm { ~ . ~ }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            299,
+            604,
+            694,
+            621
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Let us consider the probability of event $\\delta _ { t r } < \\delta _ { t s }$ and decompose it as follows: ",
+        "bbox": [
+            174,
+            622,
+            691,
+            636
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1125cd16d5d95a1f8c8e948f94949c974d4895b575a12f7fa163ec98d67420e9.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathbb { P } \\left\\{ \\delta _ { t r } < \\delta _ { t s } \\middle | y _ { v } \\in \\mathcal { Y } ^ { t s } \\right\\} = \\mathbb { P } \\left\\{ ( 1 + \\alpha ) \\delta _ { t r } < ( 1 + \\alpha ) \\delta _ { t s } | y _ { v } \\in \\mathcal { Y } ^ { t s } \\right\\} } \\\\ & { = \\mathbb { P } \\left\\{ ( 1 + \\alpha ) \\delta _ { t r } < \\delta _ { t s } \\cup \\delta _ { t s } \\leq ( 1 + \\alpha ) \\delta _ { t r } < ( 1 + \\alpha ) \\delta _ { t s } | y _ { v } \\in \\mathcal { Y } ^ { t s } \\right\\} } \\\\ & { = \\mathbb { P } \\left\\{ ( 1 + \\alpha ) \\delta _ { t r } < \\delta _ { t s } | y _ { v } \\in \\mathcal { Y } ^ { t s } \\right\\} + \\mathbb { P } \\left\\{ \\delta _ { t s } \\leq ( 1 + \\alpha ) \\delta _ { t r } < ( 1 + \\alpha ) \\delta _ { t s } | y _ { v } \\in \\mathcal { Y } ^ { t s } \\right\\} } \\\\ & { - \\mathbb { P } \\left\\{ ( 1 + \\alpha ) \\delta _ { t r } < \\delta _ { t s } \\cap \\delta _ { t s } \\leq ( 1 + \\alpha ) \\delta _ { t r } < ( 1 + \\alpha ) \\delta _ { t s } | y _ { v } \\in \\mathcal { Y } ^ { t s } \\right\\} } \\\\ & { = \\mathbb { P } \\left\\{ ( 1 + \\alpha ) \\delta _ { t r } < \\delta _ { t s } | y _ { v } \\in \\mathcal { Y } ^ { t s } \\right\\} + \\mathbb { P } \\left\\{ \\delta _ { t s } \\leq ( 1 + \\alpha ) \\delta _ { t r } < ( 1 + \\alpha ) \\delta _ { t s } | y _ { v } \\in \\mathcal { Y } ^ { t s } \\right\\} } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            214,
+            635,
+            772,
+            734
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The transitions are based on the relationship between probabilities of arbitrary events $A$ and $B$ , $\\mathbb { P } \\{ A \\cup B \\} = \\mathbb { P } \\{ A \\} + \\mathbb { P } \\{ B \\} - \\mathbb { P } \\{ A \\cap B \\}$ , and in our case ${ \\mathbb { P } } \\{ A \\cap B \\} = 0$ . This implies that: ",
+        "bbox": [
+            171,
+            734,
+            828,
+            762
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c82fe815b758df297244b22978a323eab8837f91f51cbd01bee778cf0f808da0.jpg",
+        "text": "$$\n\\begin{array} { r l r } {  { \\mathbb { P } \\{ \\widehat { y } _ { \\alpha } \\in \\mathcal { Y } ^ { t r } | y _ { v } \\in \\mathcal { Y } ^ { t s } \\} = \\mathbb { P } \\{ \\widehat { y } \\in \\mathcal { Y } ^ { t r } | y _ { v } \\in \\mathcal { Y } ^ { t s } \\} - \\mathbb { P } \\{ \\frac { \\delta _ { t s } } { ( 1 + \\alpha ) } \\leq \\delta _ { t r } < \\delta _ { t s } | y _ { v } \\in \\mathcal { Y } ^ { t s } \\} } } \\\\ & { } & { \\leq \\mathbb { P } \\{ \\widehat { y } \\in \\mathcal { Y } ^ { t r } | y _ { v } \\in \\mathcal { Y } ^ { t s } \\} . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            209,
+            763,
+            787,
+            818
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We have just shown that for a non-negative $\\alpha$ the probability of misclassifying an image from an unseen class as one of the seen classes is smaller for the decision rule $\\widehat { y } _ { \\alpha }$ than for the original decision rule $\\widehat { y }$ . In fact, we can make a stronger claim. Since $\\delta _ { t s }$ and $\\delta _ { t r }$ are non-negative, it is bclear that the length of interval $[ \\delta _ { t s } / ( 1 + \\alpha ) , \\delta _ { t s } \\overline { { ) } }$ increases as $\\alpha$ increases, and hence probability that $\\delta _ { t r }$ falls in this interval is non-decreasing with increasing $\\alpha$ . Thus we have for any $0 \\leq \\alpha _ { 1 } \\leq \\alpha _ { 2 }$ , $\\mathbb { P } \\{ \\widehat { y } _ { \\alpha _ { 1 } } \\in \\mathcal { Y } ^ { t r } | y _ { v } \\in \\mathcal { Y } ^ { t s } \\} \\geq \\mathbb { P } \\{ \\widehat { y } _ { \\alpha _ { 2 } } \\in \\mathcal { Y } ^ { \\bar { t } r } | y _ { v } \\in \\mathcal { Y } ^ { t s } \\}$ , i.e. $\\mathbb { P } \\{ \\widehat { y } _ { \\alpha } \\in \\mathcal { V } ^ { t r } | y _ { v } \\in \\mathcal { V } ^ { t s } \\}$ is a monotone bnon-increasing function of $\\alpha$ b band we can reduce it by increasing $\\alpha$ . ",
+        "bbox": [
+            173,
+            823,
+            826,
+            921
+        ],
+        "page_idx": 9
+    }
+]

parse/train/SkC_7v5gx/SkC_7v5gx.md

@@ -0,0 +1,305 @@
+# THE POWER OF SPARSITY IN CONVOLUTIONAL NEURAL NETWORKS
+
+Mark Sandler and Andrey Zhmoginov
+
+Soravit Changpinyo ∗ Department of Computer Science University of Southern California Los Angeles, CA 90020, USA schangpi@usc.edu
+
+Google Inc. 1600 Amphitheatre Parkway Mountain View, CA 94043, USA {sandler,azhmogin}@google.com
+
+# ABSTRACT
+
+Deep convolutional networks are well-known for their high computational and memory demands. Given limited resources, how does one design a network that balances its size, training time, and prediction accuracy? A surprisingly effective approach to trade accuracy for size and speed is to simply reduce the number of channels in each convolutional layer by a fixed fraction and retrain the network. In many cases this leads to significantly smaller networks with only minimal changes to accuracy. In this paper, we take a step further by empirically examining a strategy for deactivating connections between filters in convolutional layers in a way that allows us to harvest savings both in run-time and memory for many network architectures. More specifically, we generalize 2D convolution to use a channel-wise sparse connection structure and show that this leads to significantly better results than the baseline approach for large networks including VGG and Inception V3.
+
+# 1 INTRODUCTION
+
+Deep neural networks combined with large-scale labeled data have become a standard recipe for achieving state-of-the-art performance on supervised learning tasks in recent years. Despite of their success, the capability of deep neural networks to model highly nonlinear functions comes with high computational and memory demands both during the model training and inference. In particular, the number of parameters of neural network models is often designed to be huge to account for the scale, diversity, and complexity of data that they learn from. While advances in hardware have somewhat alleviated the issue, network size, speed, and power consumption are all limiting factors when it comes to production deployment on mobile and embedded devices. On the other hand, it is wellknown that there is significant redundancy among the weights of neural networks. For example, Denil et al. (2013) show that it is possible to learn less than $5 \%$ of the network parameters and predict the rest without losing predictive accuracy. This evidence suggests that neural networks are often over-parameterized.
+
+These motivate the research on neural network compression. However, several immediate questions arise: Are these parameters easy to identify? Could we just make the network $5 \%$ of its size and retrain? Or are more advanced methods required? There is an extensive literature in the last few years that explores the question of network compression using advanced techniques, including network prunning, loss-based compression, quantization, and matrix decomposition. We overview many of these directions in the next section. However, there is surprisingly little research on whether this over-parameterization can simply be re-captured by more efficient architectures that could be obtained from original architectures via simple transformations.
+
+Our approach is inspired by a very simple yet successful method called depth multiplier (Howard, 2017). In this method the depth (the number of channels) of each convolutional layer in a given network is simply reduced by a fixed fraction and the network is retrained. We generalize this approach by removing the constraint that every input filter (or channel) must be fully connected to every output filter. Instead, we use a sparse connection matrix, where each output convolution channel is connected only to a small random fraction of the input channels. Note that, for convolutional networks, this still allows for efficient computation since the one channel spatial convolution across the entire plane remains unchanged.
+
+We empirically demonstrate the effectiveness of our approach on four networks (MNIST, CIFAR Net, Inception-V3 and VGG-16) of different sizes. Our results suggest that our approach outperforms dense convolutions with depth multiplier at high compression rates.
+
+For Inception V3 (Szegedy et al., 2016), we show that we can train a network with only about 300K of convolutional parameters1 and about 100M multiply-adds that achieves above $52 \%$ accuracy after it is fully trained. The corresponding depth-multiplier network has only about $41 \%$ accuracy. Another network that we consider is VGG-16n, a slightly modified version of VGG-16 (Simonyan & Zisserman, 2015), with $7 \mathbf { x }$ fewer parameters and similar accuracy.2 We found VGG-16n to start training much faster than the original VGG-16 which was trained incrementally in the original literature. We explore the impact of sparsification and the number of parameters on the quality of the network by building the networks up to $3 0 \mathrm { x }$ smaller than VGG-16n $2 0 0 \mathrm { x }$ smaller than the original VGG-16).
+
+In terms of model flexibility, sparse connections allow for an incremental training approach, where connection structure between layers can be densified as training progresses. More importantly, the incremental training approach can potentially speed up the training significantly due to savings in the early stages of training.
+
+The rest of the paper is organized as follows. Section 2 summarizes relevant work. We describe our approach in Section 3 and then present some intuition in Section 4. Finally, we show our experimental results in Section 5.
+
+# 2 RELATED WORK
+
+# 2.1 COMPRESSION TECHNIQUES FOR NEURAL NETWORKS
+
+Our work is closely related to a compression technique based on network pruning. However, the important difference is that we do not try to select the connections which are redundant. Instead, we just fix a random connectivity pattern and let the network train around it. We also give a brief overview of other two popular techniques: quantization and decomposition, though these directions are not the main focus and could be complementary to our work.
+
+Network pruning Much initial work on neural network compression focuses on removing unimportant connections using weight decay. Hanson & Pratt (1989) introduce hyperbolic and exponential biases to the objective. Optimal Brain Damage (LeCun et al., 1989) and Optimal Brain Surgeon (Hassibi & Stork, 1993) prune the networks based on second-order derivatives of the objectives. Recent work by Han et al. (2015; 2016a) alternates between pruning near-zero weights, which are encouraged by $\ell { 1 }$ or $\ell 2$ regularization, and retraining the pruned networks.
+
+More complex regularizers have also been considered. Wen et al. (2016) and Li et al. (2016) put structured sparsity regularizers on the weights, while Murray & Chiang (2015) put them on the hidden units. Feng & Darrell (2015) explore a nonparametric prior based on the Indian buffet processes (Griffiths & Ghahramani, 2011) on layers. Hu et al. (2016) prune neurons based on the analysis of their outputs on a large dataset. Anwar et al. (2015b) consider special sparsity patterns: channel-wise (removing a feature map/channel from a layer), kernel-wise (removing all connections between two feature maps in consecutive layers), and intra-kernel-strided (removing connections between two features with particular stride and offset). They also propose to use particle filter to decide the importance of connections and paths during training.
+
+Another line of work explores fixed network architectures with some subsets of connections removed. For example, LeCun et al. (1998) remove connections between the first two convolutional feature maps in a completely uniform manner. This is similar to our approach but they only consider a pre-defined pattern in which the same number of input feature map are assigned to each output feature map (Random Connection Table in Torch’s SpatialConvolutionMap function). Further, they do not explore how sparse connections affect performance compared to dense networks. Along a similar vein, Cires¸an et al. (2011) remove random connections in their MNIST experiments. However, they do not try to preserve the spatial convolutional density and it might be a challenge to harvest the savings on existing hardware. Ioannou et al. (2016a) explore three types of hierarchical arrangements of filter groups for CNNs, which depend on different assumptions about co-dependency of filters within each layer. These arrangements include columnar topologies inspired by AlexNet (Krizhevsky et al., 2012), tree-like topologies previously used by Ioannou et al. (2016b), and root-like topologies. Finally, Howard (2017) proposes the depth multiplier method to scale down the number of filters in each convolutional layer by a factor. In this case, depth multiplier can be thought of channel-wise pruning mentioned in (Anwar et al., 2015b). However, depth multiplier modifies the network architectures before training and removes each layer’s feature maps in a uniform manner.
+
+With the exception of (Anwar et al., 2015b; Li et al., 2016; Ioannou et al., 2016a) and depth multiplier (Howard, 2017), the above previous work performs connection pruning that leads to irregular network architectures. Thus, those techniques require additional efforts to represent network connections and might or might not allow for direct computational savings.
+
+Quantization Reducing the degree of redundancy of model parameters can be done in the form of quantization of network parameters. Hwang & Sung (2014); Arora et al. (2014) and Courbariaux et al. (2015; 2016); Rastegari et al. (2016) propose to train CNNs with ternary weights and binary weights, respectively. Gong et al. (2014) use vector quantization for parameters in fully connected layers. Anwar et al. (2015a) quantize a network with the squared error minimization. Chen et al. (2015) randomly group network parameters using a hash function. We note that this technique could be complementary to network pruning. For example, Han et al. (2016a) combine connection pruning in (Han et al., 2015) with quantization and Huffman coding.
+
+Decomposition Another approach is based on low-rank decomposition of the parameters. Decomposition methods include truncated SVD (Denton et al., 2014), decomposition to rank-1 bases (Jaderberg et al., 2014), CP decomposition (PARAFAC or CANDECOMP) (Lebedev et al., 2015), Tensor-Train decomposition of Oseledets (2011) (Novikov et al., 2015), sparse dictionary learning of Mairal et al. (2009) and PCA (Liu et al., 2015), asymmetric (3D) decomposition using reconstruction loss of non-linear responses combined with a rank selection method based on PCA accumulated energy (Zhang et al., 2015b;a), and Tucker decomposition using the kernel tensor reconstruction loss combined with a rank selection method based on global analytic variational Bayesian matrix factorization (Kim et al., 2016).
+
+# 2.2 REGULARIZATION OF NEURAL NETWORKS
+
+Hinton et al. (2012); Srivastava et al. (2014) propose Dropout for regularizing fully connected layers within neural networks layers by randomly setting a subset of activations to zero during training. Wan et al. (2013) later propose DropConnect, a generalization of Dropout that instead randomly sets a subset of weights or connections to zero. Our approach could be thought as related to DropConnect, but (1) we remove connections before training; (2) we focus on connections between convolutional layers; and (3) we kill connections in a more regular manner by restricting connection patterns to be the same along spatial dimensions.
+
+Recently, Han et al. (2016b) and Jin et al. (2016) propose a form of regularization where dropped connections are unfrozen and the network is retrained. This idea is similar to our incremental training approach. However, (1) we do not start with a full network; (2) we do not unfreeze connections all at once; and (3) we preserve regularity of the convolution operation.
+
+# 2.3 NEURAL NETWORK ARCHITECTURES
+
+Network compression and architectures are closely related. The goal of compression is to remove redundancy in network parameters; therefore, the knowledge about traits that determine architecture’s success would be desirable. Other than the discovery that depth is an important factor (Ba & Caruana, 2014), little is known about such traits.
+
+Some previous work performs architecture search but without the main goal of doing compression (Murray & Chiang, 2015; De Brabandere et al., 2016). Recent work proposes shortcut/skip connections to convolutional networks. See, among others, highway networks (Srivastava et al., 2015), residual networks (He et al., 2016a;b), networks with stochastic depth (Huang et al., 2016b), and densely connected convolutional networks (Huang et al., 2016a).
+
+# 3 APPROACH
+
+A CNN architecture consist of (1) convolutional layers, (2) pooling layers, (3) fully connected layers, and (4) a topology that governs how these layers are organized. Given an architecture, our general goal is to transform it into another architecture with a smaller number of parameters. In this paper, we limit ourselves to transformation functions that keep the general topology of the input architecture intact. Moreover, the main focus will be on the convolutional layers and convolution operations, as they impose highest computational and memory burden for most if not all large networks.
+
+# 3.1 DEPTH MULTIPLIER
+
+We first give a description of the depth multiplier method used in Howard (2017). Given a hyperparameter $\alpha \in ( 0 , 1 ]$ , the depth multiplier approach scales down the number of filters in each convolutional layers by $\alpha$ . Note that depth here refers to the third dimension of the activation volume of a single layer, not the number of layers in the whole network.
+
+Let $n _ { l - 1 }$ and $n _ { l }$ be the number of input and output filters at layer $l$ , respectively. After the operation $n _ { l - 1 }$ and $n _ { l }$ become $\lceil \alpha n _ { l - 1 } \rceil$ and $\lceil \alpha n _ { l } \rceil$ and the number of parameters (and the number of multiplications) becomes $\approx \alpha ^ { 2 }$ of the original number.
+
+The result of this operation is a network that is both $1 / \alpha ^ { 2 }$ smaller and faster. Many large networks can be significantly reduced in size using this method with only a small loss of precision (Howard, 2017). It is our belief that this method establishes a strong baseline to which any other advanced techniques should compare themselves. To the best of our knowledge, we are not aware of such comparisons in the literature.
+
+# 3.2 SPARSE RANDOM
+
+Instead of looking at depth multiplier as deactivating channels in the convolutional layers, we can look at it from the perspective of deactivating connections. From this point of view, depth multiplier kills the connections between two convolutional layers such that (a) the connection patterns are still the same across spatial dimensions and (b) all “alive” input channels are fully connected to all “alive” output channels.
+
+We generalize this approach by relaxing (b) while maintaining (a). That is, for every output channel, we connect it to a small subset of input channels. In other words, dense connections between a small number of channels become sparse connections between larger number of channels. This can be summarized in Fig. 1. The advantage of this is that the actual convolution can still be computed efficiently because sparsity is introduced only at the outer loop of the convolution operation and we can still take the advantage of the continuous memory layout. For more details regarding implementations of the two approaches, please refer to the Appendix.
+
+More concretely, let $n _ { l - 1 }$ and $n _ { l }$ be the number of channels of layer $l - 1$ and layer $l$ , respectively. For a sparsity coefficient $\alpha$ , each output filter $j$ only connects to an $\alpha$ fraction of filters of the previous layer. Thus, instead of having a connectivity matrix $W _ { s i j }$ of dimension $k ^ { 2 } \times n _ { l - 1 } \times n _ { l }$ , we have a sparse matrix with non-zero entries at $W _ { s a _ { i j } j }$ , where $a _ { i j }$ is an index matrix of dimension $k ^ { 2 } \times \alpha n _ { l - 1 } \times n _ { l }$ and $k$ is the kernel size.
+
+# 3.2.1 INCREMENTAL TRAINING
+
+In contrast to depth multiplier, a sparse convolutional network defines a connection pattern on a much bigger network. Therefore, an interesting extension is to consider incremental training: we start with a network that only contains a small fraction of connections (in our experiments we use $1 \%$ and $0 . 1 \%$ ) and add connections over time. This is motivated by an intuition that the network can use learned channels in new contexts by introducing additional connections. The potential practical advantage of this approach is that since we start training with very small networks and grow them over time, this approach has a potential to speed up the whole training process significantly. We note that depth multiplier will not benefit from this approach as any newly activated connections would require learning new filters from scratch.
+
+![](images/66fc8a8512a12ff04f8f7dc6aab17648934eff7a1161c2536e3fa54b1fa83cde.jpg)  
+Figure 1: Connection tensors of depth multiplier (left) and sparse random (right) approaches for $n _ { l - 1 } = 5$ and $n _ { l } = 1 0$ . Yellow denotes active connections. For both approaches, the connection pattern is the same across spatial dimension and fixed before training. However, in the sparse random approach, each output channel is connected to a (possibly) different subset of input channels, and vice versa.
+
+# 4 ANALYSIS
+
+In this section, we approach a question of why sparse convolutions are frequently more efficient than the dense convolutions with the same number of parameters. Our main intuition is that the sparse convolutional networks promote diversity. It is much harder to learn equivalent set of channels as, at high sparsity, channels have distinct connection structure or even overlapping connections. This can be formalized with a simple observation that any dense network is in fact a part of an exponentially large equivalence class, which is guaranteed to produce the same output for every input.
+
+Lemma 1 Any dense convolutional neural network with no cross-channel nonlinearities, distinct weights and biases, and with l hidden layers of sizes $n _ { 1 }$ , $n _ { 2 }$ , . . . , $n _ { l }$ , has at least $\textstyle \prod _ { i = 1 } ^ { l } n _ { i } !$ distinct equivalent networks which produce the same output.
+
+Proof Let $I$ denote the input to the network, $C _ { i }$ be the convolutional operator, $\sigma _ { i }$ denote the nonlinearity operator applied to the $i$ -th convolution layer and $S$ be a final transformation (e.g. softmax classifier). We assume that $\sigma _ { i }$ is a function that operates on each of the channels independently. We note that this is the case for almost any modern network. The output of the network can then be written as:
+
+$$
+\mathcal { N } ( I ) \equiv S \circ \sigma _ { l } \circ C _ { l } \circ \sigma _ { l - 1 } \circ \cdots \circ \sigma _ { 1 } \circ C _ { 1 } ( I )
+$$
+
+where we use $\circ$ to denote function composition to avoid numerous parentheses. The convolution operator $C _ { i }$ operates on input with $n _ { i - 1 }$ channels and produces an output with $n _ { i }$ channels. Now, fix arbitrary set of permutation functions $\pi _ { i }$ , where $\pi _ { i }$ can permute depth of size $n _ { i }$ . Since $\pi _ { i }$ is a linear function, it follows that $C _ { i } ^ { \prime } = \pi _ { i } ^ { - 1 } C _ { i } \pi _ { i - 1 }$ is a valid convolutional operator, which can be obtained from $C _ { i }$ by permuting its bias according to $\pi _ { i }$ and its weight matrix along input and output dimensions according to $\pi _ { i - 1 }$ and $\pi _ { i }$ respectively. For a new network defined as:
+
+$$
+\mathcal { N } ^ { \prime } ( I ) = S ^ { \prime } \circ \sigma _ { l } \circ C _ { l } ^ { \prime } \circ \sigma _ { l - 1 } \circ \cdots \circ \sigma _ { 1 } \circ C _ { 1 } ^ { \prime } ( I ) ,
+$$
+
+where $\pi _ { 0 }$ is an identity operator and $S ^ { \prime } \equiv S \circ \pi _ { l }$ , we claim that $\mathcal { N } ^ { \prime } ( I ) \equiv \mathcal { N } ( I )$ . Indeed, since nonlinearities do not apply cross-depth we have $\pi _ { n } \sigma _ { n } \pi _ { n } ^ { - 1 } \equiv \sigma _ { n }$ and thus:
+
+$$
+\begin{array} { r l } & { \mathscr { N } ^ { \prime } ( I ) = S ^ { \prime } \circ \sigma _ { l } \circ C _ { l } ^ { \prime } \circ \sigma _ { l - 1 } \circ \cdots \circ \sigma _ { 1 } \circ C _ { 1 } ^ { \prime } ( I ) = } \\ & { \qquad = S \circ \pi _ { l } \circ \sigma _ { l } \circ \pi _ { l } ^ { - 1 } \circ C _ { l } \circ \pi _ { l - 1 } \circ \cdots \circ \pi _ { 1 } \circ \sigma _ { 1 } \circ \pi _ { 1 } ^ { - 1 } \circ C _ { 1 } ( I ) = \mathscr { N } ( I ) . } \end{array}
+$$
+
+Thus, any set of permutations on hidden units defines an equivalent network.
+
+It is obvious that sparse networks are much more immune to parameter permutation – indeed every channel at layer $l$ is likely to have a unique tree describing its connection matrix all the way down. Exploring this direction is an interesting open question.
+
+# 5 EXPERIMENTS
+
+In this section, we demonstrate the effectiveness of the sparse random approach by comparing it to the depth multiplier approach at different compression rates. Moreover, we examine several settings in the incremental training where connections gradually become active during the training process.
+
+# 5.1 SETUP
+
+Networks and Datasets Our experiments are conducted on 4 networks for 3 different datasets.   
+All our experiments use open-source TensorFlow networks Abadi et al. (2015).
+
+MNIST AND CIFAR-10 We use standard networks provided by TensorFlow. For MNIST, it has 3-layer convolutional layers and achieves $9 9 . 5 \%$ accuracy when fully trained. For CIFAR-10, it has 2 convolutional layers and achieves $87 \%$ accuracy.
+
+IMAGENET We use open source Inception-V3 (Szegedy et al., 2016) network and a slightly modified version of VGG-16 (Simonyan & Zisserman, 2015) called VGG-16n on ImageNet ILSVRC 2012 (Deng et al., 2009; Russakovsky et al., 2015).
+
+Random connections Connections are activated according to their likelihood from the uniform distribution. In addition, they are activated in such a way that there are no connections going in or coming out of dead filters (i.e., any connection must have a path to input image and a path to the final prediction.). All connections in fully connected layers are retained.
+
+Implementation details All code is implemented in TensorFlow (Abadi et al., 2015). Deactivating connections is done by applying masks to parameter tensors. The Inception-v3 and VGG-16n networks are trained on 8 Tesla K80 GPUs, each with batch size 256 (32 per gpu) and batch normalization was used for all networks.
+
+5.2 COMPARISON BETWEEN SPARSE RANDOM AND DEPTH MULTIPLIER
+
+# 5.2.1 MNIST AND CIFAR-10
+
+We first compare depth multiplier and sparse random for the two small networks on MNIST and CIFAR-10. We compare the accuracy of the two approaches when the numbers of connections are roughly the same, based on a hyperparameter $\alpha$ . For dense convolutions, we pick a multiplier $\alpha$ and each filter depth is scaled down by $\sqrt { \alpha }$ and then rounded up. In sparse convolutions, a fraction $\alpha$ of connections are randomly deactivated if those parameters connect at least two filters on each layer; otherwise, a fraction of $\sqrt { \alpha }$ is used instead if the parameters connect layers with only one filter left. The accuracy numbers are averaged over 5 rounds for MNIST and 2 rounds on CIFAR-10.
+
+We show in Fig. 2 and Fig. 3 that the sparse networks have comparable or higher accuracy for the same number of parameters, with comparable accuracy at higher density. We note however that these networks are so small that at high compression rates most of operations are concentrated at the first layer, which is negligible for large networks. Moreover, in MNIST example, the size of network changes most dramatically from 2000 to 2 million parameters, while affecting accuracy only by $1 \%$ . This observation suggests that there might be benefits of maintaining the number of filters to be high and/or breaking the symmetry of connections. We explore this in the next section.
+
+# 5.2.2 INCEPTION-V3 ON IMAGENET
+
+We consider different values of sparsity ranging from 0.003 to 1, and depth multiplier from 0.05 to 1. Our experiments show (see Table 1 and Fig. 4) significant advantage of sparse networks over equivalently sized dense networks. We note that due to time constraints the reported quantitative numbers are preliminary, as the networks have not finished converging. We expect the final numbers to match the reported number for Inception V3 Szegedy et al. (2016), and the smaller networks to have comparable improvement.
+
+![](images/65926ca6ffb9b876a5add68d622ccc4f1c7a0fd94934ef67cf453485cb422141.jpg)  
+Figure 2: Comparison of accuracy (averaged over 5 rounds) vs. Number of parameters/Number of multiply-adds between dense and sparse convolutions on MNIST dataset. Note that though sparse convolution result in better parameter trade-off curve, the multiply-add curve shows the opposite pattern.
+
+Table 1: Inception V3: Preliminary quantitative results after 100 Epochs. Note the smallest sparse network is actually a hybrid network - we used both depth multiplier (0.5) and sparsity (0.01). The number of parameters is the number of parameters excluding the softmax layer.
+
+Accuracy for sparse convolutions   
+
+<table><tr><td>Sparsity</td><td>MAdds Params</td><td>P@1</td></tr><tr><td>0.50/0.01 0.003</td><td>43.0M 90k 158k</td><td>40.3 46.1</td></tr><tr><td>0.01</td><td>82.0M 104M</td><td>52.3</td></tr><tr><td>0.03</td><td>287k 208M 724k</td><td></td></tr><tr><td>0.10</td><td></td><td>59.5</td></tr><tr><td>0.30</td><td>628M 2.3 M</td><td>67.2</td></tr><tr><td></td><td>1.80 B 6.6M</td><td>73</td></tr><tr><td>0.60</td><td>3.50B 13M 22 M</td><td>75</td></tr><tr><td>1.00</td><td>5.70 B</td><td>77</td></tr></table>
+
+Accuracy for Depth Multiplier   
+
+<table><tr><td>Multiplier</td><td>MAdds</td><td>Params P@1</td></tr><tr><td>0.05</td><td>55.0M 56k</td><td>24.6</td></tr><tr><td>0.10</td><td>75.0M</td><td>170k 38.6</td></tr><tr><td>0.20</td><td>183M 718k</td><td>54.2</td></tr><tr><td>0.30</td><td>439M 1.8M</td><td>64.0</td></tr><tr><td>0.50</td><td>1.40B 5.4M</td><td>72.3</td></tr><tr><td>0.80</td><td>3.40B 13M</td><td>75.6</td></tr></table>
+
+Original network: 5.70 B 22 M 77 (78.8)
+
+# 5.2.3 VGG-16 ON IMAGENET
+
+In our experiments with the VGG-16 network (Simonyan & Zisserman, 2015), we modify the model architecture (calling it VGG-16n) by removing the two fully-connected layers with depth 4096 and replacing them with a $2 \times 2$ maxpool layer followed by a $3 \times 3$ convolutional layer with the depth of 1024. This alone sped up our training significantly. The comparison between depth multiplier and sparse connection approaches is shown in Fig. 5. The modified VGG-16n network has about 7 times fewer parameters, but appears to have comparable precision.
+
+![](images/f4cf6c184c4020dc5874321b477ae62c97ddf25c9d68322157c1a605a04d32e7.jpg)  
+Figure 3: Comparison of accuracy (averaged over 2 rounds) vs. Number of parameters/Number of multiply-adds between dense and sparse convolutions on CIFAR-10 dataset.
+
+![](images/1cf4cc4464141afef87dfda693d69954f6e151da17bb74348a13d18643a16d98.jpg)  
+Figure 4: Inception V3: Comparison of Precision $@ 1$ vs. Number of parameters/Number of multiply-adds between dense and sparse convolutions on ImageNet/Inception-V3. The full network corresponds to the right-most point of the curve.
+
+![](images/a57e0b1ff2bb1e2c18547e1723279c8b784b21823938c56fcb8383c2d7879efa.jpg)  
+Figure 5: VGG 16: Preliminary Quantitative Results. Comparison of Precision $@ 1$ vs. Number of parameters/Number of multiply-adds between dense and sparse convolutions on ImageNet/VGG16n. The full network corresponds to the right-most point of the curve. Original VGG-16 as described in Simonyan & Zisserman (2015) (blue star) and the same model trained by us from scratch (red cross) are also shown.
+
+# 5.3 INCREMENTAL TRAINING
+
+![](images/f704c8a1c6906e9b1cd74e0b702c578d2acd95067c474ee8b78c09edf9df95a7.jpg)  
+Figure 6: Incremental Training Of Inception V3: We show Precision $@ 1$ during the training process, where the networks densify over time. The saturation points show where the networks actually reach their full density.
+
+Finally, we show that incremental training is a promising direction. We start with a very sparse model and increase its density over time, using the approach described in Sect. 3.2.1. We note that a naive approach where we simply add filters results in training process basically equivalent to as if it started from scratch in every step. On the other hand, when the network densifies over time, all channels already possess some discriminative power and that information is utilized.
+
+In our experiments, we initially start training Inception-V3 with only $1 \%$ or $0 . 1 \%$ of connections enabled. Then, we double the number of connections every $T$ steps. We use $T = 1 0 , 0 0 0$ , $T =$ 25, 000 and $T = 5 0 , 0 0 0$ . The results are presented in Fig. 6. We show that the networks trained with the incremental approach regardless of the doubling period can catch up with the full Inception-V3 network (in some cases with small gains). Moreover, they recover very quickly from adding more (untrained) connections. In fact, the recovery is so fast that it is shorter than our saving interval for all the networks except for the network with 10K doubling period (resulting in the sharp drop). We believe that incremental training is a promising direction to speeding up the training of large convolutional neural networks since early stages of the training require much less computation.
+
+# 6 CONCLUSION
+
+We have proposed a new compression technique that uses a sparse random connection structure between input-output filters in convolutional layers of CNNs. We fix this structure before training and use the same structure across spatial dimensions to harvest savings from modern hardware. We show that this approach is especially useful at very high compression rates for large networks. For example, this simple method when applied to Inception V3 (Fig. 4), achieves AlexNet-level accuracy (Krizhevsky et al., 2012) with fewer than 400K parameters and VGG-level one (Fig. 5) with roughly $3 . 5 \mathrm { M }$ parameters. The simplicity of our approach is instructive in that it establishes a strong baseline to compare against when developing more advanced techniques. On the other hand, the uncanny match in performance of dense and equivalently-sized sparse networks with sparsity $> 0 . 1$ suggests that there might be some fundamental property of network architectures that is controlled by the number of parameters, regardless of how they are organized. Exploring this further might yield additional insights on understanding neural networks.
+
+In addition, we show that our method leads to an interesting novel incremental training technique, where we take advantage of sparse (and smaller) models to build a dense network. One interesting open direction is to enable incremental training not to simply densify the network over time, but also increase the number of channels. This would allow us to grow the network without having to fix its original shape in place.
+
+# REFERENCES
+
+Mart´ın Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Greg S. Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Ian Goodfellow, Andrew Harp, Geoffrey Irving, Michael Isard, Yangqing Jia, Rafal Jozefowicz, Lukasz Kaiser, Manjunath Kudlur, Josh Levenberg, Dan Mane, Rajat Monga, Sherry Moore, Derek Murray, Chris Olah, Mike Schuster, Jonathon Shlens, Benoit ´ Steiner, Ilya Sutskever, Kunal Talwar, Paul Tucker, Vincent Vanhoucke, Vijay Vasudevan, Fernanda Viegas, ´ Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng. TensorFlow: Large-scale machine learning on heterogeneous systems, 2015. URL http://tensorflow.org/. Software available from tensorflow.org.
+
+Sajid Anwar, Kyuyeon Hwang, and Wonyong Sung. Fixed point optimization of deep convolutional neural networks for object recognition. In ICASSP, 2015a.
+
+Sajid Anwar, Kyuyeon Hwang, and Wonyong Sung. Structured pruning of deep convolutional neural networks. arXiv preprint arXiv:1512.08571, 2015b.
+
+Sanjeev Arora, Aditya Bhaskara, Rong Ge, and Tengyu Ma. Provable bounds for learning some deep representations. In ICML, 2014.
+
+Jimmy Ba and Rich Caruana. Do deep nets really need to be deep? In NIPS, 2014.
+
+Wenlin Chen, James T. Wilson, Stephen Tyree, Kilian Q. Weinberger, and Yixin Chen. Compressing neural networks with the hashing trick. In ICML, 2015.
+
+Dan C. Cires¸an, Ueli Meier, Jonathan Masci, Luca M. Gambardella, and Jurgen Schmidhuber. High- ¨ performance neural networks for visual object classification. arXiv preprint arXiv:1102.0183, 2011.   
+Matthieu Courbariaux, Yoshua Bengio, and Jean-Pierre David. Binaryconnect: Training deep neural networks with binary weights during propagations. In NIPS, 2015.   
+Matthieu Courbariaux, Itay Hubara, Daniel Soudry, Ran El-Yaniv, and Yoshua Bengio. Binarized neural networks: Training deep neural networks with weights and activations constrained to $+ 1$ or -1. arXiv preprint arXiv:1602.02830, 2016.   
+Bert De Brabandere, Xu Jia, Tinne Tuytelaars, and Luc Van Gool. Dynamic filter networks. In NIPS, 2016.   
+Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In CVPR, 2009.   
+Misha Denil, Babak Shakibi, Laurent Dinh, Marc Aurelio Ranzato, and Nando de Freitas. Predicting parameters in deep learning. In NIPS, 2013.   
+Emily L. Denton, Wojciech Zaremba, Joan Bruna, Yann LeCun, and Rob Fergus. Exploiting linear structure within convolutional networks for efficient evaluation. In NIPS, 2014.   
+Jiashi Feng and Trevor Darrell. Learning the structure of deep convolutional networks. In ICCV, 2015.   
+Yunchao Gong, Liu Liu, Ming Yang, and Lubomir Bourdev. Compressing deep convolutional networks using vector quantization. arXiv preprint arXiv:1412.6115, 2014.   
+Thomas L. Griffiths and Zoubin Ghahramani. The indian buffet process: An introduction and review. Journal of Machine Learning Research, 12(Apr):1185–1224, 2011.   
+Song Han, Jeff Pool, John Tran, and William Dally. Learning both weights and connections for efficient neural network. In NIPS, 2015.   
+Song Han, Huizi Mao, and William J. Dally. Deep compression: Compressing deep neural network with pruning, trained quantization and huffman coding. In ICLR, 2016a.   
+Song Han, Jeff Pool, Sharan Narang, Huizi Mao, Shijian Tang, Erich Elsen, Bryan Catanzaro, John Tran, and William J. Dally. Dsd: Regularizing deep neural networks with dense-sparse-dense training flow. arXiv preprint arXiv:1607.04381, 2016b.   
+Stephen Jose Hanson and Lorien Y. Pratt. Comparing biases for minimal network construction with back- ´ propagation. In NIPS, 1989.   
+Babak Hassibi and David G. Stork. Second order derivatives for network pruning: Optimal brain surgeon. In NIPS, 1993.   
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016a.   
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Identity mappings in deep residual networks. In ECCV, 2016b.   
+Geoffrey E. Hinton, Nitish Srivastava, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Improving neural networks by preventing co-adaptation of feature detectors. arXiv preprint arXiv:1207.0580, 2012.   
+Andrew G. Howard. Mobilenets: Efficient convolutional neural networks for mobile vision applications. In forthcoming, 2017.   
+Hengyuan Hu, Rui Peng, Yu-Wing Tai, and Chi-Keung Tang. Network trimming: A data-driven neuron pruning approach towards efficient deep architectures. arXiv preprint arXiv:1607.03250, 2016.   
+Gao Huang, Zhuang Liu, and Kilian Q. Weinberger. Densely connected convolutional networks. arXiv preprint arXiv:1608.06993, 2016a.   
+Gao Huang, Yu Sun, Zhuang Liu, Daniel Sedra, and Kilian Weinberger. Deep networks with stochastic depth. arXiv preprint arXiv:1603.09382, 2016b.   
+Kyuyeon Hwang and Wonyong Sung. Fixed-point feedforward deep neural network design using weights $+ 1$ , 0, and -1. In IEEE Workshop on Signal Processing Systems (SiPS), 2014.
+
+Yani Ioannou, Duncan Robertson, Roberto Cipolla, and Antonio Criminisi. Deep roots: Improving cnn efficiency with hierarchical filter groups. arXiv preprint arXiv:1605.06489, 2016a.
+
+Yani Ioannou, Duncan Robertson, Jamie Shotton, Roberto Cipolla, and Antonio Criminisi. Training cnns with low-rank filters for efficient image classification. In ICLR, 2016b.
+
+Max Jaderberg, Andrea Vedaldi, and Andrew Zisserman. Speeding up convolutional neural networks with low rank expansions. In BMVC, 2014.
+
+Xiaojie Jin, Xiaotong Yuan, Jiashi Feng, and Shuicheng Yan. Training skinny deep neural networks with iterative hard thresholding methods. arXiv preprint arXiv:1607.05423, 2016.
+
+Yong-Deok Kim, Eunhyeok Park, Sungjoo Yoo, Taelim Choi, Lu Yang, and Dongjun Shin. Compression of deep convolutional neural networks for fast and low power mobile applications. In ICLR, 2016.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E. Hinton. Imagenet classification with deep convolutional neural networks. In NIPS, 2012.
+
+Vadim Lebedev, Yaroslav Ganin, Maksim Rakhuba, Ivan Oseledets, and Victor Lempitsky. Speeding-up convolutional neural networks using fine-tuned cp-decomposition. In ICLR, 2015.
+
+Yann LeCun, John S. Denker, Sara A. Solla, Richard E. Howard, and Lawrence D. Jackel. Optimal brain damage. In NIPS, 1989.
+
+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.
+
+Hao Li, Asim Kadav, Igor Durdanovic, Hanan Samet, and Hans Peter Graf. Pruning filters for efficient convnets. arXiv preprint arXiv:1608.08710, 2016.
+
+Baoyuan Liu, Min Wang, Hassan Foroosh, Marshall Tappen, and Marianna Pensky. Sparse convolutional neural networks. In CVPR, 2015.
+
+Julien Mairal, Francis Bach, Jean Ponce, and Guillermo Sapiro. Online dictionary learning for sparse coding. In ICML, 2009.
+
+Kenton Murray and David Chiang. Auto-sizing neural networks: With applications to n-gram language models. In EMNLP, 2015.
+
+Alexander Novikov, Dmitrii Podoprikhin, Anton Osokin, and Dmitry P. Vetrov. Tensorizing neural networks. In NIPS, 2015.
+
+Ivan V. Oseledets. Tensor-train decomposition. SIAM Journal on Scientific Computing, 33(5):2295–2317, 2011.
+
+Mohammad Rastegari, Vicente Ordonez, Joseph Redmon, and Ali Farhadi. Xnor-net: Imagenet classification using binary convolutional neural networks. In ECCV, 2016.
+
+Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, et al. Imagenet large scale visual recognition challenge. International Journal of Computer Vision, 115(3):211–252, 2015.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. In ICLR, 2015.
+
+Nitish Srivastava, Geoffrey E. Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: a simple way to prevent neural networks from overfitting. Journal of Machine Learning Research, 15(1): 1929–1958, 2014.
+
+Rupesh K. Srivastava, Klaus Greff, and Jurgen Schmidhuber. Training very deep networks. In ¨ NIPS, 2015.
+
+Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jonathon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. In CVPR, 2016.
+
+Li Wan, Matthew Zeiler, Sixin Zhang, Yann LeCun, and Rob Fergus. Regularization of neural networks using dropconnect. In ICML, 2013.
+
+Wei Wen, Chunpeng Wu, Yandan Wang, Yiran Chen, and Hai Li. Learning structured sparsity in deep neural networks. In NIPS, 2016.
+
+Xiangyu Zhang, Jianhua Zou, Kaiming He, and Jian Sun. Accelerating very deep convolutional networks for classification and detection. IEEE Transactions on Pattern Analysis and Machine Intelligence, 2015a.
+
+Xiangyu Zhang, Jianhua Zou, Xiang Ming, Kaiming He, and Jian Sun. Efficient and accurate approximations of nonlinear convolutional networks. In CVPR, 2015b.
+
+# A ADDITIONAL DETAILS ON DENSE VS. SPARSE CONVOLUTIONS
+
+We contrast naive implementations of dense and sparse convolutions (cf. Sect. 3) in Algorithm. 1 and Algorithm 2. We emphasize that we do not use sparse matrices and only introduce sparsity from channel to channel. Thus, walltime will be mostly in terms of Multiply-Adds; the basic operation (convolving the entire image plane in Line 8 of both algorithms) is unchanged.
+
+# Algorithm 1 Naive implementation of dense convolution
+
+1: Inputs:   
+2: - input: Data tensor   
+3: - W : Parameter tensor   
+4: - input channels: Array of input channel IDs   
+5: - output channels: Array of output channel IDs   
+6: for $i$ in input channels do   
+7: for $o$ in output channels do   
+8: $o u t p u t [ o ] \gets o u t p u t [ o ] + \mathrm { c o n v o l v e } ( i n p u t [ i ] , W [ i , o , . . . ] )$   
+9: end for   
+10: end for   
+11: return output
+
+Algorithm 2 Naive implementation of sparse convolution
+
+1: Inputs:   
+2: - input: Data tensor   
+3: - W : Parameter tensor   
+4: - input channels: Array of input channel IDs   
+5: - output channels connected to i: Array of array of output channel IDs specifying connec  
+tions to each input channel   
+6: for $i$ in input channels do   
+7: for index, $o$ in enumerate(output channels connected to i[i]) do   
+8: output[o] $\gets$ output[o] $^ +$ convolve(input[i], W [i, index, . . .])   
+9: end for   
+10: end for   
+11: return output

parse/train/SkC_7v5gx/SkC_7v5gx_content_list.json

@@ -0,0 +1,1450 @@
+[
+    {
+        "type": "text",
+        "text": "THE POWER OF SPARSITY IN CONVOLUTIONAL NEURAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            99,
+            647,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Mark Sandler and Andrey Zhmoginov ",
+        "bbox": [
+            478,
+            171,
+            743,
+            184
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Soravit Changpinyo ∗ Department of Computer Science University of Southern California Los Angeles, CA 90020, USA schangpi@usc.edu ",
+        "bbox": [
+            183,
+            170,
+            405,
+            239
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Google Inc. 1600 Amphitheatre Parkway Mountain View, CA 94043, USA {sandler,azhmogin}@google.com ",
+        "bbox": [
+            478,
+            186,
+            759,
+            239
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            276,
+            544,
+            291
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep convolutional networks are well-known for their high computational and memory demands. Given limited resources, how does one design a network that balances its size, training time, and prediction accuracy? A surprisingly effective approach to trade accuracy for size and speed is to simply reduce the number of channels in each convolutional layer by a fixed fraction and retrain the network. In many cases this leads to significantly smaller networks with only minimal changes to accuracy. In this paper, we take a step further by empirically examining a strategy for deactivating connections between filters in convolutional layers in a way that allows us to harvest savings both in run-time and memory for many network architectures. More specifically, we generalize 2D convolution to use a channel-wise sparse connection structure and show that this leads to significantly better results than the baseline approach for large networks including VGG and Inception V3. ",
+        "bbox": [
+            233,
+            308,
+            764,
+            488
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            510,
+            336,
+            525
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep neural networks combined with large-scale labeled data have become a standard recipe for achieving state-of-the-art performance on supervised learning tasks in recent years. Despite of their success, the capability of deep neural networks to model highly nonlinear functions comes with high computational and memory demands both during the model training and inference. In particular, the number of parameters of neural network models is often designed to be huge to account for the scale, diversity, and complexity of data that they learn from. While advances in hardware have somewhat alleviated the issue, network size, speed, and power consumption are all limiting factors when it comes to production deployment on mobile and embedded devices. On the other hand, it is wellknown that there is significant redundancy among the weights of neural networks. For example, Denil et al. (2013) show that it is possible to learn less than $5 \\%$ of the network parameters and predict the rest without losing predictive accuracy. This evidence suggests that neural networks are often over-parameterized. ",
+        "bbox": [
+            174,
+            540,
+            825,
+            705
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "These motivate the research on neural network compression. However, several immediate questions arise: Are these parameters easy to identify? Could we just make the network $5 \\%$ of its size and retrain? Or are more advanced methods required? There is an extensive literature in the last few years that explores the question of network compression using advanced techniques, including network prunning, loss-based compression, quantization, and matrix decomposition. We overview many of these directions in the next section. However, there is surprisingly little research on whether this over-parameterization can simply be re-captured by more efficient architectures that could be obtained from original architectures via simple transformations. ",
+        "bbox": [
+            174,
+            713,
+            825,
+            824
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Our approach is inspired by a very simple yet successful method called depth multiplier (Howard, 2017). In this method the depth (the number of channels) of each convolutional layer in a given network is simply reduced by a fixed fraction and the network is retrained. We generalize this approach by removing the constraint that every input filter (or channel) must be fully connected to every output filter. Instead, we use a sparse connection matrix, where each output convolution channel is connected only to a small random fraction of the input channels. Note that, for convolutional networks, this still allows for efficient computation since the one channel spatial convolution across the entire plane remains unchanged. ",
+        "bbox": [
+            174,
+            832,
+            823,
+            901
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We empirically demonstrate the effectiveness of our approach on four networks (MNIST, CIFAR Net, Inception-V3 and VGG-16) of different sizes. Our results suggest that our approach outperforms dense convolutions with depth multiplier at high compression rates. ",
+        "bbox": [
+            176,
+            152,
+            821,
+            195
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "For Inception V3 (Szegedy et al., 2016), we show that we can train a network with only about 300K of convolutional parameters1 and about 100M multiply-adds that achieves above $52 \\%$ accuracy after it is fully trained. The corresponding depth-multiplier network has only about $41 \\%$ accuracy. Another network that we consider is VGG-16n, a slightly modified version of VGG-16 (Simonyan & Zisserman, 2015), with $7 \\mathbf { x }$ fewer parameters and similar accuracy.2 We found VGG-16n to start training much faster than the original VGG-16 which was trained incrementally in the original literature. We explore the impact of sparsification and the number of parameters on the quality of the network by building the networks up to $3 0 \\mathrm { x }$ smaller than VGG-16n $2 0 0 \\mathrm { x }$ smaller than the original VGG-16). ",
+        "bbox": [
+            174,
+            202,
+            825,
+            325
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In terms of model flexibility, sparse connections allow for an incremental training approach, where connection structure between layers can be densified as training progresses. More importantly, the incremental training approach can potentially speed up the training significantly due to savings in the early stages of training. ",
+        "bbox": [
+            174,
+            334,
+            825,
+            390
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The rest of the paper is organized as follows. Section 2 summarizes relevant work. We describe our approach in Section 3 and then present some intuition in Section 4. Finally, we show our experimental results in Section 5. ",
+        "bbox": [
+            176,
+            397,
+            825,
+            438
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            454,
+            344,
+            469
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 COMPRESSION TECHNIQUES FOR NEURAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            486,
+            588,
+            500
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our work is closely related to a compression technique based on network pruning. However, the important difference is that we do not try to select the connections which are redundant. Instead, we just fix a random connectivity pattern and let the network train around it. We also give a brief overview of other two popular techniques: quantization and decomposition, though these directions are not the main focus and could be complementary to our work. ",
+        "bbox": [
+            174,
+            512,
+            825,
+            582
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Network pruning Much initial work on neural network compression focuses on removing unimportant connections using weight decay. Hanson & Pratt (1989) introduce hyperbolic and exponential biases to the objective. Optimal Brain Damage (LeCun et al., 1989) and Optimal Brain Surgeon (Hassibi & Stork, 1993) prune the networks based on second-order derivatives of the objectives. Recent work by Han et al. (2015; 2016a) alternates between pruning near-zero weights, which are encouraged by $\\ell { 1 }$ or $\\ell 2$ regularization, and retraining the pruned networks. ",
+        "bbox": [
+            174,
+            594,
+            825,
+            678
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "More complex regularizers have also been considered. Wen et al. (2016) and Li et al. (2016) put structured sparsity regularizers on the weights, while Murray & Chiang (2015) put them on the hidden units. Feng & Darrell (2015) explore a nonparametric prior based on the Indian buffet processes (Griffiths & Ghahramani, 2011) on layers. Hu et al. (2016) prune neurons based on the analysis of their outputs on a large dataset. Anwar et al. (2015b) consider special sparsity patterns: channel-wise (removing a feature map/channel from a layer), kernel-wise (removing all connections between two feature maps in consecutive layers), and intra-kernel-strided (removing connections between two features with particular stride and offset). They also propose to use particle filter to decide the importance of connections and paths during training. ",
+        "bbox": [
+            174,
+            684,
+            825,
+            810
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Another line of work explores fixed network architectures with some subsets of connections removed. For example, LeCun et al. (1998) remove connections between the first two convolutional feature maps in a completely uniform manner. This is similar to our approach but they only consider a pre-defined pattern in which the same number of input feature map are assigned to each output feature map (Random Connection Table in Torch’s SpatialConvolutionMap function). Further, they do not explore how sparse connections affect performance compared to dense networks. Along a similar vein, Cires¸an et al. (2011) remove random connections in their MNIST experiments. However, they do not try to preserve the spatial convolutional density and it might be a challenge to harvest the savings on existing hardware. Ioannou et al. (2016a) explore three types of hierarchical arrangements of filter groups for CNNs, which depend on different assumptions about co-dependency of filters within each layer. These arrangements include columnar topologies inspired by AlexNet (Krizhevsky et al., 2012), tree-like topologies previously used by Ioannou et al. (2016b), and root-like topologies. Finally, Howard (2017) proposes the depth multiplier method to scale down the number of filters in each convolutional layer by a factor. In this case, depth multiplier can be thought of channel-wise pruning mentioned in (Anwar et al., 2015b). However, depth multiplier modifies the network architectures before training and removes each layer’s feature maps in a uniform manner. ",
+        "bbox": [
+            176,
+            818,
+            821,
+            859
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            297
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "With the exception of (Anwar et al., 2015b; Li et al., 2016; Ioannou et al., 2016a) and depth multiplier (Howard, 2017), the above previous work performs connection pruning that leads to irregular network architectures. Thus, those techniques require additional efforts to represent network connections and might or might not allow for direct computational savings. ",
+        "bbox": [
+            174,
+            304,
+            823,
+            361
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Quantization Reducing the degree of redundancy of model parameters can be done in the form of quantization of network parameters. Hwang & Sung (2014); Arora et al. (2014) and Courbariaux et al. (2015; 2016); Rastegari et al. (2016) propose to train CNNs with ternary weights and binary weights, respectively. Gong et al. (2014) use vector quantization for parameters in fully connected layers. Anwar et al. (2015a) quantize a network with the squared error minimization. Chen et al. (2015) randomly group network parameters using a hash function. We note that this technique could be complementary to network pruning. For example, Han et al. (2016a) combine connection pruning in (Han et al., 2015) with quantization and Huffman coding. ",
+        "bbox": [
+            174,
+            375,
+            825,
+            486
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Decomposition Another approach is based on low-rank decomposition of the parameters. Decomposition methods include truncated SVD (Denton et al., 2014), decomposition to rank-1 bases (Jaderberg et al., 2014), CP decomposition (PARAFAC or CANDECOMP) (Lebedev et al., 2015), Tensor-Train decomposition of Oseledets (2011) (Novikov et al., 2015), sparse dictionary learning of Mairal et al. (2009) and PCA (Liu et al., 2015), asymmetric (3D) decomposition using reconstruction loss of non-linear responses combined with a rank selection method based on PCA accumulated energy (Zhang et al., 2015b;a), and Tucker decomposition using the kernel tensor reconstruction loss combined with a rank selection method based on global analytic variational Bayesian matrix factorization (Kim et al., 2016). ",
+        "bbox": [
+            173,
+            500,
+            825,
+            625
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 REGULARIZATION OF NEURAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            638,
+            513,
+            654
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Hinton et al. (2012); Srivastava et al. (2014) propose Dropout for regularizing fully connected layers within neural networks layers by randomly setting a subset of activations to zero during training. Wan et al. (2013) later propose DropConnect, a generalization of Dropout that instead randomly sets a subset of weights or connections to zero. Our approach could be thought as related to DropConnect, but (1) we remove connections before training; (2) we focus on connections between convolutional layers; and (3) we kill connections in a more regular manner by restricting connection patterns to be the same along spatial dimensions. ",
+        "bbox": [
+            174,
+            666,
+            823,
+            763
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Recently, Han et al. (2016b) and Jin et al. (2016) propose a form of regularization where dropped connections are unfrozen and the network is retrained. This idea is similar to our incremental training approach. However, (1) we do not start with a full network; (2) we do not unfreeze connections all at once; and (3) we preserve regularity of the convolution operation. ",
+        "bbox": [
+            174,
+            770,
+            823,
+            827
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.3 NEURAL NETWORK ARCHITECTURES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            840,
+            468,
+            854
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Network compression and architectures are closely related. The goal of compression is to remove redundancy in network parameters; therefore, the knowledge about traits that determine architecture’s success would be desirable. Other than the discovery that depth is an important factor (Ba & Caruana, 2014), little is known about such traits. ",
+        "bbox": [
+            176,
+            867,
+            823,
+            922
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Some previous work performs architecture search but without the main goal of doing compression (Murray & Chiang, 2015; De Brabandere et al., 2016). Recent work proposes shortcut/skip connections to convolutional networks. See, among others, highway networks (Srivastava et al., 2015), residual networks (He et al., 2016a;b), networks with stochastic depth (Huang et al., 2016b), and densely connected convolutional networks (Huang et al., 2016a). ",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 APPROACH",
+        "text_level": 1,
+        "bbox": [
+            174,
+            188,
+            299,
+            204
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "A CNN architecture consist of (1) convolutional layers, (2) pooling layers, (3) fully connected layers, and (4) a topology that governs how these layers are organized. Given an architecture, our general goal is to transform it into another architecture with a smaller number of parameters. In this paper, we limit ourselves to transformation functions that keep the general topology of the input architecture intact. Moreover, the main focus will be on the convolutional layers and convolution operations, as they impose highest computational and memory burden for most if not all large networks. ",
+        "bbox": [
+            174,
+            218,
+            825,
+            301
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 DEPTH MULTIPLIER ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            314,
+            351,
+            327
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We first give a description of the depth multiplier method used in Howard (2017). Given a hyperparameter $\\alpha \\in ( 0 , 1 ]$ , the depth multiplier approach scales down the number of filters in each convolutional layers by $\\alpha$ . Note that depth here refers to the third dimension of the activation volume of a single layer, not the number of layers in the whole network. ",
+        "bbox": [
+            174,
+            340,
+            825,
+            396
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Let $n _ { l - 1 }$ and $n _ { l }$ be the number of input and output filters at layer $l$ , respectively. After the operation $n _ { l - 1 }$ and $n _ { l }$ become $\\lceil \\alpha n _ { l - 1 } \\rceil$ and $\\lceil \\alpha n _ { l } \\rceil$ and the number of parameters (and the number of multiplications) becomes $\\approx \\alpha ^ { 2 }$ of the original number. ",
+        "bbox": [
+            176,
+            404,
+            821,
+            445
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The result of this operation is a network that is both $1 / \\alpha ^ { 2 }$ smaller and faster. Many large networks can be significantly reduced in size using this method with only a small loss of precision (Howard, 2017). It is our belief that this method establishes a strong baseline to which any other advanced techniques should compare themselves. To the best of our knowledge, we are not aware of such comparisons in the literature. ",
+        "bbox": [
+            174,
+            452,
+            825,
+            522
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 SPARSE RANDOM ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            535,
+            338,
+            549
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Instead of looking at depth multiplier as deactivating channels in the convolutional layers, we can look at it from the perspective of deactivating connections. From this point of view, depth multiplier kills the connections between two convolutional layers such that (a) the connection patterns are still the same across spatial dimensions and (b) all “alive” input channels are fully connected to all “alive” output channels. ",
+        "bbox": [
+            174,
+            561,
+            825,
+            631
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We generalize this approach by relaxing (b) while maintaining (a). That is, for every output channel, we connect it to a small subset of input channels. In other words, dense connections between a small number of channels become sparse connections between larger number of channels. This can be summarized in Fig. 1. The advantage of this is that the actual convolution can still be computed efficiently because sparsity is introduced only at the outer loop of the convolution operation and we can still take the advantage of the continuous memory layout. For more details regarding implementations of the two approaches, please refer to the Appendix. ",
+        "bbox": [
+            174,
+            638,
+            825,
+            736
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "More concretely, let $n _ { l - 1 }$ and $n _ { l }$ be the number of channels of layer $l - 1$ and layer $l$ , respectively. For a sparsity coefficient $\\alpha$ , each output filter $j$ only connects to an $\\alpha$ fraction of filters of the previous layer. Thus, instead of having a connectivity matrix $W _ { s i j }$ of dimension $k ^ { 2 } \\times n _ { l - 1 } \\times n _ { l }$ , we have a sparse matrix with non-zero entries at $W _ { s a _ { i j } j }$ , where $a _ { i j }$ is an index matrix of dimension $k ^ { 2 } \\times \\alpha n _ { l - 1 } \\times n _ { l }$ and $k$ is the kernel size. ",
+        "bbox": [
+            174,
+            742,
+            825,
+            814
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2.1 INCREMENTAL TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            827,
+            403,
+            842
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In contrast to depth multiplier, a sparse convolutional network defines a connection pattern on a much bigger network. Therefore, an interesting extension is to consider incremental training: we start with a network that only contains a small fraction of connections (in our experiments we use $1 \\%$ and $0 . 1 \\%$ ) and add connections over time. This is motivated by an intuition that the network can use learned channels in new contexts by introducing additional connections. The potential practical advantage of this approach is that since we start training with very small networks and grow them over time, this approach has a potential to speed up the whole training process significantly. We note that depth multiplier will not benefit from this approach as any newly activated connections would require learning new filters from scratch. ",
+        "bbox": [
+            174,
+            853,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/66fc8a8512a12ff04f8f7dc6aab17648934eff7a1161c2536e3fa54b1fa83cde.jpg",
+        "image_caption": [
+            "Figure 1: Connection tensors of depth multiplier (left) and sparse random (right) approaches for $n _ { l - 1 } = 5$ and $n _ { l } = 1 0$ . Yellow denotes active connections. For both approaches, the connection pattern is the same across spatial dimension and fixed before training. However, in the sparse random approach, each output channel is connected to a (possibly) different subset of input channels, and vice versa. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            204,
+            106,
+            782,
+            185
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            281,
+            825,
+            338
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            356,
+            290,
+            371
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section, we approach a question of why sparse convolutions are frequently more efficient than the dense convolutions with the same number of parameters. Our main intuition is that the sparse convolutional networks promote diversity. It is much harder to learn equivalent set of channels as, at high sparsity, channels have distinct connection structure or even overlapping connections. This can be formalized with a simple observation that any dense network is in fact a part of an exponentially large equivalence class, which is guaranteed to produce the same output for every input. ",
+        "bbox": [
+            173,
+            386,
+            825,
+            470
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Lemma 1 Any dense convolutional neural network with no cross-channel nonlinearities, distinct weights and biases, and with l hidden layers of sizes $n _ { 1 }$ , $n _ { 2 }$ , . . . , $n _ { l }$ , has at least $\\textstyle \\prod _ { i = 1 } ^ { l } n _ { i } !$ distinct equivalent networks which produce the same output. ",
+        "bbox": [
+            173,
+            484,
+            825,
+            530
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Proof Let $I$ denote the input to the network, $C _ { i }$ be the convolutional operator, $\\sigma _ { i }$ denote the nonlinearity operator applied to the $i$ -th convolution layer and $S$ be a final transformation (e.g. softmax classifier). We assume that $\\sigma _ { i }$ is a function that operates on each of the channels independently. We note that this is the case for almost any modern network. The output of the network can then be written as: ",
+        "bbox": [
+            173,
+            542,
+            825,
+            613
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/beea7d489507a37291c18e46788f828e6040412e7e84a7604ead6cd1d103d3a8.jpg",
+        "text": "$$\n\\mathcal { N } ( I ) \\equiv S \\circ \\sigma _ { l } \\circ C _ { l } \\circ \\sigma _ { l - 1 } \\circ \\cdots \\circ \\sigma _ { 1 } \\circ C _ { 1 } ( I )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            346,
+            617,
+            650,
+            635
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where we use $\\circ$ to denote function composition to avoid numerous parentheses. The convolution operator $C _ { i }$ operates on input with $n _ { i - 1 }$ channels and produces an output with $n _ { i }$ channels. Now, fix arbitrary set of permutation functions $\\pi _ { i }$ , where $\\pi _ { i }$ can permute depth of size $n _ { i }$ . Since $\\pi _ { i }$ is a linear function, it follows that $C _ { i } ^ { \\prime } = \\pi _ { i } ^ { - 1 } C _ { i } \\pi _ { i - 1 }$ is a valid convolutional operator, which can be obtained from $C _ { i }$ by permuting its bias according to $\\pi _ { i }$ and its weight matrix along input and output dimensions according to $\\pi _ { i - 1 }$ and $\\pi _ { i }$ respectively. For a new network defined as: ",
+        "bbox": [
+            173,
+            643,
+            825,
+            728
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f9d507d6a130c4c9052e073184e7bcd8a6aa91888fa306ef72272247738d2624.jpg",
+        "text": "$$\n\\mathcal { N } ^ { \\prime } ( I ) = S ^ { \\prime } \\circ \\sigma _ { l } \\circ C _ { l } ^ { \\prime } \\circ \\sigma _ { l - 1 } \\circ \\cdots \\circ \\sigma _ { 1 } \\circ C _ { 1 } ^ { \\prime } ( I ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            339,
+            739,
+            656,
+            757
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\pi _ { 0 }$ is an identity operator and $S ^ { \\prime } \\equiv S \\circ \\pi _ { l }$ , we claim that $\\mathcal { N } ^ { \\prime } ( I ) \\equiv \\mathcal { N } ( I )$ . Indeed, since nonlinearities do not apply cross-depth we have $\\pi _ { n } \\sigma _ { n } \\pi _ { n } ^ { - 1 } \\equiv \\sigma _ { n }$ and thus: ",
+        "bbox": [
+            173,
+            767,
+            823,
+            797
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f024c18d6595d3e2ba9aa755d9d14deecbf1af5c05c6f9f759b65544ecec492d.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathscr { N } ^ { \\prime } ( I ) = S ^ { \\prime } \\circ \\sigma _ { l } \\circ C _ { l } ^ { \\prime } \\circ \\sigma _ { l - 1 } \\circ \\cdots \\circ \\sigma _ { 1 } \\circ C _ { 1 } ^ { \\prime } ( I ) = } \\\\ & { \\qquad = S \\circ \\pi _ { l } \\circ \\sigma _ { l } \\circ \\pi _ { l } ^ { - 1 } \\circ C _ { l } \\circ \\pi _ { l - 1 } \\circ \\cdots \\circ \\pi _ { 1 } \\circ \\sigma _ { 1 } \\circ \\pi _ { 1 } ^ { - 1 } \\circ C _ { 1 } ( I ) = \\mathscr { N } ( I ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            187,
+            809,
+            808,
+            852
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Thus, any set of permutations on hidden units defines an equivalent network. ",
+        "bbox": [
+            176,
+            859,
+            676,
+            875
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "It is obvious that sparse networks are much more immune to parameter permutation – indeed every channel at layer $l$ is likely to have a unique tree describing its connection matrix all the way down. Exploring this direction is an interesting open question. ",
+        "bbox": [
+            174,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            326,
+            118
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we demonstrate the effectiveness of the sparse random approach by comparing it to the depth multiplier approach at different compression rates. Moreover, we examine several settings in the incremental training where connections gradually become active during the training process. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            176
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.1 SETUP ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            193,
+            261,
+            207
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Networks and Datasets Our experiments are conducted on 4 networks for 3 different datasets.   \nAll our experiments use open-source TensorFlow networks Abadi et al. (2015). ",
+        "bbox": [
+            176,
+            222,
+            823,
+            250
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "MNIST AND CIFAR-10 We use standard networks provided by TensorFlow. For MNIST, it has 3-layer convolutional layers and achieves $9 9 . 5 \\%$ accuracy when fully trained. For CIFAR-10, it has 2 convolutional layers and achieves $87 \\%$ accuracy. ",
+        "bbox": [
+            176,
+            267,
+            823,
+            309
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "IMAGENET We use open source Inception-V3 (Szegedy et al., 2016) network and a slightly modified version of VGG-16 (Simonyan & Zisserman, 2015) called VGG-16n on ImageNet ILSVRC 2012 (Deng et al., 2009; Russakovsky et al., 2015). ",
+        "bbox": [
+            176,
+            327,
+            821,
+            369
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Random connections Connections are activated according to their likelihood from the uniform distribution. In addition, they are activated in such a way that there are no connections going in or coming out of dead filters (i.e., any connection must have a path to input image and a path to the final prediction.). All connections in fully connected layers are retained. ",
+        "bbox": [
+            174,
+            387,
+            825,
+            443
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Implementation details All code is implemented in TensorFlow (Abadi et al., 2015). Deactivating connections is done by applying masks to parameter tensors. The Inception-v3 and VGG-16n networks are trained on 8 Tesla K80 GPUs, each with batch size 256 (32 per gpu) and batch normalization was used for all networks. ",
+        "bbox": [
+            176,
+            460,
+            823,
+            516
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.2 COMPARISON BETWEEN SPARSE RANDOM AND DEPTH MULTIPLIER ",
+        "bbox": [
+            176,
+            536,
+            676,
+            549
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.2.1 MNIST AND CIFAR-10 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            563,
+            398,
+            578
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We first compare depth multiplier and sparse random for the two small networks on MNIST and CIFAR-10. We compare the accuracy of the two approaches when the numbers of connections are roughly the same, based on a hyperparameter $\\alpha$ . For dense convolutions, we pick a multiplier $\\alpha$ and each filter depth is scaled down by $\\sqrt { \\alpha }$ and then rounded up. In sparse convolutions, a fraction $\\alpha$ of connections are randomly deactivated if those parameters connect at least two filters on each layer; otherwise, a fraction of $\\sqrt { \\alpha }$ is used instead if the parameters connect layers with only one filter left. The accuracy numbers are averaged over 5 rounds for MNIST and 2 rounds on CIFAR-10. ",
+        "bbox": [
+            174,
+            592,
+            825,
+            689
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We show in Fig. 2 and Fig. 3 that the sparse networks have comparable or higher accuracy for the same number of parameters, with comparable accuracy at higher density. We note however that these networks are so small that at high compression rates most of operations are concentrated at the first layer, which is negligible for large networks. Moreover, in MNIST example, the size of network changes most dramatically from 2000 to 2 million parameters, while affecting accuracy only by $1 \\%$ . This observation suggests that there might be benefits of maintaining the number of filters to be high and/or breaking the symmetry of connections. We explore this in the next section. ",
+        "bbox": [
+            174,
+            696,
+            825,
+            794
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.2.2 INCEPTION-V3 ON IMAGENET",
+        "text_level": 1,
+        "bbox": [
+            176,
+            810,
+            436,
+            825
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We consider different values of sparsity ranging from 0.003 to 1, and depth multiplier from 0.05 to 1. Our experiments show (see Table 1 and Fig. 4) significant advantage of sparse networks over equivalently sized dense networks. We note that due to time constraints the reported quantitative numbers are preliminary, as the networks have not finished converging. We expect the final numbers to match the reported number for Inception V3 Szegedy et al. (2016), and the smaller networks to have comparable improvement. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            922
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/65926ca6ffb9b876a5add68d622ccc4f1c7a0fd94934ef67cf453485cb422141.jpg",
+        "image_caption": [
+            "Figure 2: Comparison of accuracy (averaged over 5 rounds) vs. Number of parameters/Number of multiply-adds between dense and sparse convolutions on MNIST dataset. Note that though sparse convolution result in better parameter trade-off curve, the multiply-add curve shows the opposite pattern. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            204,
+            101,
+            784,
+            271
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Inception V3: Preliminary quantitative results after 100 Epochs. Note the smallest sparse network is actually a hybrid network - we used both depth multiplier (0.5) and sparsity (0.01). The number of parameters is the number of parameters excluding the softmax layer. ",
+        "bbox": [
+            176,
+            340,
+            825,
+            383
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/b34ddde6d213af5b60d226747df5ee3604eee0c1cb8d2d5689b2231902ee2059.jpg",
+        "table_caption": [
+            "Accuracy for sparse convolutions "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Sparsity</td><td>MAdds Params</td><td>P@1</td></tr><tr><td>0.50/0.01 0.003</td><td>43.0M 90k 158k</td><td>40.3 46.1</td></tr><tr><td>0.01</td><td>82.0M 104M</td><td>52.3</td></tr><tr><td>0.03</td><td>287k 208M 724k</td><td></td></tr><tr><td>0.10</td><td></td><td>59.5</td></tr><tr><td>0.30</td><td>628M 2.3 M</td><td>67.2</td></tr><tr><td></td><td>1.80 B 6.6M</td><td>73</td></tr><tr><td>0.60</td><td>3.50B 13M 22 M</td><td>75</td></tr><tr><td>1.00</td><td>5.70 B</td><td>77</td></tr></table>",
+        "bbox": [
+            215,
+            409,
+            486,
+            537
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/f13c73e145cd97e43929b7f6bff27130ece79ed9e82f3f37297cc3a19a01a5c9.jpg",
+        "table_caption": [
+            "Accuracy for Depth Multiplier "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Multiplier</td><td>MAdds</td><td>Params P@1</td></tr><tr><td>0.05</td><td>55.0M 56k</td><td>24.6</td></tr><tr><td>0.10</td><td>75.0M</td><td>170k 38.6</td></tr><tr><td>0.20</td><td>183M 718k</td><td>54.2</td></tr><tr><td>0.30</td><td>439M 1.8M</td><td>64.0</td></tr><tr><td>0.50</td><td>1.40B 5.4M</td><td>72.3</td></tr><tr><td>0.80</td><td>3.40B 13M</td><td>75.6</td></tr></table>",
+        "bbox": [
+            534,
+            422,
+            815,
+            523
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Original network: 5.70 B 22 M 77 (78.8) ",
+        "bbox": [
+            194,
+            549,
+            509,
+            564
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2.3 VGG-16 ON IMAGENET ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            594,
+            397,
+            609
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In our experiments with the VGG-16 network (Simonyan & Zisserman, 2015), we modify the model architecture (calling it VGG-16n) by removing the two fully-connected layers with depth 4096 and replacing them with a $2 \\times 2$ maxpool layer followed by a $3 \\times 3$ convolutional layer with the depth of 1024. This alone sped up our training significantly. The comparison between depth multiplier and sparse connection approaches is shown in Fig. 5. The modified VGG-16n network has about 7 times fewer parameters, but appears to have comparable precision. ",
+        "bbox": [
+            173,
+            622,
+            825,
+            707
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/f4cf6c184c4020dc5874321b477ae62c97ddf25c9d68322157c1a605a04d32e7.jpg",
+        "image_caption": [
+            "Figure 3: Comparison of accuracy (averaged over 2 rounds) vs. Number of parameters/Number of multiply-adds between dense and sparse convolutions on CIFAR-10 dataset. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            222,
+            734,
+            767,
+            896
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/1cf4cc4464141afef87dfda693d69954f6e151da17bb74348a13d18643a16d98.jpg",
+        "image_caption": [
+            "Figure 4: Inception V3: Comparison of Precision $@ 1$ vs. Number of parameters/Number of multiply-adds between dense and sparse convolutions on ImageNet/Inception-V3. The full network corresponds to the right-most point of the curve. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            204,
+            102,
+            787,
+            273
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/a57e0b1ff2bb1e2c18547e1723279c8b784b21823938c56fcb8383c2d7879efa.jpg",
+        "image_caption": [
+            "Figure 5: VGG 16: Preliminary Quantitative Results. Comparison of Precision $@ 1$ vs. Number of parameters/Number of multiply-adds between dense and sparse convolutions on ImageNet/VGG16n. The full network corresponds to the right-most point of the curve. Original VGG-16 as described in Simonyan & Zisserman (2015) (blue star) and the same model trained by us from scratch (red cross) are also shown. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            335,
+            785,
+            507
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.3 INCREMENTAL TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            609,
+            392,
+            622
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/f704c8a1c6906e9b1cd74e0b702c578d2acd95067c474ee8b78c09edf9df95a7.jpg",
+        "image_caption": [
+            "Figure 6: Incremental Training Of Inception V3: We show Precision $@ 1$ during the training process, where the networks densify over time. The saturation points show where the networks actually reach their full density. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            310,
+            657,
+            676,
+            881
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Finally, we show that incremental training is a promising direction. We start with a very sparse model and increase its density over time, using the approach described in Sect. 3.2.1. We note that a naive approach where we simply add filters results in training process basically equivalent to as if it started from scratch in every step. On the other hand, when the network densifies over time, all channels already possess some discriminative power and that information is utilized. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            172
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In our experiments, we initially start training Inception-V3 with only $1 \\%$ or $0 . 1 \\%$ of connections enabled. Then, we double the number of connections every $T$ steps. We use $T = 1 0 , 0 0 0$ , $T =$ 25, 000 and $T = 5 0 , 0 0 0$ . The results are presented in Fig. 6. We show that the networks trained with the incremental approach regardless of the doubling period can catch up with the full Inception-V3 network (in some cases with small gains). Moreover, they recover very quickly from adding more (untrained) connections. In fact, the recovery is so fast that it is shorter than our saving interval for all the networks except for the network with 10K doubling period (resulting in the sharp drop). We believe that incremental training is a promising direction to speeding up the training of large convolutional neural networks since early stages of the training require much less computation. ",
+        "bbox": [
+            174,
+            180,
+            825,
+            305
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            320,
+            318,
+            337
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We have proposed a new compression technique that uses a sparse random connection structure between input-output filters in convolutional layers of CNNs. We fix this structure before training and use the same structure across spatial dimensions to harvest savings from modern hardware. We show that this approach is especially useful at very high compression rates for large networks. For example, this simple method when applied to Inception V3 (Fig. 4), achieves AlexNet-level accuracy (Krizhevsky et al., 2012) with fewer than 400K parameters and VGG-level one (Fig. 5) with roughly $3 . 5 \\mathrm { M }$ parameters. The simplicity of our approach is instructive in that it establishes a strong baseline to compare against when developing more advanced techniques. On the other hand, the uncanny match in performance of dense and equivalently-sized sparse networks with sparsity $> 0 . 1$ suggests that there might be some fundamental property of network architectures that is controlled by the number of parameters, regardless of how they are organized. Exploring this further might yield additional insights on understanding neural networks. ",
+        "bbox": [
+            173,
+            352,
+            825,
+            517
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In addition, we show that our method leads to an interesting novel incremental training technique, where we take advantage of sparse (and smaller) models to build a dense network. One interesting open direction is to enable incremental training not to simply densify the network over time, but also increase the number of channels. This would allow us to grow the network without having to fix its original shape in place. ",
+        "bbox": [
+            174,
+            525,
+            825,
+            594
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            611,
+            285,
+            626
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mart´ın Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Greg S. Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Ian Goodfellow, Andrew Harp, Geoffrey Irving, Michael Isard, Yangqing Jia, Rafal Jozefowicz, Lukasz Kaiser, Manjunath Kudlur, Josh Levenberg, Dan Mane, Rajat Monga, Sherry Moore, Derek Murray, Chris Olah, Mike Schuster, Jonathon Shlens, Benoit ´ Steiner, Ilya Sutskever, Kunal Talwar, Paul Tucker, Vincent Vanhoucke, Vijay Vasudevan, Fernanda Viegas, ´ Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng. TensorFlow: Large-scale machine learning on heterogeneous systems, 2015. URL http://tensorflow.org/. Software available from tensorflow.org. ",
+        "bbox": [
+            176,
+            640,
+            825,
+            742
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sajid Anwar, Kyuyeon Hwang, and Wonyong Sung. Fixed point optimization of deep convolutional neural networks for object recognition. In ICASSP, 2015a. ",
+        "bbox": [
+            169,
+            755,
+            823,
+            781
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sajid Anwar, Kyuyeon Hwang, and Wonyong Sung. Structured pruning of deep convolutional neural networks. arXiv preprint arXiv:1512.08571, 2015b. ",
+        "bbox": [
+            171,
+            792,
+            821,
+            819
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sanjeev Arora, Aditya Bhaskara, Rong Ge, and Tengyu Ma. Provable bounds for learning some deep representations. In ICML, 2014. ",
+        "bbox": [
+            171,
+            832,
+            821,
+            858
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jimmy Ba and Rich Caruana. Do deep nets really need to be deep? In NIPS, 2014. ",
+        "bbox": [
+            173,
+            871,
+            663,
+            885
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Wenlin Chen, James T. Wilson, Stephen Tyree, Kilian Q. Weinberger, and Yixin Chen. Compressing neural networks with the hashing trick. In ICML, 2015. ",
+        "bbox": [
+            173,
+            897,
+            825,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Dan C. Cires¸an, Ueli Meier, Jonathan Masci, Luca M. Gambardella, and Jurgen Schmidhuber. High- ¨ performance neural networks for visual object classification. arXiv preprint arXiv:1102.0183, 2011.   \nMatthieu Courbariaux, Yoshua Bengio, and Jean-Pierre David. Binaryconnect: Training deep neural networks with binary weights during propagations. In NIPS, 2015.   \nMatthieu Courbariaux, Itay Hubara, Daniel Soudry, Ran El-Yaniv, and Yoshua Bengio. Binarized neural networks: Training deep neural networks with weights and activations constrained to $+ 1$ or -1. arXiv preprint arXiv:1602.02830, 2016.   \nBert De Brabandere, Xu Jia, Tinne Tuytelaars, and Luc Van Gool. Dynamic filter networks. In NIPS, 2016.   \nJia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In CVPR, 2009.   \nMisha Denil, Babak Shakibi, Laurent Dinh, Marc Aurelio Ranzato, and Nando de Freitas. Predicting parameters in deep learning. In NIPS, 2013.   \nEmily L. Denton, Wojciech Zaremba, Joan Bruna, Yann LeCun, and Rob Fergus. Exploiting linear structure within convolutional networks for efficient evaluation. In NIPS, 2014.   \nJiashi Feng and Trevor Darrell. Learning the structure of deep convolutional networks. In ICCV, 2015.   \nYunchao Gong, Liu Liu, Ming Yang, and Lubomir Bourdev. Compressing deep convolutional networks using vector quantization. arXiv preprint arXiv:1412.6115, 2014.   \nThomas L. Griffiths and Zoubin Ghahramani. The indian buffet process: An introduction and review. Journal of Machine Learning Research, 12(Apr):1185–1224, 2011.   \nSong Han, Jeff Pool, John Tran, and William Dally. Learning both weights and connections for efficient neural network. In NIPS, 2015.   \nSong Han, Huizi Mao, and William J. Dally. Deep compression: Compressing deep neural network with pruning, trained quantization and huffman coding. In ICLR, 2016a.   \nSong Han, Jeff Pool, Sharan Narang, Huizi Mao, Shijian Tang, Erich Elsen, Bryan Catanzaro, John Tran, and William J. Dally. Dsd: Regularizing deep neural networks with dense-sparse-dense training flow. arXiv preprint arXiv:1607.04381, 2016b.   \nStephen Jose Hanson and Lorien Y. Pratt. Comparing biases for minimal network construction with back- ´ propagation. In NIPS, 1989.   \nBabak Hassibi and David G. Stork. Second order derivatives for network pruning: Optimal brain surgeon. In NIPS, 1993.   \nKaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016a.   \nKaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Identity mappings in deep residual networks. In ECCV, 2016b.   \nGeoffrey E. Hinton, Nitish Srivastava, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Improving neural networks by preventing co-adaptation of feature detectors. arXiv preprint arXiv:1207.0580, 2012.   \nAndrew G. Howard. Mobilenets: Efficient convolutional neural networks for mobile vision applications. In forthcoming, 2017.   \nHengyuan Hu, Rui Peng, Yu-Wing Tai, and Chi-Keung Tang. Network trimming: A data-driven neuron pruning approach towards efficient deep architectures. arXiv preprint arXiv:1607.03250, 2016.   \nGao Huang, Zhuang Liu, and Kilian Q. Weinberger. Densely connected convolutional networks. arXiv preprint arXiv:1608.06993, 2016a.   \nGao Huang, Yu Sun, Zhuang Liu, Daniel Sedra, and Kilian Weinberger. Deep networks with stochastic depth. arXiv preprint arXiv:1603.09382, 2016b.   \nKyuyeon Hwang and Wonyong Sung. Fixed-point feedforward deep neural network design using weights $+ 1$ , 0, and -1. In IEEE Workshop on Signal Processing Systems (SiPS), 2014. ",
+        "bbox": [
+            171,
+            94,
+            828,
+            929
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yani Ioannou, Duncan Robertson, Roberto Cipolla, and Antonio Criminisi. Deep roots: Improving cnn efficiency with hierarchical filter groups. arXiv preprint arXiv:1605.06489, 2016a. ",
+        "bbox": [
+            171,
+            103,
+            821,
+            131
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yani Ioannou, Duncan Robertson, Jamie Shotton, Roberto Cipolla, and Antonio Criminisi. Training cnns with low-rank filters for efficient image classification. In ICLR, 2016b. ",
+        "bbox": [
+            174,
+            140,
+            821,
+            166
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Max Jaderberg, Andrea Vedaldi, and Andrew Zisserman. Speeding up convolutional neural networks with low rank expansions. In BMVC, 2014. ",
+        "bbox": [
+            176,
+            174,
+            821,
+            202
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xiaojie Jin, Xiaotong Yuan, Jiashi Feng, and Shuicheng Yan. Training skinny deep neural networks with iterative hard thresholding methods. arXiv preprint arXiv:1607.05423, 2016. ",
+        "bbox": [
+            174,
+            210,
+            823,
+            238
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yong-Deok Kim, Eunhyeok Park, Sungjoo Yoo, Taelim Choi, Lu Yang, and Dongjun Shin. Compression of deep convolutional neural networks for fast and low power mobile applications. In ICLR, 2016. ",
+        "bbox": [
+            173,
+            246,
+            823,
+            273
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Ilya Sutskever, and Geoffrey E. Hinton. Imagenet classification with deep convolutional neural networks. In NIPS, 2012. ",
+        "bbox": [
+            174,
+            281,
+            823,
+            308
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Vadim Lebedev, Yaroslav Ganin, Maksim Rakhuba, Ivan Oseledets, and Victor Lempitsky. Speeding-up convolutional neural networks using fine-tuned cp-decomposition. In ICLR, 2015. ",
+        "bbox": [
+            173,
+            316,
+            821,
+            344
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, John S. Denker, Sara A. Solla, Richard E. Howard, and Lawrence D. Jackel. Optimal brain damage. In NIPS, 1989. ",
+        "bbox": [
+            174,
+            352,
+            823,
+            378
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to document ´ recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998. ",
+        "bbox": [
+            174,
+            387,
+            823,
+            415
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Hao Li, Asim Kadav, Igor Durdanovic, Hanan Samet, and Hans Peter Graf. Pruning filters for efficient convnets. arXiv preprint arXiv:1608.08710, 2016. ",
+        "bbox": [
+            173,
+            422,
+            823,
+            450
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Baoyuan Liu, Min Wang, Hassan Foroosh, Marshall Tappen, and Marianna Pensky. Sparse convolutional neural networks. In CVPR, 2015. ",
+        "bbox": [
+            173,
+            458,
+            821,
+            486
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Julien Mairal, Francis Bach, Jean Ponce, and Guillermo Sapiro. Online dictionary learning for sparse coding. In ICML, 2009. ",
+        "bbox": [
+            171,
+            494,
+            821,
+            521
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kenton Murray and David Chiang. Auto-sizing neural networks: With applications to n-gram language models. In EMNLP, 2015. ",
+        "bbox": [
+            173,
+            530,
+            823,
+            558
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alexander Novikov, Dmitrii Podoprikhin, Anton Osokin, and Dmitry P. Vetrov. Tensorizing neural networks. In NIPS, 2015. ",
+        "bbox": [
+            173,
+            565,
+            821,
+            592
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ivan V. Oseledets. Tensor-train decomposition. SIAM Journal on Scientific Computing, 33(5):2295–2317, 2011. ",
+        "bbox": [
+            173,
+            601,
+            821,
+            627
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mohammad Rastegari, Vicente Ordonez, Joseph Redmon, and Ali Farhadi. Xnor-net: Imagenet classification using binary convolutional neural networks. In ECCV, 2016. ",
+        "bbox": [
+            173,
+            636,
+            823,
+            662
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, et al. Imagenet large scale visual recognition challenge. International Journal of Computer Vision, 115(3):211–252, 2015. ",
+        "bbox": [
+            174,
+            671,
+            821,
+            712
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. In ICLR, 2015. ",
+        "bbox": [
+            173,
+            719,
+            823,
+            746
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nitish Srivastava, Geoffrey E. Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: a simple way to prevent neural networks from overfitting. Journal of Machine Learning Research, 15(1): 1929–1958, 2014. ",
+        "bbox": [
+            174,
+            755,
+            821,
+            795
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Rupesh K. Srivastava, Klaus Greff, and Jurgen Schmidhuber. Training very deep networks. In ¨ NIPS, 2015. ",
+        "bbox": [
+            171,
+            803,
+            803,
+            818
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jonathon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. In CVPR, 2016. ",
+        "bbox": [
+            171,
+            827,
+            823,
+            853
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Li Wan, Matthew Zeiler, Sixin Zhang, Yann LeCun, and Rob Fergus. Regularization of neural networks using dropconnect. In ICML, 2013. ",
+        "bbox": [
+            173,
+            862,
+            823,
+            888
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Wei Wen, Chunpeng Wu, Yandan Wang, Yiran Chen, and Hai Li. Learning structured sparsity in deep neural networks. In NIPS, 2016. ",
+        "bbox": [
+            171,
+            897,
+            825,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xiangyu Zhang, Jianhua Zou, Kaiming He, and Jian Sun. Accelerating very deep convolutional networks for classification and detection. IEEE Transactions on Pattern Analysis and Machine Intelligence, 2015a. ",
+        "bbox": [
+            173,
+            104,
+            823,
+            131
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Xiangyu Zhang, Jianhua Zou, Xiang Ming, Kaiming He, and Jian Sun. Efficient and accurate approximations of nonlinear convolutional networks. In CVPR, 2015b. ",
+        "bbox": [
+            174,
+            140,
+            823,
+            165
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A ADDITIONAL DETAILS ON DENSE VS. SPARSE CONVOLUTIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            722,
+            117
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We contrast naive implementations of dense and sparse convolutions (cf. Sect. 3) in Algorithm. 1 and Algorithm 2. We emphasize that we do not use sparse matrices and only introduce sparsity from channel to channel. Thus, walltime will be mostly in terms of Multiply-Adds; the basic operation (convolving the entire image plane in Line 8 of both algorithms) is unchanged. ",
+        "bbox": [
+            174,
+            131,
+            825,
+            188
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Naive implementation of dense convolution ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            203,
+            549,
+            218
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "1: Inputs:   \n2: - input: Data tensor   \n3: - W : Parameter tensor   \n4: - input channels: Array of input channel IDs   \n5: - output channels: Array of output channel IDs   \n6: for $i$ in input channels do   \n7: for $o$ in output channels do   \n8: $o u t p u t [ o ] \\gets o u t p u t [ o ] + \\mathrm { c o n v o l v e } ( i n p u t [ i ] , W [ i , o , . . . ] )$   \n9: end for   \n10: end for   \n11: return output ",
+        "bbox": [
+            179,
+            223,
+            629,
+            381
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 2 Naive implementation of sparse convolution ",
+        "bbox": [
+            174,
+            409,
+            552,
+            422
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "1: Inputs:   \n2: - input: Data tensor   \n3: - W : Parameter tensor   \n4: - input channels: Array of input channel IDs   \n5: - output channels connected to i: Array of array of output channel IDs specifying connec  \ntions to each input channel   \n6: for $i$ in input channels do   \n7: for index, $o$ in enumerate(output channels connected to i[i]) do   \n8: output[o] $\\gets$ output[o] $^ +$ convolve(input[i], W [i, index, . . .])   \n9: end for   \n10: end for   \n11: return output ",
+        "bbox": [
+            179,
+            429,
+            825,
+            603
+        ],
+        "page_idx": 12
+    }
+]

parse/train/lHmhW2zmVN/lHmhW2zmVN.md

@@ -0,0 +1,248 @@
+# Attention over learned object embeddings enables complex visual reasoning
+
+David Ding Felix Hill Adam Santoro Malcolm Reynolds Matt Botvinick DeepMind London, United Kingdom   
+{fding, felixhill, adamsantoro, mareynolds, botvinick}@google.com
+
+# Abstract
+
+Neural networks have achieved success in a wide array of perceptual tasks but often fail at tasks involving both perception and higher-level reasoning. On these more challenging tasks, bespoke approaches (such as modular symbolic components, independent dynamics models or semantic parsers) targeted towards that specific type of task have typically performed better. The downside to these targeted approaches, however, is that they can be more brittle than general-purpose neural networks, requiring significant modification or even redesign according to the particular task at hand. Here, we propose a more general neural-network-based approach to dynamic visual reasoning problems that obtains state-of-the-art performance on three different domains, in each case outperforming bespoke modular approaches tailored specifically to the task. Our method relies on learned object-centric representations, self-attention and self-supervised dynamics learning, and all three elements together are required for strong performance to emerge. The success of this combination suggests that there may be no need to trade off flexibility for performance on problems involving spatio-temporal or causal-style reasoning. With the right soft biases and learning objectives in a neural network we may be able to attain the best of both worlds.
+
+# 1 Introduction
+
+Despite the popularity of artificial neural networks, a body of recent work has focused on their limitations as models of cognition and reasoning. Experiments with dynamical reasoning datasets such as CLEVRER [41], CATER [12], and ACRE [44] show that neural networks can fail to adequately reason about the spatio-temporal, compositional or causal structure of visual scenes. On CLEVRER, where models must answer questions about the dynamics of colliding objects, previous experiments show that neural networks can adequately describe the video, but fail when asked to predict, explain, or consider counterfactual possibilities. Similarly, on CATER, an object-tracking task, models have trouble tracking the movement of objects when they are hidden in a container. Finally, on ACRE, a dataset testing for causal inference, popular models only learned correlations between visual scenes and not the deeper causal logic.
+
+Failures such as these on reasoning (rather than perception) problems have motivated the adoption of pipeline-style approaches that combine a general purpose neural network (such as a convolutional block) with a task-specific module that builds in the core logic of the task. For example, on CLEVRER the NS-DR method [41] applies a hand-coded symbolic logic engine (that has the core logic of CLEVRER built-in) to the outputs of a “perceptual” neural front-end, achieving better results than neural network baselines, particularly on counterfactual and explanatory problems. One limitation of these pipeline approaches, however, is that they are typically created with a single problem or problem domain in mind, and may not apply out-of-the-box to other related problems. For example, to apply NS-DR to CATER, the entire symbolic module needs to be rewritten to handle the new interactions and task logic of CATER: the custom logic to handle collisions and object removal must be replaced with new custom logic to handle occlusions and grid-resolution, and these changes require further modifications to the perceptual front-end to output data in a new format. This brittleness is not exclusive to symbolic approaches. While Hungarian-matching between object embeddings may be well-suited for object-tracking tasks [45], it is not obvious how it would help for causal inference tasks.
+
+Here, we describe a more general neural-network-based approach to visual spatio-temporal reasoning problems, which does not rely on task-specific integration of modular components. In place of these components, our model relies on three key aspects:
+
+• Self-attention to effectively integrate information over time   
+• Soft-discretization of the input at the most informative level of abstraction – above pixels and local features, and below entire frames—corresponding approximately to ‘objects’   
+Self-supervised learning, i.e. requiring the model to infer masked out objects, to extract more information about dynamics from each sample.
+
+While many past models have applied each individual ingredient separately (including on the tasks we study), we show that it is the combination of all three ingredients in the right way that allows our model to succeed.
+
+The resulting model, which we call Aloe (Attention over Learned Object Embeddings), outperforms both pipeline and neural-network-based approaches on three different task domains designed to test physical and dynamical reasoning from pixel inputs. We highlight our key results here:
+
+• CLEVRER (explanatory, predictive, and counterfactual reasoning): Aloe achieves significantly higher accuracy than both more task-specific, modular approaches, and previous neural network methods on all question types. On counterfactual questions, thought to be most challenging for neural-only architectures, we achieve $75 \%$ vs $46 \%$ accuracy for more specialised methods. • CATER (object-permanence): Aloe achieves accuracy exceeding or matching other current models. Notably, the strongest alternative models were expressly designed for object-tracking, whereas our architecture is applicable without modification to other reasoning tasks as well. ACRE (causal-inference “beyond the simple strategy of inducing causal relationships by covariation” [44]): Overall, Aloe achieves $94 \%$ vs the $67 \%$ accuracy achieved by the top neuro-symbolic model. On the most challenging tasks, we achieve, for “backward-blocking” inference, $9 4 . 4 8 \%$ (vs $1 6 . 0 6 \%$ by the best modular, neuro-symbolic systems), and, for “screenoff” inference, $9 8 . 9 7 \%$ (vs ${ \bf0 . 0 0 \% }$ by a CNN-BERT baseline).
+
+As we have emphasized, the previous best performing models for each task all contain task-specific design elements, whereas Aloe can be applied to all the tasks without modification. On CLEVRER, we also show that Aloe matches the performance of the previous best models with $40 \%$ less training data, which demonstrates that our approach is data-efficient as well as performant.
+
+# 2 Methods
+
+A guiding motivation for the design of Aloe is the converging evidence for the value of self-attention mechanisms operating on a finite sequences of discrete entities. Written language is inherently discrete and hence is well-suited to self-attention-based approaches. In other domains, such as raw audio or vision, it is less clear how to leverage self-attention. We hypothesize that the application of self-attention-based models to visual tasks could benefit from an approximate ‘discretization’ process, and determining the right level of discretization is an important choice that can significantly affect model performance.
+
+At the finest level, data could simply be discretized into pixels (as is already the case for most machine-processed visual data). Pixels are too fine-grained for many applications, however—for one, the memory required to support self-attention across all pixels is prohibitive. Partly for this reason, coarser representations, such as the downsampled “hyper-pixel” outputs of a convolutional network, are often used instead (e.g. [27, 43]). In the case of videos, previous work considered even coarser discretization schemes, such as frame or subclip level representations [35].
+
+![](images/fb75c68d2f8c0da36c1f5ab1ea3c806bea16df8a72eccf44e82552a1d3195e0e.jpg)  
+Figure 1: A schematic of the model architecture. See the main text for details.
+
+The neuroscience literature, however, suggests that biological visual systems infer and exploit the existence of objects, rather than spatial or temporal blocks with artificial boundaries [5, 30, 32]. Because objects are the atomic units of physical interactions, it makes sense to discretize on the level of objects. Numerous object segmentation algorithms have been proposed [15, 19, 29]. We chose to use MONet, an unsupervised object segmentation algorithm [2]. Because MONet is unsupervised, we can train it directly in our domain of interest without the need for object segmentation labels. We emphasize that our choice of MONet is an implementation detail, and in Appendix B, we show that our framework of attention over learned object embeddings also works with other object-segmentation schemes. We also do not need to place strong demands on the object segmentation algorithm, e.g. for it to produce aligned output or to have a built-in dynamics model.
+
+To segment each frame into object representations, MONet uses a recurrent attention network to obtain a set of $N _ { o }$ “object attention masks” ( $\mathrm { \Delta } N _ { o }$ is a fixed parameter). Each attention mask represents the probability that any given pixel belongs to that mask’s object. The pixels assigned to the mask are encoded into latent variables with means $\mu _ { t i } \in \mathbb { R } ^ { d }$ , where $i$ indexes the object slot and $t$ the frame. These means are used as the object embeddings in Aloe. More details are provided in Appendix A.1.
+
+The self-attention component is a transformer model [37] operating on a sequence of vectors in $\mathbb { R } ^ { d }$ : the object representations $\mu _ { t i }$ for all $t$ and $i$ , a trainable vector $\mathbf { \bar { \mathit { C L S } } } \in \mathbf { \bar { \mathbb { R } } ^ { d } }$ used to generate classification results (analogous to the CLS token in BERT [9]), and (for CLEVRER) the embedded words $\mathbf { w } _ { i }$ from the question (and choice for multiple choice questions). For the object representations $\mu _ { t i }$ and word embeddings $\mathbf { w } _ { i }$ , we append a two-dimensional one-hot vector to $\mu _ { t i }$ and $\mathbf { w } _ { i }$ to indicate whether the input is a word or an object. Because the transformer is shared between the modalities, information can flow between objects and words to solve the task, as we show in Section 3.1.
+
+We pass this sequence of vectors through a transformer with $N _ { T }$ layers. All inputs are first projected (via a linear layer and ReLU activation) to $\mathbb { R } ^ { N _ { H } \times d }$ , where $N _ { H }$ is the number of self-attention heads. We add a relative sinusoidal positional encoding at each layer of the transformer to give the model knowledge of the word and frame order [7]. The transformed value of $C L S$ is passed through an MLP (with one hidden layer of size $N _ { H }$ ) to generate the final answer. A schema of our architecture is shown in Figure 1.
+
+Note that in the model presented above (which we call global attention), the transformer sees no distinction between objects of different frames (other than through the position encoding). Another intuitive choice, which we call hierarchical attention, is to have one transformer acting on the objects of each frame independently, and another transformer acting on the concatenated outputs of the first transformer (this temporal division of input data is commonly used, e.g. in [35]). In pseudo-code, global attention can be expressed as
+
+![](images/8b8974247844831b2889dcf142e48a4d89360d0c23450734c7b5e9c93722a7eb.jpg)  
+Figure 2: Different masking schemes for self-supervised learning applied to Aloe.
+
+out $=$ transformer(reshape(objects, [B, F \* N, D])
+
+and hiearchical attention as
+
+out $=$ transformer1(reshape(objects, [B \* F, N, D])) out $=$ transformer2(reshape(out, [B, F, N $\star$ D])) .
+
+We study the importance of global attention (objects as the atomic entities) vs hierarchical attention (objects, and subsequently frames as the atomic entities). The comparison is shown in Table 1.
+
+# 2.1 Self-supervised learning
+
+We explored whether self-supervised learning could improve the performance of Aloe beyond the benefits conveyed by object-level representation, i.e. in ways that support the model’s interpretation of scene dynamics rather than just via improved perception of static observations. Our approach is inspired by the loss used in BERT [9], where a transformer model is trained to predict certain words that are masked from the input. In our case, we mask object embeddings, and train the model to infer the content of the masked object representations using its knowledge of unmasked objects.
+
+Concretely, during training, we multiply each MONet latent $\mu _ { t i }$ by a masking indicator, $m _ { t i } \in \{ 0 , 1 \}$ . Let $\mu _ { t i } ^ { \prime }$ be the transformed value of $m _ { t i } \mu _ { t i }$ after passing through the transformer. We expect the transformer to understand the underlying dynamics of the video, so that the masked out slot $\mu _ { t i }$ could be predicted from $\mu _ { t i } ^ { \prime }$ . To guide the transformer in learning effective representations capable of this type of dynamics prediction, we add an auxiliary loss:
+
+$$
+{ \mathrm { a u x i l i a r y ~ l o s s } } = \sum _ { t , i } { \tau _ { t i } l \left( f ( \mu _ { t i } ^ { \prime } ) , \mu \right) } ,
+$$
+
+where $f$ is a learned linear mapping to $\mathbb { R } ^ { d }$ , $l$ a loss function, and $\tau _ { t i } \in \{ 0 , 1 \}$ are one-hot indicator variables identifying the prediction targets (not necessarily just the masked out entries, since the prediction targets could be a subset of the masked out entries). We propagate gradients only to the parameters of $f$ and the transformer and not to the learned word and $C L S$ embeddings. This auxiliary loss is added to the main classification loss with weighting $\lambda$ , and both losses are minimized simultaneously by the optimizer. We do not pretrain the model with only the auxiliary loss.
+
+We tested two different loss functions for $l$ , an L2 loss and a contrastive loss (formulas given in Appendix A.2), and six different masking schemes (settings of $m _ { t i }$ and $\tau _ { t i }$ ), as illustrated in Figure 2. This exploration was motivated by the observation that video inputs at adjacent timesteps are highly correlated in a way that adjacent words are not. We thus hypothesized that BERT-style prediction of adjacent words might not be optimal. A different masking strategy, in which prediction targets are separated from the context by more than a single timestep, may stimulate capacity in the network to acquire knowledge that permits context-based unrolls and better long-horizon predictions.
+
+The simplest approach would be to set $m _ { t i } = 1$ uniformly at random across $t$ and $i$ , fixing the expected proportion of the $m _ { t i }$ set to 1 (schema $^ b$ in Figure 2). The targets would simply be the unmasked slots, $\tau _ { t i } = 1 - m _ { t i }$ . One potential problem with this approach is that multiple objects could be masked out in a single frame. MONet can unpredictably switch object-to-slot assignments multiple times in a single video. If multiple slots are masked out, the transformer cannot determine with certainty which missing object to assign to each slot. Thus, the auxiliary loss could penalize the model even if it predicted all the objects correctly. To avoid this problem, we also try constraining the mask such that exactly one slot is masked out per frame (schema $a$ ).
+
+To pose harder prediction challenges, we can add a buffer between the context (where $m _ { t i } = 1$ ) and the infilling targets (where $\tau _ { t i } = 1$ ). For $t$ in this buffer zone, both $m _ { t i } = 0$ and $\tau _ { t i } = 0$ (schemas $c { - } f )$ . We choose a single cutoff $T$ randomly, and we set $m _ { t i } = 0$ for $t < T$ and $m _ { t i } = 1$ for $t \geq T$ . In the presence of this buffer, we compared prediction (where the context is strictly before the targets; schema $c , d$ ) versus infilling (where the context surrounds the targets; schema $e , f ,$ ). We also compared setting the targets as individual objects (schema $c , e$ ) versus targets as all objects in the scene (schema $d , f )$ . We visually inspect the efficacy of this self-supervised loss in encouraging better representations (beyond improvements of scores on tasks) in Appendix D.
+
+# 3 Experiments
+
+We tested Aloe on three datasets, CLEVRER [41], CATER [12], and ACRE [44]. For each dataset, we pretrained a MONet model on individual frames. More training details and a table of hyperparameters are given in Appendix A.3; these hyperparameters were obtained through a hyperparameter sweep. All error bars are standard deviations computed over at least 5 random seeds.
+
+# 3.1 CLEVRER
+
+CLEVRER features videos of CLEVR objects [21] that move and collide with each other. For each video, several questions are posed to test the model’s understanding of the scene. Unlike most other visual question answering datasets, which test for only descriptive understanding (“what happened?”), CLEVRER poses other more complex questions, including explanatory questions (“why did something happen?”), predictive questions (“what will happen next?”), and counterfactual questions (“what would happen in a unseen circumstance?”) [41].
+
+We compare Aloe to state-of-the-art models reported in the literature: MAC $\left( \mathrm { V } + \right)$ and NS-DR [41], as well as the DCL model [6] (simultaneous to our work). MAC $\left( \mathrm { V } + \right)$ (based on the MAC network [20]) is an end-to-end network augmented with object information and trained using ground truth labels for object segmentation masks and features (e.g. color, shape). NS-DR and DCL are hybrid models that apply a symbolic logic engine to outputs of various neural networks. The neural networks are used to detect objects, predict dynamics, and parse the question into a program, and the symbolic executor runs the parsed program to obtain the final output. NS-DR is trained using ground truth labels and ground truth parsed programs, while DCL requires only the ground truth parsed programs.
+
+Table 1 shows the result of Aloe compared to these models. Across all categories, Aloe significantly outperforms the previous best models. Moreover, compared to the other models, Aloe does not use any labeled data other than the correct answer for the questions, nor does it require pretraining on any other dataset. Aloe also was not specifically designed for this task, and it straightforwardly generalizes to other tasks as well, such as CATER [12] and ACRE [44]. We provide a few sample model classifications on a randomly selected set of videos and questions in Appendix E.1 and detailed analysis of counterfactual questions in Appendix C. These examples suggest qualitatively that, for most instances where the model was incorrect, humans would plausibly furnish the same answer.
+
+Attention analysis (More analyses are given in Appendix D) We analyzed the cross-modal attention between question-words and the MONet objects. For each word, we determined the object that attended to that word with highest weight (for one head in the last layer). In the visualization below, the bounding boxes show the objects found by MONet, and each word is colored according to the
+
+Table 1: Performance (per question accuracy) on CLEVRER of Aloe compared to results from literature and to ablations: 1) MLP instead of self-attention; 2) ResNet superpixels instead of MONet objects; 3) hierarchical frame-level and intra-frame attention instead of global cross-frame object attention; 4) no auxiliary loss.   
+
+<table><tr><td>Model</td><td>Descriptive</td><td>Explanatory</td><td>Predictive</td><td>Counterfactual</td></tr><tr><td>MAC (V+)</td><td>86.4</td><td>22.3</td><td>42.9</td><td>25.1</td></tr><tr><td>NS-DR</td><td>88.1</td><td>79.6</td><td>68.7</td><td>42.2</td></tr><tr><td>DCL</td><td>90.7</td><td>82.8</td><td>82.0</td><td>46.5</td></tr><tr><td>Aloe</td><td>94.0 ± 0.4</td><td>96.0 ± 0.6</td><td>87.5 ± 3.0</td><td>75.6 ± 3.8</td></tr><tr><td>Aloe- self-attention+MLP</td><td>45.4</td><td>16.0</td><td>27.7</td><td>9.9</td></tr><tr><td>Aloe- object-repr. +ResNet</td><td>74.9</td><td>66.1</td><td>58.3</td><td>32.4</td></tr><tr><td>Aloe - global + hierarchical attn.</td><td>80.6</td><td>87.4</td><td>73.5</td><td>55.1</td></tr><tr><td>Aloe- self-supervised loss</td><td>91.0</td><td>92.8</td><td>82.8</td><td>68.7</td></tr></table>
+
+object that attended to it with highest weight (black represents a MONet slot without any objects).   
+We observe that generally, objects attend heavily to the words that describe them.
+
+![](images/229b16c4fda57fa6be8830ae071ce6a0ec54820c6c821a7f96d21f78abffa24d.jpg)
+
+Q: If the cylinder is removed, which event will not happen?
+
+1. The brown object collides with the green object.   
+2. The yellow object and the metal cube collide.   
+3. The yellow cube collides with the green object.
+
+We also looked at the objects that were most heavily attended upon in determining the final answer. The image below illustrates the attention weights for the $C L S$ token attending on each object (for one head in the last layer), when the model is tasked with assessing the first choice of the question above. The bounding boxes show the two most heavily attended upon objects for one transformer head. We observe that this head focuses on the green and brown objects (asked about in choice 1), but switches its focus to the cyan cylinder when it looks like the cylinder might collide with the cubes and change the outcome.
+
+![](images/f9813d948a0c16a84c18a5a51d92a5b3b2434d16be376473d12c2adad84e34ba.jpg)
+
+Model ablation Table 1 shows the contributions of various components of Aloe. First, self-attention is necessary for solving this problem. For comparison, we replace Aloe’s transformer with four fully connected layers with 2048 units per layer1. We find that an MLP is unable to answer non-descriptive questions effectively, despite using more parameters (20M vs 15M parameters).
+
+Second, we verify that an object-based discretization scheme is essential to the performance of Aloe. We compare with a version of the architecture where the MONet object representations $\mu _ { t i }$ are replaced with ResNet hyperpixels as in Zambaldi et al. [43]. Concretely, we flatten the output of the final convolutional layer of the ResNet to obtain a sequence of feature vectors that is fed into the transformer as the discrete entities. To match MONet’s pretraining regimen, we pretrain the ResNet on CLEVR [21] by training an Aloe model (using a ResNet instead of MONet) on the CLEVR task and initializing the ResNet used in the CLEVRER task with these pre-trained weights. We find that an object level representation, such as one output by MONet, greatly outperforms the locality-aware but object-agnostic ResNet representation.
+
+We also observe the importance of global attention between all objects across all frames, compared to a hierarchical attention model where objects within a frame could attend to each other but frames could only attend to each other as an atomic entity. We hypothesize that global attention may be important because with hierarchical attention, objects in different frames can only attend to each other at the “frame” granularity. A cube attending to a cube in a different frame would then gather information about the other non-cube objects, muddling the resulting representation.
+
+![](images/3444a8a096a123941b20407702c07de6ac1b82d124cdf4ea73c3ff1606e480c9.jpg)  
+Figure 3: Accuracy with/without auxiliary loss for different proportions of CLEVRER (row 1) and CATER (row 2) training data. We also show comparisons with previous and concurrent work. For CLEVRER, the lighter yellow bar represents the best neurosymbolic model DCL, and the darker yellow bar represents the previous best distributed model, MAC $\left( \mathrm { V } + \right)$ . For CATER, the lighter yellow bar represents Hopper and the darker yellow bar represents $\mathrm { R 3 D + N L }$ , the best published results for the moving camera dataset.
+
+Finally, we see that an auxiliary self-supervised loss improves the performance of the model by between 4 and 6 percentage points, with the greatest improvement on the counterfactual questions.
+
+Self-supervision strategies We compared the various masking schemes and loss functions for our auxiliary loss; a detailed figure is provided in Appendix A (Figure 4). We find that for all question types in CLEVRER, an L2 loss performs better than a contrastive loss, and among the masking schemes, masking one object per frame is the most effective. This particular result runs counter to our hypothesis that predictions or infilling in which the target is temporally removed from the context could encourage the model to learn more about scene dynamics and object interactions than (BERT-style) local predictions of adjacent targets. Of course, there may be other settings or loss functions that reveal the benefits of non-local prediction or constrastive losses; we leave this investigation to future work.
+
+Data efficiency We investigated how model performance varies as a function of the number of labelled (question-answer) pairs it learns from. To do so, we train models on $N \%$ of the videos and their associated labeled data. We evaluate the effect of including the auxiliary self-supervised loss (applied to the entire dataset, not just the labelled portion) in this low data regime. This scenario, where unlabeled data is plentiful while labeled data is scarce, occurs frequently in practice, since collecting labeled data is much more expensive than collecting unlabeled data.
+
+Figure 3 shows that our best model reaches the approximate level of the previous state-of-the-art approaches using only $50 \% - 6 0 \%$ of the data. The self-supervised auxiliary loss makes a particular improvement to performance in low-data regimes. For instance, when trained on only $50 \%$ of the available labelled data, self-supervised learning enables the model to reach a performance of $37 \%$ on counterfactual questions (compared to $2 5 \%$ by MAC $( \mathrm { V } + )$ and $42 \%$ by NS-DR on the full dataset), while without self-supervision, the model only reaches a performance of $13 \%$ (compared to the $10 \%$ achieved by answering randomly [41]).
+
+Table 2: Performance on CATER of Aloe compared to the best results from literature. We report top 1 accuracy, top 5 accuracy, and L1 distance between the predicted grid cell and true grid cell. The labels (S) and (M) refer to static and moving cameras.   
+
+<table><tr><td>Model</td><td>Top 1 (S)</td><td>Top 5 (S)</td><td>L1(S)</td><td>Top 1 (M)</td><td>Top 5 (M)</td><td>L1 (M)</td></tr><tr><td>R3DLSTM R3D+NL LSTM OPNet</td><td>60.2 46.2 74.8 73.2</td><td>81.8 69.9 1 93.8</td><td>1.2 1.5 0.54 0.85</td><td>28.6 38.6 1 1</td><td>63.3 70.2 1 1</td><td>1.7 1.5 -</td></tr><tr><td>Hopper Aloe (no auxiliary) Aloe Aloe (with L1 loss)</td><td>60.5 70.6 74.0 ± 0.3</td><td>84.5 93.0 94.0 ± 0.4</td><td>0.90 0.53 0.44 ± 0.01</td><td>46.8 56.6 59.7 ± 0.5</td><td>75.1 87.0 90.1 ± 0.6</td><td>- 1.3 0.82 0.69 ± 0.01</td></tr></table>
+
+# 3.2 CATER
+
+In a second experiment, we tested Aloe on CATER, a widely-used object-tracking dataset [12, 14, 31, 45]. In CATER, objects from the CLEVR dataset [21] move and potentially occlude other objects, and the goal is to predict the location of a target object (called the snitch) in the final frame. Because the snitch could be occluded by multiple objects that could move in the meantime, a successful model must be sensitive to notions of object permanence. CATER also includes a moving camera variant, which introduces additional complexities for the model.
+
+Concretely, CATER is setup as a classification challenge. Objects are located in an xyz coordinate system, where x and y range from -3 to 3. The xy plane is divided into a 6 by 6 grid, and the task is to predict the grid index of the snitch in the final frame. For Aloe, we use a classification loss (cross entropy over the 36 possible grid indices) and an L1 loss (L1 distance between predicted grid cell and the true grid cell).
+
+Table 2 shows Aloe compared to state-of-the-art models in the literature on both static and moving camera videos. R3D and R3D NL are the strongest two models evaluated by Girdhar and Ramanan [12]. OPNet, or the Object Permanence Network [31], is an architecture with inductive biases designed for object tracking tasks; it was trained with extra supervised labels, namely the bounding boxes for all objects (including occluded ones). Hopper is a multi-hop transformer model developed simultaneously with this work [45]. One key component of Hopper is Hungarian matching between objects of different frames, a strong inductive bias for object tracking.
+
+We train Aloe simultaneously on both static and moving camera videos. Aloe outperforms the R3D models for both static and moving cameras. We also ran Aloe with an additional auxiliary loss consisting of the L1 distance between the predicted cell and the actual cell. With this additional loss, we get comparable results in the moving camera case as the R3D models for the static camera case. Moreover, we achieve comparable accuracy as OPNet for accuracy and L1 distance, despite requiring less supervision to train. Appendix E.2 gives a few sample outputs from Aloe; in particular we note that it is able to find the target object in several cases where the object was occluded, demonstrating that Aloe is able to do some level of object tracking. Finally,we find that an auxiliary self-supervised loss helps the model perform well in the low data regime for CATER as well, as shown in Figure 3.
+
+# 3.3 ACRE
+
+Finally, we measured Aloe’s performance on ACRE, a causal induction dataset inspired by the Blicket task from developmental psychology [13, 44]. ACRE is divided into a set of problems. In each problem, certain objects are chosen to be “Blickets”, and this assignment changes across problems. Each problem presents a context of six images to the model, where different objects are placed on a Blicket machine that lights up if one of those objects is a Blicket. The model is asked whether an unseen combination of objects will light up the Blicket machine. Besides “yes” and “no”, a third possible answer is “undetermined”, which is the case if it is impossible to determine for certain if the objects will light up the machine. Correct inference goes beyond mere correlation: even if every context scene involving object A has a lit-up machine, A’s Blicketness is still uncertain if each of those scenes can potentially be explained by another object (deduction of A’s Blicketness is backward-blocked).
+
+Table 3: Performance on ACRE of Aloe compared to the best results from Zhang et al. [44], split across inference type $\mathrm { { D . R = } } 1$ Direct, I.D $\Vdash$ Indirect, ${ \bf { S . O } } \mathrm { { = } } \mathrm { { ; } }$ Screen-Off, B.B $\ c =$ Backwards Blocking) and generalization type ( $\mathrm { C } =$ Compositional, ${ \bf S } =$ Systematic).   
+
+<table><tr><td>Model</td><td>All (C)</td><td>D.R.</td><td>I.D.</td><td>S.0.</td><td>B.B.</td><td>All (S)</td><td>D.R.</td><td>1.D.</td><td>S.0.</td><td>B.B</td></tr><tr><td>CNN-BERT</td><td>43.79</td><td>54.07</td><td>46.88</td><td>40.57</td><td>28.79</td><td>39.93</td><td>55.97</td><td>68.25</td><td>0.00</td><td>45.59</td></tr><tr><td>NS-OPT</td><td>69.04</td><td>92.5</td><td>76.05</td><td>88.33</td><td>13.48</td><td>67.44</td><td>94.73</td><td>88.38</td><td>82.76</td><td>16.06</td></tr><tr><td>Aloe</td><td>91.76</td><td>97.14</td><td>90.8</td><td>96.8</td><td>78.81</td><td>93.90</td><td>97.18</td><td>71.24</td><td>98.97</td><td>94.48</td></tr></table>
+
+Inference problems in ACRE are categorized by reasoning type: reasoning from direct evidence (one of the context frames show the query objects on a machine), reasoning from indirect evidence (Blicketness must be deduced by combining evidence from several frames), screened-off reasoning (presence of non-Blickets do not matter if a single Blicket is present), and backward-blocked reasoning (Blicketness cannot be deduced due to confounding variables). Please see Zhang et al. [44] for a more detailed discussion of these reasoning types.
+
+Table 3 show Aloe performance compared to a CNN-BERT baseline and to NS-OPT, a neuro-symbolic model introduced in Zhang et al. [44]. Aloe outperforms all extant models for almost all reasoning types and train-test splits. We did not need to do any tuning to apply our model to ACRE—settings from CATER yielded the reported results on the first attempt. Contrary to widely-held opinions that neural networks cannot generalize, Aloe generalizes in scenarios where the training and test sets contain different visual features (compositional split) or different numbers of activated machines in the context (systematic split). Moreover, Aloe achieved by far the best performance on the backwardblocking task, which requires the model to “go beyond the simple covariation strategy to discover the hidden causal relations” [44], dispelling the notion that neural networks can only find correlation. Comparison with NS-OPT (which uses object representations) and CNN-BERT (which uses attention) shows that neither object representations nor attention alone is sufficient for the task; combining these two ideas, as done in Aloe for instance, is essential for this complex reasoning task as well.
+
+# 4 Related work
+
+Self-attention for reasoning Various studies have shown that transformers [37] can manipulate symbolic data in a manner traditionally associated with symbolic computation. For example, in Lample and Charton [23], a transformer model learned to do symbolic integration and solve ordinary differential equations symbolically, tasks traditionally reserved for symbolic computer algebra systems. Similarly, in Hahn et al. [17], a transformer model learned to solve formulas in propositional logic and demonstrated some degree of generalization to out of distribution formulas. Finally, Brown et al. [1] showed that a transformer trained for language modeling can also do simple analogical reasoning tasks without explicit training. Although these models do not necessarily beat carefully tuned symbolic algorithms in all cases (especially on out of distribution data), they are an important motivation for our proposed recipe for attaining strong reasoning capabilities from self-attention-based models on visually grounded tasks.
+
+Object representations A wide body of research points to the importance of object segmentation and representation learning (see e.g. Garnelo and Shanahan [11] for a discussion). Various methods have been proposed for object detection and feature extraction [2, 10, 15, 19, 25, 26, 29]. Past research have also investigated using object based representations in downstream tasks [8, 28].
+
+Self-supervised learning Another line of research concerns learning good representations through self-supervised learning, with an unsupervised auxiliary loss to encourage the discovery of better representations. These better representations could lead to improved performance on supervised tasks, especially when labeled data is scarce. In Devlin et al. [9], for instance, an auxiliary infill loss allows the BERT model to benefit from pretraining on a large corpus of unlabeled data. Our approach to object-centric self-supervised learning is heavily inspired by the BERT infilling loss. Other studies have shown similar benefits to auxiliary learning in vision as well [4, 16, 18]. These works apply various forms of contrastive losses to predict scene dynamics, and the better representations that result carry downstream benefits to supervised and reinforcement learning tasks.
+
+Vision and language in self-attention models Recently, many works have emerged on applying transformer models to visual and multimodal data, for static images [24, 27, 33, 36] and videos [34, 35, 43]. These approaches combine the output of convolutional networks with language in various ways using self-attention. While these previous works focused on popular visual question answering tasks, which typically consist of descriptive questions only [41], we focus on understanding deeper causal dynamics of videos. Together with these works, we provide more evidence that self-attention between visual and language elements enables good performance on a diverse set of tasks.
+
+In addition, while the use of object representations for discretization in tasks involving static images is becoming more popular, the right way to discretize videos is less clear. We provide strong evidence in the form of ablation studies for architectural decisions that we claim are essential for higher reasoning for this type of data: visual elements should correspond to physical objects in the videos and inter-frame attention between sub-frame entities (as opposed to inter-frame attention of entire frames) is crucial. We also demonstrate the success of using unsupervised object segmentation methods as opposed to the supervised methods used in past work.
+
+# 5 Conclusion
+
+We have presented Aloe, a model that obtains state-of-the-art performance on three different task domains involving spatiotemporal reasoning about objects. In each of these tasks, previous state-ofthe-art results were established by models with modular, task-specific components. Aloe, by contrast, is a unified solution to all three domains. Its flexibility comes from a reliance on only soft biases and learning objectives: self-attention over learned object embeddings and self-supervised learning of dynamics. We believe the simplicity of this approach is its strength, and hope that this fact, together with the provided code, makes it easy for others to adopt and apply to arbitrary spatio-temporal reasoning problems.
+
+On many of these spatio-temporal reasoning problems, previous state-of-the-art was achieved by neuro-symbolic models [6, 11, 40, 41, 44]. Compared to neuro-symbolic models, Aloe can more easily be adapted to other tasks. Indeed, the symbolic components of neuro-symbolic models are often task-specific and not straightforwardly applicable to other tasks. Neuro-symbolic models do have a few advantages, however. First, they are often easier to interpret. Despite the insights that can be gleaned from Aloe’s attention weights, these soft computations are harder to interpret than the explicit symbolic computation found in neuro-symbolic models. Moreover, neuro-symbolic models can be structured in a more modular fashion, which can enable effective generalization to sub-tasks of the task on which the model was trained [6].
+
+Aloe also has some important limitations. First, it has only been applied to synthetic datasets. This limitation is mainly due to the lack of real-world datasets that test for higher-order spatiotemporal reasoning, although we are excited that new datasets such as Traffic QA will be released soon [38]. Second, while the domains where Aloe is applied have been widely adopted and well-received by the research community, it remains possible that they do not evaluate the capacities that they aim to evaluate because of hidden biases or other factors. Regardless, we hope that this work stimulates the design and development of more challenging tasks that more closely approximate the ultimate goal of human or super-human-level visual, spatiotemporal and causal reasoning. Finally, from an ethical point of view, our model may share the common drawback of deep-learning models in perpetuating biases found in the training data, especially when applied to real world data. Development of causal reasoning models could also invite problematic applications involving automated assignment of blame.
+
+References   
+[1] Tom B Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. Language models are few-shot learners. arXiv preprint arXiv:2005.14165, 2020.   
+[2] Chris P. Burgess, Loic Matthey, Nick Watters, Rishabh Kabra, Irina Higgins, Matt Botvinick, and Alex Lerchner. MONet: Unsupervised scene decomposition and representation. arXiv preprint arXiv:1901.11390, 2019.   
+[3] Nicolas Carion, Francisco Massa, Gabriel Synnaeve, Nicolas Usunier, Alexander Kirillov, and Sergey Zagoruyko. End-to-end object detection with transformers. In ECCV, 2020.   
+[4] Ting Chen, Simon Kornblith, Mohammad Norouzi, and Geoffrey Hinton. A simple framework for contrastive learning of visual representations. arXiv preprint arXiv:2002.05709, 2020.   
+[5] Zhe Chen. Object-based attention: A tutorial review. Attention, Perception, & Psychophysics, 74:784–802, 2012. URL https://doi.org/10.3758/s13414-012-0322-z.   
+[6] Zhenfang Chen, Jiayuan Mao, Jiajun Wu, Kwan-Yee Kenneth Wong, Joshua B. Tenenbaum, and Chuang Gan. Grounding physical object and event concepts through dynamic visual reasoning. In International Conference on Learning Representations, 2021. URL https: //arxiv.org/pdf/2103.16564.pdf.   
+[7] Zihang Dai, Zhilin Yang, Yiming Yang, William W Cohen, Jaime Carbonell, Quoc V Le, and Ruslan Salakhutdinov. Transformer-xl: Attentive language models beyond a fixed-length context. arXiv preprint arXiv:1901.02860, 2019.   
+[8] Mikyas T. Desta, Larry Chen, and Tomasz Kornuta. Object-based reasoning in VQA. CoRR, abs/1801.09718, 2018. URL http://arxiv.org/abs/1801.09718.   
+[9] Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. BERT: Pre-training of deep bidirectional transformers for language understanding. arXiv preprint arXiv:1810.04805, 2018.   
+[10] Yilun Du, Kevin Smith, Tomer Ulman, Joshua Tenenbaum, and Jiajun Wu. Unsupervised discovery of 3d physical objects from video. arXiv preprint arXiv:2007.12348, 2020.   
+[11] Marta Garnelo and Murray Shanahan. Reconciling deep learning with symbolic artificial intelligence: representing objects and relations. Current Opinion in Behavioral Sciences, 29: 17–23, 2019.   
+[12] Rohit Girdhar and Deva Ramanan. CATER: A diagnostic dataset for Compositional Actions and TEmporal Reasoning. In ICLR, 2020.   
+[13] Alison Gopnik and David Sobel. Detecting blickets: how young children use information about novel causal powers in categorization and induction. Child Dev, pages 1205–22, 2000. doi: 10.1111/1467-8624.00224.   
+[14] Anirudh Goyal, Aniket Didolkar, Alex Lamb, Kartikeya Badola, Nan Rosemary Ke, Nasim Rahaman, Jonathan Binas, Charles Blundell, Michael Mozer, and Yoshua Bengio. Coordination among neural modules through a shared global workspace. CoRR, abs/2103.01197, 2021. URL https://arxiv.org/abs/2103.01197.   
+[15] Klaus Greff, Raphaël Lopez Kaufman, Rishabh Kabra, Nick Watters, Christopher Burgess, Daniel Zoran, Loïc Matthey, Matthew Botvinick, and Alexander Lerchner. Multi-object representation learning with iterative variational inference. CoRR, abs/1903.00450, 2019. URL http://arxiv.org/abs/1903.00450.   
+[16] Karol Gregor, Danilo Jimenez Rezende, Frederic Besse, Yan Wu, Hamza Merzic, and Aaron van den Oord. Shaping belief states with generative environment models for rl. In H. Wallach, H. Larochelle, A. Beygelzimer, F. d’ Alché-Buc, E. Fox, and R. Garnett, editors, Advances in Neural Information Processing Systems 32, pages 13475–13487. Curran Associates, Inc., 2019. URL http://papers.nips.cc/paper/ 9503-shaping-belief-states-with-generative-environment-models-f pdf.
+
+[17] Christopher Hahn, Frederik Schmitt, Jens U. Kreber, Markus N. Rabe, and Bernd Finkbeiner. Transformers generalize to the semantics of logics. arXiv preprint arXiv:2003.04218, 2020.
+
+[18] Tengda Han, Weidi Xie, and Andrew Zisserman. Video representation learning by dense predictive coding. In Workshop on Large Scale Holistic Video Understanding, ICCV, 2019.
+
+[19] Kaiming He, Georgia Gkioxari, Piotr Dollár, and Ross B. Girshick. Mask R-CNN. CoRR, abs/1703.06870, 2017. URL http://arxiv.org/abs/1703.06870.
+
+[20] Drew A Hudson and Christopher D Manning. Compositional attention networks for machine reasoning. 2018.
+
+[21] Justin Johnson, Bharath Hariharan, Laurens van der Maaten, Li Fei-Fei, C. Lawrence Zitnick, and Ross B. Girshick. CLEVR: A diagnostic dataset for compositional language and elementary visual reasoning. CoRR, abs/1612.06890, 2016. URL http://arxiv.org/abs/1612. 06890.
+
+[22] Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+[23] Guillaume Lample and François Charton. Deep learning for symbolic mathematics. In International Conference on Learning Representations, 2020. URL https://openreview.net/ forum?id ${ . } = { }$ S1eZYeHFDS.
+
+[24] Liunian Harold Li, Mark Yatskar, Da Yin, Cho-Jui Hsieh, and Kai-Wei Chang. Visualbert: A simple and performant baseline for vision and language. arXiv preprint arXiv:1908.03557, 2019.
+
+[25] Zhixuan Lin, Yi-Fu Wu, Skand Vishwanath Peri, Weihao Sun, Gautam Singh, Fei Deng, Jindong Jiang, and Sungjin Ahn. SPACE: Unsupervised object-oriented scene representation via spatial attention and decomposition. In International Conference on Learning Representations, 2020. URL https://openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } }$ rkl03ySYDH.
+
+[26] Francesco Locatello, Dirk Weissenborn, Thomas Unterthiner, Aravindh Mahendran, Georg Heigold, Jakob Uszkoreit, Alexey Dosovitskiy, and Thomas Kipf1. Object-Centric Learning with Slot Attention. In Advances in Neural Information Processing Systems (NIPS), 2020.
+
+[27] Jiasen Lu, Dhruv Batra, Devi Parikh, and Stefan Lee. Vilbert: Pretraining task-agnostic visiolinguistic representations for vision-and-language tasks. arXiv preprint arXiv:1908.02265, 2019.
+
+[28] David Raposo, Adam Santoro, David G. T. Barrett, Razvan Pascanu, Timothy P. Lillicrap, and Peter W. Battaglia. Discovering objects and their relations from entangled scene representations. CoRR, abs/1702.05068, 2017. URL http://arxiv.org/abs/1702.05068.
+
+[29] Shaoqing Ren, Kaiming He, Ross B. Girshick, and Jian Sun. Faster R-CNN: towards realtime object detection with region proposal networks. CoRR, abs/1506.01497, 2015. URL http://arxiv.org/abs/1506.01497.
+
+[30] Pieter R. Roelfsema, Victor A. Lamme, and Henk Spekreijse. Object-based attention in the primary visual cortex of the macaque monkey. Nature, 395:376–381, 1998. doi: 10.1038/26475.
+
+[31] Aviv Shamsian, Ofri Kleinfeld, Amir Globerson, and Gal Chechik. Learning object permanence from video. arXiv preprint arXiv:2003.10469, 2020.
+
+[32] Elizabeth Spelke. Core knowledge. The American psychologist, 55:1233–43, 12 2000. doi: 10.1037/0003-066X.55.11.1233.
+
+[33] Weijie Su, Xizhou Zhu, Yue Cao, Bin Li, Lewei Lu, Furu Wei, and Jifeng Dai. Vl-bert: Pretraining of generic visual-linguistic representations. In International Conference on Learning Representations, 2020. URL https://openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ SygXPaEYvH.
+
+[34] Chen Sun, Fabien Baradel, Kevin Murphy, and Cordelia Schmid. Contrastive bidirectional transformer for temporal representation learning. CoRR, abs/1906.05743, 2019. URL http: //arxiv.org/abs/1906.05743.
+
+[35] Chen Sun, Austin Myers, Carl Vondrick, Kevin Murphy, and Cordelia Schmid. Videobert: A joint model for video and language representation learning. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), October 2019.
+
+[36] Hao Tan and Mohit Bansal. Lxmert: Learning cross-modality encoder representations from transformers. In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing, 2019.
+
+[37] 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.
+
+[38] Li Xu, He Huang, and Jun Liu. Sutd-trafficqa: A question answering benchmark and an efficient network for video reasoning over traffic events. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, 2021.
+
+[39] Kexin Yi, Jiajun Wu, Chuang Gan, Antonio Torralba, Pushmeet Kohli, and Joshua B Tenenbaum. Neural-Symbolic VQA: Disentangling Reasoning from Vision and Language Understanding. In Advances in Neural Information Processing Systems (NIPS), 2018.
+
+[40] Kexin Yi, Jiajun Wu, Chuang Gan, Antonio Torralba, Pushmeet Kohli, and Joshua B. Tenenbaum. Neural-symbolic vqa: Disentangling reasoning from vision and language understanding. In Advances in Neural Information Processing Systems, pages 1039–1050, 2018.
+
+[41] Kexin Yi, Chuang Gan, Yunzhu Li, Pushmeet Kohli, Jiajun Wu, Antonio Torralba, and Joshua B. Tenenbaum. CLEVRER: Collision events for video representation and reasoning. In International Conference on Learning Representations, 2020. URL https: //openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ HkxYzANYDB.
+
+[42] Yang You, Jing Li, Sashank Reddi, Jonathan Hseu, Sanjiv Kumar, Srinadh Bhojanapalli, Xiaodan Song, James Demmel, and Cho-Jui Hsieh. Large batch optimization for deep learning: Training BERT in 76 minutes. Technical Report UCB/EECS-2019-103, EECS Department, University of California, Berkeley, Jun 2019. URL http://www2.eecs.berkeley.edu/Pubs/ TechRpts/2019/EECS-2019-103.html.
+
+[43] Vinicius Zambaldi, David Raposo, Adam Santoro, Victor Bapst, Yujia Li, Igor Babuschkin, Karl Tuyls, David Reichert, Timothy Lillicrap, Edward Lockhart, Murray Shanahan, Victoria Langston, Razvan Pascanu, Matthew Botvinick, Oriol Vinyals, and Peter Battaglia. Deep reinforcement learning with relational inductive biases. In International Conference on Learning Representations, 2019. URL https://openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ HkxaFoC9KQ.
+
+[44] Chi Zhang, Baoxiong Jia, Mark Edmonds, Song-Chun Zhu, and Yixin Zhu. Acre: Abstract causal reasoning beyond covariation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2021.
+
+[45] Honglu Zhou, Asim Kadav, Farley Lai, Alexandru Niculescu-Mizil, Martin Renqiang Min, Mubbasir Kapadia, and Hans Peter Graf. Hopper: Multi-hop transformer for spatiotemporal reasoning. In International Conference on Learning Representations, 2021. URL https: //arxiv.org/abs/2103.10574.

parse/train/lHmhW2zmVN/lHmhW2zmVN_content_list.json

@@ -0,0 +1,1278 @@
+[
+    {
+        "type": "text",
+        "text": "Attention over learned object embeddings enables complex visual reasoning ",
+        "text_level": 1,
+        "bbox": [
+            197,
+            122,
+            802,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "David Ding Felix Hill Adam Santoro Malcolm Reynolds Matt Botvinick DeepMind London, United Kingdom   \n{fding, felixhill, adamsantoro, mareynolds, botvinick}@google.com ",
+        "bbox": [
+            181,
+            224,
+            821,
+            282
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            318,
+            535,
+            334
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Neural networks have achieved success in a wide array of perceptual tasks but often fail at tasks involving both perception and higher-level reasoning. On these more challenging tasks, bespoke approaches (such as modular symbolic components, independent dynamics models or semantic parsers) targeted towards that specific type of task have typically performed better. The downside to these targeted approaches, however, is that they can be more brittle than general-purpose neural networks, requiring significant modification or even redesign according to the particular task at hand. Here, we propose a more general neural-network-based approach to dynamic visual reasoning problems that obtains state-of-the-art performance on three different domains, in each case outperforming bespoke modular approaches tailored specifically to the task. Our method relies on learned object-centric representations, self-attention and self-supervised dynamics learning, and all three elements together are required for strong performance to emerge. The success of this combination suggests that there may be no need to trade off flexibility for performance on problems involving spatio-temporal or causal-style reasoning. With the right soft biases and learning objectives in a neural network we may be able to attain the best of both worlds. ",
+        "bbox": [
+            233,
+            348,
+            766,
+            582
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            607,
+            310,
+            625
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Despite the popularity of artificial neural networks, a body of recent work has focused on their limitations as models of cognition and reasoning. Experiments with dynamical reasoning datasets such as CLEVRER [41], CATER [12], and ACRE [44] show that neural networks can fail to adequately reason about the spatio-temporal, compositional or causal structure of visual scenes. On CLEVRER, where models must answer questions about the dynamics of colliding objects, previous experiments show that neural networks can adequately describe the video, but fail when asked to predict, explain, or consider counterfactual possibilities. Similarly, on CATER, an object-tracking task, models have trouble tracking the movement of objects when they are hidden in a container. Finally, on ACRE, a dataset testing for causal inference, popular models only learned correlations between visual scenes and not the deeper causal logic. ",
+        "bbox": [
+            174,
+            638,
+            825,
+            777
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Failures such as these on reasoning (rather than perception) problems have motivated the adoption of pipeline-style approaches that combine a general purpose neural network (such as a convolutional block) with a task-specific module that builds in the core logic of the task. For example, on CLEVRER the NS-DR method [41] applies a hand-coded symbolic logic engine (that has the core logic of CLEVRER built-in) to the outputs of a “perceptual” neural front-end, achieving better results than neural network baselines, particularly on counterfactual and explanatory problems. One limitation of these pipeline approaches, however, is that they are typically created with a single problem or problem domain in mind, and may not apply out-of-the-box to other related problems. For example, to apply NS-DR to CATER, the entire symbolic module needs to be rewritten to handle the new interactions and task logic of CATER: the custom logic to handle collisions and object removal must be replaced with new custom logic to handle occlusions and grid-resolution, and these changes require further modifications to the perceptual front-end to output data in a new format. This brittleness is not exclusive to symbolic approaches. While Hungarian-matching between object embeddings may be well-suited for object-tracking tasks [45], it is not obvious how it would help for causal inference tasks. ",
+        "bbox": [
+            174,
+            784,
+            825,
+            867
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            215
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Here, we describe a more general neural-network-based approach to visual spatio-temporal reasoning problems, which does not rely on task-specific integration of modular components. In place of these components, our model relies on three key aspects: ",
+        "bbox": [
+            176,
+            222,
+            825,
+            263
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• Self-attention to effectively integrate information over time   \n• Soft-discretization of the input at the most informative level of abstraction – above pixels and local features, and below entire frames—corresponding approximately to ‘objects’   \nSelf-supervised learning, i.e. requiring the model to infer masked out objects, to extract more information about dynamics from each sample. ",
+        "bbox": [
+            192,
+            275,
+            825,
+            357
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "While many past models have applied each individual ingredient separately (including on the tasks we study), we show that it is the combination of all three ingredients in the right way that allows our model to succeed. ",
+        "bbox": [
+            178,
+            368,
+            823,
+            410
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The resulting model, which we call Aloe (Attention over Learned Object Embeddings), outperforms both pipeline and neural-network-based approaches on three different task domains designed to test physical and dynamical reasoning from pixel inputs. We highlight our key results here: ",
+        "bbox": [
+            178,
+            416,
+            823,
+            458
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• CLEVRER (explanatory, predictive, and counterfactual reasoning): Aloe achieves significantly higher accuracy than both more task-specific, modular approaches, and previous neural network methods on all question types. On counterfactual questions, thought to be most challenging for neural-only architectures, we achieve $75 \\%$ vs $46 \\%$ accuracy for more specialised methods. • CATER (object-permanence): Aloe achieves accuracy exceeding or matching other current models. Notably, the strongest alternative models were expressly designed for object-tracking, whereas our architecture is applicable without modification to other reasoning tasks as well. ACRE (causal-inference “beyond the simple strategy of inducing causal relationships by covariation” [44]): Overall, Aloe achieves $94 \\%$ vs the $67 \\%$ accuracy achieved by the top neuro-symbolic model. On the most challenging tasks, we achieve, for “backward-blocking” inference, $9 4 . 4 8 \\%$ (vs $1 6 . 0 6 \\%$ by the best modular, neuro-symbolic systems), and, for “screenoff” inference, $9 8 . 9 7 \\%$ (vs ${ \\bf0 . 0 0 \\% }$ by a CNN-BERT baseline). ",
+        "bbox": [
+            192,
+            469,
+            826,
+            647
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "As we have emphasized, the previous best performing models for each task all contain task-specific design elements, whereas Aloe can be applied to all the tasks without modification. On CLEVRER, we also show that Aloe matches the performance of the previous best models with $40 \\%$ less training data, which demonstrates that our approach is data-efficient as well as performant. ",
+        "bbox": [
+            176,
+            659,
+            825,
+            714
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Methods ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            734,
+            279,
+            751
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A guiding motivation for the design of Aloe is the converging evidence for the value of self-attention mechanisms operating on a finite sequences of discrete entities. Written language is inherently discrete and hence is well-suited to self-attention-based approaches. In other domains, such as raw audio or vision, it is less clear how to leverage self-attention. We hypothesize that the application of self-attention-based models to visual tasks could benefit from an approximate ‘discretization’ process, and determining the right level of discretization is an important choice that can significantly affect model performance. ",
+        "bbox": [
+            174,
+            766,
+            825,
+            863
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "At the finest level, data could simply be discretized into pixels (as is already the case for most machine-processed visual data). Pixels are too fine-grained for many applications, however—for one, the memory required to support self-attention across all pixels is prohibitive. Partly for this reason, coarser representations, such as the downsampled “hyper-pixel” outputs of a convolutional network, are often used instead (e.g. [27, 43]). In the case of videos, previous work considered even coarser discretization schemes, such as frame or subclip level representations [35]. ",
+        "bbox": [
+            176,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/fb75c68d2f8c0da36c1f5ab1ea3c806bea16df8a72eccf44e82552a1d3195e0e.jpg",
+        "image_caption": [
+            "Figure 1: A schematic of the model architecture. See the main text for details. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            251,
+            93,
+            761,
+            300
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            366,
+            825,
+            409
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The neuroscience literature, however, suggests that biological visual systems infer and exploit the existence of objects, rather than spatial or temporal blocks with artificial boundaries [5, 30, 32]. Because objects are the atomic units of physical interactions, it makes sense to discretize on the level of objects. Numerous object segmentation algorithms have been proposed [15, 19, 29]. We chose to use MONet, an unsupervised object segmentation algorithm [2]. Because MONet is unsupervised, we can train it directly in our domain of interest without the need for object segmentation labels. We emphasize that our choice of MONet is an implementation detail, and in Appendix B, we show that our framework of attention over learned object embeddings also works with other object-segmentation schemes. We also do not need to place strong demands on the object segmentation algorithm, e.g. for it to produce aligned output or to have a built-in dynamics model. ",
+        "bbox": [
+            174,
+            415,
+            825,
+            553
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To segment each frame into object representations, MONet uses a recurrent attention network to obtain a set of $N _ { o }$ “object attention masks” ( $\\mathrm { \\Delta } N _ { o }$ is a fixed parameter). Each attention mask represents the probability that any given pixel belongs to that mask’s object. The pixels assigned to the mask are encoded into latent variables with means $\\mu _ { t i } \\in \\mathbb { R } ^ { d }$ , where $i$ indexes the object slot and $t$ the frame. These means are used as the object embeddings in Aloe. More details are provided in Appendix A.1. ",
+        "bbox": [
+            174,
+            559,
+            825,
+            628
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The self-attention component is a transformer model [37] operating on a sequence of vectors in $\\mathbb { R } ^ { d }$ : the object representations $\\mu _ { t i }$ for all $t$ and $i$ , a trainable vector $\\mathbf { \\bar { \\mathit { C L S } } } \\in \\mathbf { \\bar { \\mathbb { R } } ^ { d } }$ used to generate classification results (analogous to the CLS token in BERT [9]), and (for CLEVRER) the embedded words $\\mathbf { w } _ { i }$ from the question (and choice for multiple choice questions). For the object representations $\\mu _ { t i }$ and word embeddings $\\mathbf { w } _ { i }$ , we append a two-dimensional one-hot vector to $\\mu _ { t i }$ and $\\mathbf { w } _ { i }$ to indicate whether the input is a word or an object. Because the transformer is shared between the modalities, information can flow between objects and words to solve the task, as we show in Section 3.1. ",
+        "bbox": [
+            174,
+            635,
+            825,
+            732
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We pass this sequence of vectors through a transformer with $N _ { T }$ layers. All inputs are first projected (via a linear layer and ReLU activation) to $\\mathbb { R } ^ { N _ { H } \\times d }$ , where $N _ { H }$ is the number of self-attention heads. We add a relative sinusoidal positional encoding at each layer of the transformer to give the model knowledge of the word and frame order [7]. The transformed value of $C L S$ is passed through an MLP (with one hidden layer of size $N _ { H }$ ) to generate the final answer. A schema of our architecture is shown in Figure 1. ",
+        "bbox": [
+            174,
+            738,
+            825,
+            821
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Note that in the model presented above (which we call global attention), the transformer sees no distinction between objects of different frames (other than through the position encoding). Another intuitive choice, which we call hierarchical attention, is to have one transformer acting on the objects of each frame independently, and another transformer acting on the concatenated outputs of the first transformer (this temporal division of input data is commonly used, e.g. in [35]). In pseudo-code, global attention can be expressed as ",
+        "bbox": [
+            174,
+            828,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/8b8974247844831b2889dcf142e48a4d89360d0c23450734c7b5e9c93722a7eb.jpg",
+        "image_caption": [
+            "Figure 2: Different masking schemes for self-supervised learning applied to Aloe. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            98,
+            820,
+            325
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "out $=$ transformer(reshape(objects, [B, F \\* N, D]) ",
+        "bbox": [
+            207,
+            385,
+            642,
+            398
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "and hiearchical attention as ",
+        "bbox": [
+            174,
+            405,
+            354,
+            419
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "out $=$ transformer1(reshape(objects, [B \\* F, N, D])) out $=$ transformer2(reshape(out, [B, F, N $\\star$ D])) . ",
+        "bbox": [
+            207,
+            425,
+            655,
+            459
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We study the importance of global attention (objects as the atomic entities) vs hierarchical attention (objects, and subsequently frames as the atomic entities). The comparison is shown in Table 1. ",
+        "bbox": [
+            171,
+            465,
+            825,
+            494
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.1 Self-supervised learning ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            512,
+            380,
+            527
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We explored whether self-supervised learning could improve the performance of Aloe beyond the benefits conveyed by object-level representation, i.e. in ways that support the model’s interpretation of scene dynamics rather than just via improved perception of static observations. Our approach is inspired by the loss used in BERT [9], where a transformer model is trained to predict certain words that are masked from the input. In our case, we mask object embeddings, and train the model to infer the content of the masked object representations using its knowledge of unmasked objects. ",
+        "bbox": [
+            173,
+            537,
+            825,
+            622
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Concretely, during training, we multiply each MONet latent $\\mu _ { t i }$ by a masking indicator, $m _ { t i } \\in \\{ 0 , 1 \\}$ . Let $\\mu _ { t i } ^ { \\prime }$ be the transformed value of $m _ { t i } \\mu _ { t i }$ after passing through the transformer. We expect the transformer to understand the underlying dynamics of the video, so that the masked out slot $\\mu _ { t i }$ could be predicted from $\\mu _ { t i } ^ { \\prime }$ . To guide the transformer in learning effective representations capable of this type of dynamics prediction, we add an auxiliary loss: ",
+        "bbox": [
+            173,
+            627,
+            825,
+            698
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ec34b10eb5dbd048dcd818839d9d4c52bdbb686a32df86c0e869749c1ec07022.jpg",
+        "text": "$$\n{ \\mathrm { a u x i l i a r y ~ l o s s } } = \\sum _ { t , i } { \\tau _ { t i } l \\left( f ( \\mu _ { t i } ^ { \\prime } ) , \\mu \\right) } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            377,
+            707,
+            619,
+            742
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $f$ is a learned linear mapping to $\\mathbb { R } ^ { d }$ , $l$ a loss function, and $\\tau _ { t i } \\in \\{ 0 , 1 \\}$ are one-hot indicator variables identifying the prediction targets (not necessarily just the masked out entries, since the prediction targets could be a subset of the masked out entries). We propagate gradients only to the parameters of $f$ and the transformer and not to the learned word and $C L S$ embeddings. This auxiliary loss is added to the main classification loss with weighting $\\lambda$ , and both losses are minimized simultaneously by the optimizer. We do not pretrain the model with only the auxiliary loss. ",
+        "bbox": [
+            173,
+            751,
+            825,
+            837
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We tested two different loss functions for $l$ , an L2 loss and a contrastive loss (formulas given in Appendix A.2), and six different masking schemes (settings of $m _ { t i }$ and $\\tau _ { t i }$ ), as illustrated in Figure 2. This exploration was motivated by the observation that video inputs at adjacent timesteps are highly correlated in a way that adjacent words are not. We thus hypothesized that BERT-style prediction of adjacent words might not be optimal. A different masking strategy, in which prediction targets are separated from the context by more than a single timestep, may stimulate capacity in the network to acquire knowledge that permits context-based unrolls and better long-horizon predictions. ",
+        "bbox": [
+            174,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            92,
+            823,
+            119
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The simplest approach would be to set $m _ { t i } = 1$ uniformly at random across $t$ and $i$ , fixing the expected proportion of the $m _ { t i }$ set to 1 (schema $^ b$ in Figure 2). The targets would simply be the unmasked slots, $\\tau _ { t i } = 1 - m _ { t i }$ . One potential problem with this approach is that multiple objects could be masked out in a single frame. MONet can unpredictably switch object-to-slot assignments multiple times in a single video. If multiple slots are masked out, the transformer cannot determine with certainty which missing object to assign to each slot. Thus, the auxiliary loss could penalize the model even if it predicted all the objects correctly. To avoid this problem, we also try constraining the mask such that exactly one slot is masked out per frame (schema $a$ ). ",
+        "bbox": [
+            174,
+            126,
+            825,
+            237
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To pose harder prediction challenges, we can add a buffer between the context (where $m _ { t i } = 1$ ) and the infilling targets (where $\\tau _ { t i } = 1$ ). For $t$ in this buffer zone, both $m _ { t i } = 0$ and $\\tau _ { t i } = 0$ (schemas $c { - } f )$ . We choose a single cutoff $T$ randomly, and we set $m _ { t i } = 0$ for $t < T$ and $m _ { t i } = 1$ for $t \\geq T$ . In the presence of this buffer, we compared prediction (where the context is strictly before the targets; schema $c , d$ ) versus infilling (where the context surrounds the targets; schema $e , f ,$ ). We also compared setting the targets as individual objects (schema $c , e$ ) versus targets as all objects in the scene (schema $d , f )$ . We visually inspect the efficacy of this self-supervised loss in encouraging better representations (beyond improvements of scores on tasks) in Appendix D. ",
+        "bbox": [
+            174,
+            242,
+            825,
+            353
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            377,
+            312,
+            395
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We tested Aloe on three datasets, CLEVRER [41], CATER [12], and ACRE [44]. For each dataset, we pretrained a MONet model on individual frames. More training details and a table of hyperparameters are given in Appendix A.3; these hyperparameters were obtained through a hyperparameter sweep. All error bars are standard deviations computed over at least 5 random seeds. ",
+        "bbox": [
+            174,
+            412,
+            825,
+            468
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1 CLEVRER ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            489,
+            292,
+            505
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "CLEVRER features videos of CLEVR objects [21] that move and collide with each other. For each video, several questions are posed to test the model’s understanding of the scene. Unlike most other visual question answering datasets, which test for only descriptive understanding (“what happened?”), CLEVRER poses other more complex questions, including explanatory questions (“why did something happen?”), predictive questions (“what will happen next?”), and counterfactual questions (“what would happen in a unseen circumstance?”) [41]. ",
+        "bbox": [
+            174,
+            517,
+            825,
+            602
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We compare Aloe to state-of-the-art models reported in the literature: MAC $\\left( \\mathrm { V } + \\right)$ and NS-DR [41], as well as the DCL model [6] (simultaneous to our work). MAC $\\left( \\mathrm { V } + \\right)$ (based on the MAC network [20]) is an end-to-end network augmented with object information and trained using ground truth labels for object segmentation masks and features (e.g. color, shape). NS-DR and DCL are hybrid models that apply a symbolic logic engine to outputs of various neural networks. The neural networks are used to detect objects, predict dynamics, and parse the question into a program, and the symbolic executor runs the parsed program to obtain the final output. NS-DR is trained using ground truth labels and ground truth parsed programs, while DCL requires only the ground truth parsed programs. ",
+        "bbox": [
+            174,
+            607,
+            825,
+            718
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Table 1 shows the result of Aloe compared to these models. Across all categories, Aloe significantly outperforms the previous best models. Moreover, compared to the other models, Aloe does not use any labeled data other than the correct answer for the questions, nor does it require pretraining on any other dataset. Aloe also was not specifically designed for this task, and it straightforwardly generalizes to other tasks as well, such as CATER [12] and ACRE [44]. We provide a few sample model classifications on a randomly selected set of videos and questions in Appendix E.1 and detailed analysis of counterfactual questions in Appendix C. These examples suggest qualitatively that, for most instances where the model was incorrect, humans would plausibly furnish the same answer. ",
+        "bbox": [
+            174,
+            724,
+            825,
+            835
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Attention analysis (More analyses are given in Appendix D) We analyzed the cross-modal attention between question-words and the MONet objects. For each word, we determined the object that attended to that word with highest weight (for one head in the last layer). In the visualization below, the bounding boxes show the objects found by MONet, and each word is colored according to the ",
+        "bbox": [
+            176,
+            856,
+            825,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/b17fb2d33ac7519789a92be95f5ba1468a0123fe73f580cd362649f95d93168e.jpg",
+        "table_caption": [
+            "Table 1: Performance (per question accuracy) on CLEVRER of Aloe compared to results from literature and to ablations: 1) MLP instead of self-attention; 2) ResNet superpixels instead of MONet objects; 3) hierarchical frame-level and intra-frame attention instead of global cross-frame object attention; 4) no auxiliary loss. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Descriptive</td><td>Explanatory</td><td>Predictive</td><td>Counterfactual</td></tr><tr><td>MAC (V+)</td><td>86.4</td><td>22.3</td><td>42.9</td><td>25.1</td></tr><tr><td>NS-DR</td><td>88.1</td><td>79.6</td><td>68.7</td><td>42.2</td></tr><tr><td>DCL</td><td>90.7</td><td>82.8</td><td>82.0</td><td>46.5</td></tr><tr><td>Aloe</td><td>94.0 ± 0.4</td><td>96.0 ± 0.6</td><td>87.5 ± 3.0</td><td>75.6 ± 3.8</td></tr><tr><td>Aloe- self-attention+MLP</td><td>45.4</td><td>16.0</td><td>27.7</td><td>9.9</td></tr><tr><td>Aloe- object-repr. +ResNet</td><td>74.9</td><td>66.1</td><td>58.3</td><td>32.4</td></tr><tr><td>Aloe - global + hierarchical attn.</td><td>80.6</td><td>87.4</td><td>73.5</td><td>55.1</td></tr><tr><td>Aloe- self-supervised loss</td><td>91.0</td><td>92.8</td><td>82.8</td><td>68.7</td></tr></table>",
+        "bbox": [
+            178,
+            87,
+            818,
+            217
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "object that attended to it with highest weight (black represents a MONet slot without any objects).   \nWe observe that generally, objects attend heavily to the words that describe them. ",
+        "bbox": [
+            173,
+            306,
+            823,
+            335
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/229b16c4fda57fa6be8830ae071ce6a0ec54820c6c821a7f96d21f78abffa24d.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            343,
+            380,
+            449
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Q: If the cylinder is removed, which event will not happen? ",
+        "bbox": [
+            431,
+            353,
+            759,
+            381
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "1. The brown object collides with the green object.   \n2. The yellow object and the metal cube collide.   \n3. The yellow cube collides with the green object. ",
+        "bbox": [
+            431,
+            387,
+            763,
+            439
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We also looked at the objects that were most heavily attended upon in determining the final answer. The image below illustrates the attention weights for the $C L S$ token attending on each object (for one head in the last layer), when the model is tasked with assessing the first choice of the question above. The bounding boxes show the two most heavily attended upon objects for one transformer head. We observe that this head focuses on the green and brown objects (asked about in choice 1), but switches its focus to the cyan cylinder when it looks like the cylinder might collide with the cubes and change the outcome. ",
+        "bbox": [
+            173,
+            457,
+            826,
+            554
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/f9813d948a0c16a84c18a5a51d92a5b3b2434d16be376473d12c2adad84e34ba.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            560,
+            821,
+            618
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Model ablation Table 1 shows the contributions of various components of Aloe. First, self-attention is necessary for solving this problem. For comparison, we replace Aloe’s transformer with four fully connected layers with 2048 units per layer1. We find that an MLP is unable to answer non-descriptive questions effectively, despite using more parameters (20M vs 15M parameters). ",
+        "bbox": [
+            174,
+            637,
+            825,
+            693
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Second, we verify that an object-based discretization scheme is essential to the performance of Aloe. We compare with a version of the architecture where the MONet object representations $\\mu _ { t i }$ are replaced with ResNet hyperpixels as in Zambaldi et al. [43]. Concretely, we flatten the output of the final convolutional layer of the ResNet to obtain a sequence of feature vectors that is fed into the transformer as the discrete entities. To match MONet’s pretraining regimen, we pretrain the ResNet on CLEVR [21] by training an Aloe model (using a ResNet instead of MONet) on the CLEVR task and initializing the ResNet used in the CLEVRER task with these pre-trained weights. We find that an object level representation, such as one output by MONet, greatly outperforms the locality-aware but object-agnostic ResNet representation. ",
+        "bbox": [
+            173,
+            699,
+            825,
+            824
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We also observe the importance of global attention between all objects across all frames, compared to a hierarchical attention model where objects within a frame could attend to each other but frames could only attend to each other as an atomic entity. We hypothesize that global attention may be important because with hierarchical attention, objects in different frames can only attend to each other at the “frame” granularity. A cube attending to a cube in a different frame would then gather information about the other non-cube objects, muddling the resulting representation. ",
+        "bbox": [
+            176,
+            830,
+            821,
+            872
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/3444a8a096a123941b20407702c07de6ac1b82d124cdf4ea73c3ff1606e480c9.jpg",
+        "image_caption": [
+            "Figure 3: Accuracy with/without auxiliary loss for different proportions of CLEVRER (row 1) and CATER (row 2) training data. We also show comparisons with previous and concurrent work. For CLEVRER, the lighter yellow bar represents the best neurosymbolic model DCL, and the darker yellow bar represents the previous best distributed model, MAC $\\left( \\mathrm { V } + \\right)$ . For CATER, the lighter yellow bar represents Hopper and the darker yellow bar represents $\\mathrm { R 3 D + N L }$ , the best published results for the moving camera dataset. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            87,
+            825,
+            328
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            460,
+            825,
+            502
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Finally, we see that an auxiliary self-supervised loss improves the performance of the model by between 4 and 6 percentage points, with the greatest improvement on the counterfactual questions. ",
+        "bbox": [
+            174,
+            508,
+            823,
+            537
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Self-supervision strategies We compared the various masking schemes and loss functions for our auxiliary loss; a detailed figure is provided in Appendix A (Figure 4). We find that for all question types in CLEVRER, an L2 loss performs better than a contrastive loss, and among the masking schemes, masking one object per frame is the most effective. This particular result runs counter to our hypothesis that predictions or infilling in which the target is temporally removed from the context could encourage the model to learn more about scene dynamics and object interactions than (BERT-style) local predictions of adjacent targets. Of course, there may be other settings or loss functions that reveal the benefits of non-local prediction or constrastive losses; we leave this investigation to future work. ",
+        "bbox": [
+            174,
+            568,
+            825,
+            693
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Data efficiency We investigated how model performance varies as a function of the number of labelled (question-answer) pairs it learns from. To do so, we train models on $N \\%$ of the videos and their associated labeled data. We evaluate the effect of including the auxiliary self-supervised loss (applied to the entire dataset, not just the labelled portion) in this low data regime. This scenario, where unlabeled data is plentiful while labeled data is scarce, occurs frequently in practice, since collecting labeled data is much more expensive than collecting unlabeled data. ",
+        "bbox": [
+            173,
+            724,
+            825,
+            808
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Figure 3 shows that our best model reaches the approximate level of the previous state-of-the-art approaches using only $50 \\% - 6 0 \\%$ of the data. The self-supervised auxiliary loss makes a particular improvement to performance in low-data regimes. For instance, when trained on only $50 \\%$ of the available labelled data, self-supervised learning enables the model to reach a performance of $37 \\%$ on counterfactual questions (compared to $2 5 \\%$ by MAC $( \\mathrm { V } + )$ and $42 \\%$ by NS-DR on the full dataset), while without self-supervision, the model only reaches a performance of $13 \\%$ (compared to the $10 \\%$ achieved by answering randomly [41]). ",
+        "bbox": [
+            174,
+            814,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/e9161209b964b799a3fdbb5b6fd16ab97b2278252e29ae3b7dbfb3b5a8d70f15.jpg",
+        "table_caption": [
+            "Table 2: Performance on CATER of Aloe compared to the best results from literature. We report top 1 accuracy, top 5 accuracy, and L1 distance between the predicted grid cell and true grid cell. The labels (S) and (M) refer to static and moving cameras. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Top 1 (S)</td><td>Top 5 (S)</td><td>L1(S)</td><td>Top 1 (M)</td><td>Top 5 (M)</td><td>L1 (M)</td></tr><tr><td>R3DLSTM R3D+NL LSTM OPNet</td><td>60.2 46.2 74.8 73.2</td><td>81.8 69.9 1 93.8</td><td>1.2 1.5 0.54 0.85</td><td>28.6 38.6 1 1</td><td>63.3 70.2 1 1</td><td>1.7 1.5 -</td></tr><tr><td>Hopper Aloe (no auxiliary) Aloe Aloe (with L1 loss)</td><td>60.5 70.6 74.0 ± 0.3</td><td>84.5 93.0 94.0 ± 0.4</td><td>0.90 0.53 0.44 ± 0.01</td><td>46.8 56.6 59.7 ± 0.5</td><td>75.1 87.0 90.1 ± 0.6</td><td>- 1.3 0.82 0.69 ± 0.01</td></tr></table>",
+        "bbox": [
+            147,
+            87,
+            849,
+            203
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "3.2 CATER ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            284,
+            267,
+            299
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In a second experiment, we tested Aloe on CATER, a widely-used object-tracking dataset [12, 14, 31, 45]. In CATER, objects from the CLEVR dataset [21] move and potentially occlude other objects, and the goal is to predict the location of a target object (called the snitch) in the final frame. Because the snitch could be occluded by multiple objects that could move in the meantime, a successful model must be sensitive to notions of object permanence. CATER also includes a moving camera variant, which introduces additional complexities for the model. ",
+        "bbox": [
+            174,
+            313,
+            825,
+            396
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Concretely, CATER is setup as a classification challenge. Objects are located in an xyz coordinate system, where x and y range from -3 to 3. The xy plane is divided into a 6 by 6 grid, and the task is to predict the grid index of the snitch in the final frame. For Aloe, we use a classification loss (cross entropy over the 36 possible grid indices) and an L1 loss (L1 distance between predicted grid cell and the true grid cell). ",
+        "bbox": [
+            174,
+            402,
+            825,
+            472
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 2 shows Aloe compared to state-of-the-art models in the literature on both static and moving camera videos. R3D and R3D NL are the strongest two models evaluated by Girdhar and Ramanan [12]. OPNet, or the Object Permanence Network [31], is an architecture with inductive biases designed for object tracking tasks; it was trained with extra supervised labels, namely the bounding boxes for all objects (including occluded ones). Hopper is a multi-hop transformer model developed simultaneously with this work [45]. One key component of Hopper is Hungarian matching between objects of different frames, a strong inductive bias for object tracking. ",
+        "bbox": [
+            174,
+            478,
+            825,
+            575
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We train Aloe simultaneously on both static and moving camera videos. Aloe outperforms the R3D models for both static and moving cameras. We also ran Aloe with an additional auxiliary loss consisting of the L1 distance between the predicted cell and the actual cell. With this additional loss, we get comparable results in the moving camera case as the R3D models for the static camera case. Moreover, we achieve comparable accuracy as OPNet for accuracy and L1 distance, despite requiring less supervision to train. Appendix E.2 gives a few sample outputs from Aloe; in particular we note that it is able to find the target object in several cases where the object was occluded, demonstrating that Aloe is able to do some level of object tracking. Finally,we find that an auxiliary self-supervised loss helps the model perform well in the low data regime for CATER as well, as shown in Figure 3. ",
+        "bbox": [
+            174,
+            582,
+            825,
+            707
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "3.3 ACRE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            731,
+            258,
+            744
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Finally, we measured Aloe’s performance on ACRE, a causal induction dataset inspired by the Blicket task from developmental psychology [13, 44]. ACRE is divided into a set of problems. In each problem, certain objects are chosen to be “Blickets”, and this assignment changes across problems. Each problem presents a context of six images to the model, where different objects are placed on a Blicket machine that lights up if one of those objects is a Blicket. The model is asked whether an unseen combination of objects will light up the Blicket machine. Besides “yes” and “no”, a third possible answer is “undetermined”, which is the case if it is impossible to determine for certain if the objects will light up the machine. Correct inference goes beyond mere correlation: even if every context scene involving object A has a lit-up machine, A’s Blicketness is still uncertain if each of those scenes can potentially be explained by another object (deduction of A’s Blicketness is backward-blocked). ",
+        "bbox": [
+            174,
+            758,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/5ddeb805759cc50f38656ec7ccfdc74c896c226a89b61f575f9dcf2d123229ee.jpg",
+        "table_caption": [
+            "Table 3: Performance on ACRE of Aloe compared to the best results from Zhang et al. [44], split across inference type $\\mathrm { { D . R = } } 1$ Direct, I.D $\\Vdash$ Indirect, ${ \\bf { S . O } } \\mathrm { { = } } \\mathrm { { ; } }$ Screen-Off, B.B $\\ c =$ Backwards Blocking) and generalization type ( $\\mathrm { C } =$ Compositional, ${ \\bf S } =$ Systematic). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>All (C)</td><td>D.R.</td><td>I.D.</td><td>S.0.</td><td>B.B.</td><td>All (S)</td><td>D.R.</td><td>1.D.</td><td>S.0.</td><td>B.B</td></tr><tr><td>CNN-BERT</td><td>43.79</td><td>54.07</td><td>46.88</td><td>40.57</td><td>28.79</td><td>39.93</td><td>55.97</td><td>68.25</td><td>0.00</td><td>45.59</td></tr><tr><td>NS-OPT</td><td>69.04</td><td>92.5</td><td>76.05</td><td>88.33</td><td>13.48</td><td>67.44</td><td>94.73</td><td>88.38</td><td>82.76</td><td>16.06</td></tr><tr><td>Aloe</td><td>91.76</td><td>97.14</td><td>90.8</td><td>96.8</td><td>78.81</td><td>93.90</td><td>97.18</td><td>71.24</td><td>98.97</td><td>94.48</td></tr></table>",
+        "bbox": [
+            156,
+            87,
+            841,
+            147
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Inference problems in ACRE are categorized by reasoning type: reasoning from direct evidence (one of the context frames show the query objects on a machine), reasoning from indirect evidence (Blicketness must be deduced by combining evidence from several frames), screened-off reasoning (presence of non-Blickets do not matter if a single Blicket is present), and backward-blocked reasoning (Blicketness cannot be deduced due to confounding variables). Please see Zhang et al. [44] for a more detailed discussion of these reasoning types. ",
+        "bbox": [
+            174,
+            227,
+            825,
+            310
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Table 3 show Aloe performance compared to a CNN-BERT baseline and to NS-OPT, a neuro-symbolic model introduced in Zhang et al. [44]. Aloe outperforms all extant models for almost all reasoning types and train-test splits. We did not need to do any tuning to apply our model to ACRE—settings from CATER yielded the reported results on the first attempt. Contrary to widely-held opinions that neural networks cannot generalize, Aloe generalizes in scenarios where the training and test sets contain different visual features (compositional split) or different numbers of activated machines in the context (systematic split). Moreover, Aloe achieved by far the best performance on the backwardblocking task, which requires the model to “go beyond the simple covariation strategy to discover the hidden causal relations” [44], dispelling the notion that neural networks can only find correlation. Comparison with NS-OPT (which uses object representations) and CNN-BERT (which uses attention) shows that neither object representations nor attention alone is sufficient for the task; combining these two ideas, as done in Aloe for instance, is essential for this complex reasoning task as well. ",
+        "bbox": [
+            174,
+            315,
+            825,
+            482
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4 Related work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            506,
+            316,
+            522
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Self-attention for reasoning Various studies have shown that transformers [37] can manipulate symbolic data in a manner traditionally associated with symbolic computation. For example, in Lample and Charton [23], a transformer model learned to do symbolic integration and solve ordinary differential equations symbolically, tasks traditionally reserved for symbolic computer algebra systems. Similarly, in Hahn et al. [17], a transformer model learned to solve formulas in propositional logic and demonstrated some degree of generalization to out of distribution formulas. Finally, Brown et al. [1] showed that a transformer trained for language modeling can also do simple analogical reasoning tasks without explicit training. Although these models do not necessarily beat carefully tuned symbolic algorithms in all cases (especially on out of distribution data), they are an important motivation for our proposed recipe for attaining strong reasoning capabilities from self-attention-based models on visually grounded tasks. ",
+        "bbox": [
+            174,
+            540,
+            825,
+            691
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Object representations A wide body of research points to the importance of object segmentation and representation learning (see e.g. Garnelo and Shanahan [11] for a discussion). Various methods have been proposed for object detection and feature extraction [2, 10, 15, 19, 25, 26, 29]. Past research have also investigated using object based representations in downstream tasks [8, 28]. ",
+        "bbox": [
+            174,
+            712,
+            825,
+            767
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Self-supervised learning Another line of research concerns learning good representations through self-supervised learning, with an unsupervised auxiliary loss to encourage the discovery of better representations. These better representations could lead to improved performance on supervised tasks, especially when labeled data is scarce. In Devlin et al. [9], for instance, an auxiliary infill loss allows the BERT model to benefit from pretraining on a large corpus of unlabeled data. Our approach to object-centric self-supervised learning is heavily inspired by the BERT infilling loss. Other studies have shown similar benefits to auxiliary learning in vision as well [4, 16, 18]. These works apply various forms of contrastive losses to predict scene dynamics, and the better representations that result carry downstream benefits to supervised and reinforcement learning tasks. ",
+        "bbox": [
+            174,
+            786,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Vision and language in self-attention models Recently, many works have emerged on applying transformer models to visual and multimodal data, for static images [24, 27, 33, 36] and videos [34, 35, 43]. These approaches combine the output of convolutional networks with language in various ways using self-attention. While these previous works focused on popular visual question answering tasks, which typically consist of descriptive questions only [41], we focus on understanding deeper causal dynamics of videos. Together with these works, we provide more evidence that self-attention between visual and language elements enables good performance on a diverse set of tasks. ",
+        "bbox": [
+            174,
+            92,
+            825,
+            188
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In addition, while the use of object representations for discretization in tasks involving static images is becoming more popular, the right way to discretize videos is less clear. We provide strong evidence in the form of ablation studies for architectural decisions that we claim are essential for higher reasoning for this type of data: visual elements should correspond to physical objects in the videos and inter-frame attention between sub-frame entities (as opposed to inter-frame attention of entire frames) is crucial. We also demonstrate the success of using unsupervised object segmentation methods as opposed to the supervised methods used in past work. ",
+        "bbox": [
+            174,
+            194,
+            825,
+            291
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            310,
+            299,
+            328
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We have presented Aloe, a model that obtains state-of-the-art performance on three different task domains involving spatiotemporal reasoning about objects. In each of these tasks, previous state-ofthe-art results were established by models with modular, task-specific components. Aloe, by contrast, is a unified solution to all three domains. Its flexibility comes from a reliance on only soft biases and learning objectives: self-attention over learned object embeddings and self-supervised learning of dynamics. We believe the simplicity of this approach is its strength, and hope that this fact, together with the provided code, makes it easy for others to adopt and apply to arbitrary spatio-temporal reasoning problems. ",
+        "bbox": [
+            174,
+            342,
+            825,
+            453
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "On many of these spatio-temporal reasoning problems, previous state-of-the-art was achieved by neuro-symbolic models [6, 11, 40, 41, 44]. Compared to neuro-symbolic models, Aloe can more easily be adapted to other tasks. Indeed, the symbolic components of neuro-symbolic models are often task-specific and not straightforwardly applicable to other tasks. Neuro-symbolic models do have a few advantages, however. First, they are often easier to interpret. Despite the insights that can be gleaned from Aloe’s attention weights, these soft computations are harder to interpret than the explicit symbolic computation found in neuro-symbolic models. Moreover, neuro-symbolic models can be structured in a more modular fashion, which can enable effective generalization to sub-tasks of the task on which the model was trained [6]. ",
+        "bbox": [
+            174,
+            459,
+            825,
+            584
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Aloe also has some important limitations. First, it has only been applied to synthetic datasets. This limitation is mainly due to the lack of real-world datasets that test for higher-order spatiotemporal reasoning, although we are excited that new datasets such as Traffic QA will be released soon [38]. Second, while the domains where Aloe is applied have been widely adopted and well-received by the research community, it remains possible that they do not evaluate the capacities that they aim to evaluate because of hidden biases or other factors. Regardless, we hope that this work stimulates the design and development of more challenging tasks that more closely approximate the ultimate goal of human or super-human-level visual, spatiotemporal and causal reasoning. Finally, from an ethical point of view, our model may share the common drawback of deep-learning models in perpetuating biases found in the training data, especially when applied to real world data. Development of causal reasoning models could also invite problematic applications involving automated assignment of blame. ",
+        "bbox": [
+            174,
+            590,
+            825,
+            756
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References   \n[1] Tom B Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. Language models are few-shot learners. arXiv preprint arXiv:2005.14165, 2020.   \n[2] Chris P. Burgess, Loic Matthey, Nick Watters, Rishabh Kabra, Irina Higgins, Matt Botvinick, and Alex Lerchner. MONet: Unsupervised scene decomposition and representation. arXiv preprint arXiv:1901.11390, 2019.   \n[3] Nicolas Carion, Francisco Massa, Gabriel Synnaeve, Nicolas Usunier, Alexander Kirillov, and Sergey Zagoruyko. End-to-end object detection with transformers. In ECCV, 2020.   \n[4] Ting Chen, Simon Kornblith, Mohammad Norouzi, and Geoffrey Hinton. A simple framework for contrastive learning of visual representations. arXiv preprint arXiv:2002.05709, 2020.   \n[5] Zhe Chen. Object-based attention: A tutorial review. Attention, Perception, & Psychophysics, 74:784–802, 2012. URL https://doi.org/10.3758/s13414-012-0322-z.   \n[6] Zhenfang Chen, Jiayuan Mao, Jiajun Wu, Kwan-Yee Kenneth Wong, Joshua B. Tenenbaum, and Chuang Gan. Grounding physical object and event concepts through dynamic visual reasoning. In International Conference on Learning Representations, 2021. URL https: //arxiv.org/pdf/2103.16564.pdf.   \n[7] Zihang Dai, Zhilin Yang, Yiming Yang, William W Cohen, Jaime Carbonell, Quoc V Le, and Ruslan Salakhutdinov. Transformer-xl: Attentive language models beyond a fixed-length context. arXiv preprint arXiv:1901.02860, 2019.   \n[8] Mikyas T. Desta, Larry Chen, and Tomasz Kornuta. Object-based reasoning in VQA. CoRR, abs/1801.09718, 2018. URL http://arxiv.org/abs/1801.09718.   \n[9] Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. BERT: Pre-training of deep bidirectional transformers for language understanding. arXiv preprint arXiv:1810.04805, 2018.   \n[10] Yilun Du, Kevin Smith, Tomer Ulman, Joshua Tenenbaum, and Jiajun Wu. Unsupervised discovery of 3d physical objects from video. arXiv preprint arXiv:2007.12348, 2020.   \n[11] Marta Garnelo and Murray Shanahan. Reconciling deep learning with symbolic artificial intelligence: representing objects and relations. Current Opinion in Behavioral Sciences, 29: 17–23, 2019.   \n[12] Rohit Girdhar and Deva Ramanan. CATER: A diagnostic dataset for Compositional Actions and TEmporal Reasoning. In ICLR, 2020.   \n[13] Alison Gopnik and David Sobel. Detecting blickets: how young children use information about novel causal powers in categorization and induction. Child Dev, pages 1205–22, 2000. doi: 10.1111/1467-8624.00224.   \n[14] Anirudh Goyal, Aniket Didolkar, Alex Lamb, Kartikeya Badola, Nan Rosemary Ke, Nasim Rahaman, Jonathan Binas, Charles Blundell, Michael Mozer, and Yoshua Bengio. Coordination among neural modules through a shared global workspace. CoRR, abs/2103.01197, 2021. URL https://arxiv.org/abs/2103.01197.   \n[15] Klaus Greff, Raphaël Lopez Kaufman, Rishabh Kabra, Nick Watters, Christopher Burgess, Daniel Zoran, Loïc Matthey, Matthew Botvinick, and Alexander Lerchner. Multi-object representation learning with iterative variational inference. CoRR, abs/1903.00450, 2019. URL http://arxiv.org/abs/1903.00450.   \n[16] Karol Gregor, Danilo Jimenez Rezende, Frederic Besse, Yan Wu, Hamza Merzic, and Aaron van den Oord. Shaping belief states with generative environment models for rl. In H. Wallach, H. Larochelle, A. Beygelzimer, F. d’ Alché-Buc, E. Fox, and R. Garnett, editors, Advances in Neural Information Processing Systems 32, pages 13475–13487. Curran Associates, Inc., 2019. URL http://papers.nips.cc/paper/ 9503-shaping-belief-states-with-generative-environment-models-f pdf. ",
+        "bbox": [
+            173,
+            75,
+            828,
+            916
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[17] Christopher Hahn, Frederik Schmitt, Jens U. Kreber, Markus N. Rabe, and Bernd Finkbeiner. Transformers generalize to the semantics of logics. arXiv preprint arXiv:2003.04218, 2020. ",
+        "bbox": [
+            173,
+            90,
+            825,
+            121
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[18] Tengda Han, Weidi Xie, and Andrew Zisserman. Video representation learning by dense predictive coding. In Workshop on Large Scale Holistic Video Understanding, ICCV, 2019. ",
+        "bbox": [
+            174,
+            127,
+            823,
+            157
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[19] Kaiming He, Georgia Gkioxari, Piotr Dollár, and Ross B. Girshick. Mask R-CNN. CoRR, abs/1703.06870, 2017. URL http://arxiv.org/abs/1703.06870. ",
+        "bbox": [
+            176,
+            165,
+            825,
+            194
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[20] Drew A Hudson and Christopher D Manning. Compositional attention networks for machine reasoning. 2018. ",
+        "bbox": [
+            174,
+            202,
+            825,
+            231
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[21] Justin Johnson, Bharath Hariharan, Laurens van der Maaten, Li Fei-Fei, C. Lawrence Zitnick, and Ross B. Girshick. CLEVR: A diagnostic dataset for compositional language and elementary visual reasoning. CoRR, abs/1612.06890, 2016. URL http://arxiv.org/abs/1612. 06890. ",
+        "bbox": [
+            174,
+            238,
+            826,
+            295
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[22] Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            173,
+            303,
+            825,
+            332
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[23] Guillaume Lample and François Charton. Deep learning for symbolic mathematics. In International Conference on Learning Representations, 2020. URL https://openreview.net/ forum?id ${ . } = { }$ S1eZYeHFDS. ",
+        "bbox": [
+            174,
+            339,
+            825,
+            382
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[24] Liunian Harold Li, Mark Yatskar, Da Yin, Cho-Jui Hsieh, and Kai-Wei Chang. Visualbert: A simple and performant baseline for vision and language. arXiv preprint arXiv:1908.03557, 2019. ",
+        "bbox": [
+            174,
+            390,
+            825,
+            433
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[25] Zhixuan Lin, Yi-Fu Wu, Skand Vishwanath Peri, Weihao Sun, Gautam Singh, Fei Deng, Jindong Jiang, and Sungjin Ahn. SPACE: Unsupervised object-oriented scene representation via spatial attention and decomposition. In International Conference on Learning Representations, 2020. URL https://openreview.net/forum?id $\\underline { { \\underline { { \\mathbf { \\Pi } } } } }$ rkl03ySYDH. ",
+        "bbox": [
+            174,
+            440,
+            825,
+            497
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[26] Francesco Locatello, Dirk Weissenborn, Thomas Unterthiner, Aravindh Mahendran, Georg Heigold, Jakob Uszkoreit, Alexey Dosovitskiy, and Thomas Kipf1. Object-Centric Learning with Slot Attention. In Advances in Neural Information Processing Systems (NIPS), 2020. ",
+        "bbox": [
+            174,
+            505,
+            823,
+            547
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[27] Jiasen Lu, Dhruv Batra, Devi Parikh, and Stefan Lee. Vilbert: Pretraining task-agnostic visiolinguistic representations for vision-and-language tasks. arXiv preprint arXiv:1908.02265, 2019. ",
+        "bbox": [
+            173,
+            556,
+            823,
+            598
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[28] David Raposo, Adam Santoro, David G. T. Barrett, Razvan Pascanu, Timothy P. Lillicrap, and Peter W. Battaglia. Discovering objects and their relations from entangled scene representations. CoRR, abs/1702.05068, 2017. URL http://arxiv.org/abs/1702.05068. ",
+        "bbox": [
+            174,
+            606,
+            825,
+            650
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[29] Shaoqing Ren, Kaiming He, Ross B. Girshick, and Jian Sun. Faster R-CNN: towards realtime object detection with region proposal networks. CoRR, abs/1506.01497, 2015. URL http://arxiv.org/abs/1506.01497. ",
+        "bbox": [
+            173,
+            656,
+            823,
+            700
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[30] Pieter R. Roelfsema, Victor A. Lamme, and Henk Spekreijse. Object-based attention in the primary visual cortex of the macaque monkey. Nature, 395:376–381, 1998. doi: 10.1038/26475. ",
+        "bbox": [
+            173,
+            708,
+            823,
+            737
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[31] Aviv Shamsian, Ofri Kleinfeld, Amir Globerson, and Gal Chechik. Learning object permanence from video. arXiv preprint arXiv:2003.10469, 2020. ",
+        "bbox": [
+            173,
+            744,
+            823,
+            773
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[32] Elizabeth Spelke. Core knowledge. The American psychologist, 55:1233–43, 12 2000. doi: 10.1037/0003-066X.55.11.1233. ",
+        "bbox": [
+            174,
+            781,
+            823,
+            810
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[33] Weijie Su, Xizhou Zhu, Yue Cao, Bin Li, Lewei Lu, Furu Wei, and Jifeng Dai. Vl-bert: Pretraining of generic visual-linguistic representations. In International Conference on Learning Representations, 2020. URL https://openreview.net/forum?id $\\underline { { \\underline { { \\mathbf { \\Pi } } } } } =$ SygXPaEYvH. ",
+        "bbox": [
+            173,
+            818,
+            823,
+            862
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[34] Chen Sun, Fabien Baradel, Kevin Murphy, and Cordelia Schmid. Contrastive bidirectional transformer for temporal representation learning. CoRR, abs/1906.05743, 2019. URL http: //arxiv.org/abs/1906.05743. ",
+        "bbox": [
+            174,
+            869,
+            828,
+            911
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[35] Chen Sun, Austin Myers, Carl Vondrick, Kevin Murphy, and Cordelia Schmid. Videobert: A joint model for video and language representation learning. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), October 2019. ",
+        "bbox": [
+            171,
+            90,
+            823,
+            133
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[36] Hao Tan and Mohit Bansal. Lxmert: Learning cross-modality encoder representations from transformers. In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing, 2019. ",
+        "bbox": [
+            173,
+            142,
+            823,
+            185
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[37] 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. ",
+        "bbox": [
+            173,
+            193,
+            823,
+            236
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[38] Li Xu, He Huang, and Jun Liu. Sutd-trafficqa: A question answering benchmark and an efficient network for video reasoning over traffic events. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, 2021. ",
+        "bbox": [
+            171,
+            244,
+            823,
+            287
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[39] Kexin Yi, Jiajun Wu, Chuang Gan, Antonio Torralba, Pushmeet Kohli, and Joshua B Tenenbaum. Neural-Symbolic VQA: Disentangling Reasoning from Vision and Language Understanding. In Advances in Neural Information Processing Systems (NIPS), 2018. ",
+        "bbox": [
+            171,
+            296,
+            825,
+            339
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[40] Kexin Yi, Jiajun Wu, Chuang Gan, Antonio Torralba, Pushmeet Kohli, and Joshua B. Tenenbaum. Neural-symbolic vqa: Disentangling reasoning from vision and language understanding. In Advances in Neural Information Processing Systems, pages 1039–1050, 2018. ",
+        "bbox": [
+            173,
+            347,
+            823,
+            391
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[41] Kexin Yi, Chuang Gan, Yunzhu Li, Pushmeet Kohli, Jiajun Wu, Antonio Torralba, and Joshua B. Tenenbaum. CLEVRER: Collision events for video representation and reasoning. In International Conference on Learning Representations, 2020. URL https: //openreview.net/forum?id $\\underline { { \\underline { { \\mathbf { \\Pi } } } } } =$ HkxYzANYDB. ",
+        "bbox": [
+            174,
+            398,
+            825,
+            455
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[42] Yang You, Jing Li, Sashank Reddi, Jonathan Hseu, Sanjiv Kumar, Srinadh Bhojanapalli, Xiaodan Song, James Demmel, and Cho-Jui Hsieh. Large batch optimization for deep learning: Training BERT in 76 minutes. Technical Report UCB/EECS-2019-103, EECS Department, University of California, Berkeley, Jun 2019. URL http://www2.eecs.berkeley.edu/Pubs/ TechRpts/2019/EECS-2019-103.html. ",
+        "bbox": [
+            174,
+            464,
+            826,
+            535
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[43] Vinicius Zambaldi, David Raposo, Adam Santoro, Victor Bapst, Yujia Li, Igor Babuschkin, Karl Tuyls, David Reichert, Timothy Lillicrap, Edward Lockhart, Murray Shanahan, Victoria Langston, Razvan Pascanu, Matthew Botvinick, Oriol Vinyals, and Peter Battaglia. Deep reinforcement learning with relational inductive biases. In International Conference on Learning Representations, 2019. URL https://openreview.net/forum?id $\\underline { { \\underline { { \\mathbf { \\Pi } } } } } =$ HkxaFoC9KQ. ",
+        "bbox": [
+            173,
+            542,
+            825,
+            613
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[44] Chi Zhang, Baoxiong Jia, Mark Edmonds, Song-Chun Zhu, and Yixin Zhu. Acre: Abstract causal reasoning beyond covariation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2021. ",
+        "bbox": [
+            169,
+            622,
+            823,
+            665
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[45] Honglu Zhou, Asim Kadav, Farley Lai, Alexandru Niculescu-Mizil, Martin Renqiang Min, Mubbasir Kapadia, and Hans Peter Graf. Hopper: Multi-hop transformer for spatiotemporal reasoning. In International Conference on Learning Representations, 2021. URL https: //arxiv.org/abs/2103.10574. ",
+        "bbox": [
+            174,
+            674,
+            826,
+            731
+        ],
+        "page_idx": 12
+    }
+]

parse/train/r1My6sR9tX/r1My6sR9tX.md

@@ -0,0 +1,388 @@
+# UNSUPERVISED LEARNING VIA META-LEARNING
+
+Kyle Hsu†   
+University of Toronto   
+kyle.hsu@mail.utoronto.ca
+
+Sergey Levine, Chelsea Finn University of California, Berkeley {svlevine,cbfinn}@eecs.berkeley.edu
+
+# ABSTRACT
+
+A central goal of unsupervised learning is to acquire representations from unlabeled data or experience that can be used for more effective learning of downstream tasks from modest amounts of labeled data. Many prior unsupervised learning works aim to do so by developing proxy objectives based on reconstruction, disentanglement, prediction, and other metrics. Instead, we develop an unsupervised meta-learning method that explicitly optimizes for the ability to learn a variety of tasks from small amounts of data. To do so, we construct tasks from unlabeled data in an automatic way and run meta-learning over the constructed tasks. Surprisingly, we find that, when integrated with meta-learning, relatively simple task construction mechanisms, such as clustering embeddings, lead to good performance on a variety of downstream, human-specified tasks. Our experiments across four image datasets indicate that our unsupervised meta-learning approach acquires a learning algorithm without any labeled data that is applicable to a wide range of downstream classification tasks, improving upon the embedding learned by four prior unsupervised learning methods.
+
+# 1 INTRODUCTION
+
+Unsupervised learning is a fundamental, unsolved problem (Hastie et al., 2009) and has seen promising results in domains such as image recognition (Le et al., 2013) and natural language understanding (Ramachandran et al., 2017). A central use case of unsupervised learning methods is enabling better or more efficient learning of downstream tasks by training on top of unsupervised representations (Reed et al., 2014; Cheung et al., 2015; Chen et al., 2016) or fine-tuning a learned model (Erhan et al., 2010). However, since the downstream objective requires access to supervision, the objectives used for unsupervised learning are only a rough proxy for downstream performance. If a central goal of unsupervised learning is to learn useful representations, can we derive an unsupervised learning objective that explicitly takes into account how the representation will be used?
+
+The use of unsupervised representations for downstream tasks is closely related to the objective of meta-learning techniques: finding a learning procedure that is more efficient and effective than learning from scratch. However, unlike unsupervised learning methods, meta-learning methods require large, labeled datasets and hand-specified task distributions. These dependencies are major obstacles to widespread use of these methods for few-shot classification.
+
+To begin addressing these problems, we propose an unsupervised meta-learning method: one which aims to learn a learning procedure, without supervision, that is useful for solving a wide range of new, human-specified tasks. With only raw, unlabeled observations, our model’s goal is to learn a useful prior such that, after meta-training, when presented with a modestly-sized dataset for a human-specified task, the model can transfer its prior experience to efficiently learn to perform the new task. If we can build such an algorithm, we can enable few-shot learning of new tasks without needing any labeled data nor any pre-defined tasks.
+
+To perform unsupervised meta-learning, we need to automatically construct tasks from unlabeled data. We study several options for how this can be done. We find that a good task distribution should be diverse, but also not too difficult: na¨ıve random approaches for task generation produce tasks that contain insufficient regularity to enable useful meta-learning. To that end, our method proposes tasks by first leveraging prior unsupervised learning algorithms to learn an embedding of the input data, and then performing an overcomplete partitioning of the dataset to construct numerous categorizations of the data. We show how we can derive classification tasks from these categorizations for use with meta-learning algorithms. Surprisingly, even with simple mechanisms for partitioning the embedding space, such as $k$ -means clustering, we find that meta-learning acquires priors that, when used to learn new, human-designed tasks, learn those tasks more effectively than methods that directly learn on the embedding. That is, the learning algorithm acquired through unsupervised meta-learning achieves better downstream performance than the original representation used to derive meta-training tasks, without introducing any additional assumptions or supervision. See Figure 1 for an illustration of the complete approach.
+
+The core idea in this paper is that we can leverage unsupervised embeddings to propose tasks for a meta-learning algorithm, leading to an unsupervised meta-learning algorithm that is particularly effective as pre-training for human-specified downstream tasks. In the following sections, we formalize our problem assumptions and goal, which match those of unsupervised learning, and discuss several options for automatically deriving tasks from embeddings. We instantiate our method with two meta-learning algorithms and compare to prior state-of-the-art unsupervised learning methods. Across four image datasets (MNIST, Omniglot, miniImageNet, and CelebA), we find that our method consistently leads to effective downstream learning of a variety of human-specified tasks, including character recognition tasks, object classification tasks, and facial attribute discrimination tasks, without requiring any labels or hand-designed tasks during meta-learning and where key hyperparameters of our method are held constant across all domains. We show that, even though our unsupervised meta-learning algorithm trains for one-shot generalization, one instantiation of our approach performs well not only on few-shot learning, but also when learning downstream tasks with up to 50 training examples per class. In fact, some of our results begin to approach the performance of fully-supervised meta-learning techniques trained with fully-specified task distributions.
+
+![](images/2aa42c4a43d437245b1ba217e8b16d1cdbed8dd1add1db4a9609cd8a7a78f543.jpg)  
+Figure 1: Illustration of the proposed unsupervised meta-learning procedure. Embeddings of raw observations are clustered with $k$ -means to construct partitions, which give rise to classification tasks. Each task involves distinguishing between examples from $N = 2$ clusters, with $K _ { \mathrm { m - t r } } = 1$ example from each cluster being a training input. The meta-learner’s aim is to produce a learning procedure that successfully solves these tasks.
+
+# 2 UNSUPERVISED META-LEARNING
+
+In this section, we describe our problem setting in relation to that of unsupervised and semisupervised learning, provide necessary preliminaries, and present our approach.
+
+# 2.1 PROBLEM STATEMENT
+
+Our goal is to leverage unlabeled data for the efficient learning of a range of human-specified downstream tasks. We only assume access to an unlabeled dataset $\mathcal { D } = \{ \mathbf { x } _ { i } \}$ during meta-training. After learning from the unlabeled data, which we will refer to as unsupervised meta-training, we want to apply what was learned towards learning a variety of downstream, human-specified tasks from a modest amount of labeled data, potentially as few as a single example per class. These downstream tasks may, in general, have different underlying classes or attributes (in contrast to typical semi-supervised problem assumptions), but are assumed to have inputs from the same distribution as the one from which datapoints in $\mathcal { D }$ are drawn. Concretely, we assume that downstream tasks are $M$ -way classification tasks, and that the goal is to learn an accurate classifier using $K$ labeled datapoints $\left( \mathbf { x } _ { k } , \mathbf { y } _ { k } \right)$ from each of the $M$ classes, where $K$ is relatively small (i.e. between 1 and 50).
+
+The unsupervised meta-training phase aligns with the unsupervised learning problem in that it involves no access to information about the downstream tasks, other than the fact that they are $M$ -way classification tasks, for variable $M$ upper-bounded by $N$ . The upper bound $N$ is assumed to be known during unsupervised meta-training, but otherwise, the values of $M$ and $K$ are not known $a$ priori. As a result, the unsupervised meta-training phase needs to acquire a sufficiently general prior for applicability to a range of classification tasks with variable quantities of data and classes. This problem definition is our prototype for a practical use-case in which a user would like to train an application-specific image classifier, but does not have an abundance of labeled data.
+
+# 2.2 PRELIMINARIES
+
+Unsupervised embedding learning. An unsupervised embedding learning algorithm $\mathcal { E }$ is a procedure that takes as input an unlabeled dataset $\mathcal { D } = \left\{ \mathbf { x } _ { i } \right\}$ and outputs a mapping from $\{ { \bf { x } } _ { i } \}$ to embeddings $\left\{ \mathbf { z } _ { i } \right\}$ . These embedded points are typically lower-dimensional and arranged such that distances correspond to meaningful differences between inputs, in contrast to distances between the original inputs, such as image pixels, which are not meaningful measures of image similarity.
+
+Task. An $M$ -way $K$ -shot classification task $\tau$ consists of $K$ training datapoints and labels $\{ ( \mathbf { x } _ { k } , \ell _ { k } ) \}$ per class, which are used for learning a classifier, and $Q$ query datapoints and labels per class, on which the learned classifier is evaluated. That is, in a task there are $K + Q = R$ datapoints and labels for each of the $M$ classes.
+
+Meta-learning. A supervised meta-learning algorithm $\mathcal { M } ( \cdot )$ takes as input a set of supervised metatraining tasks $\{ \mathcal { T } _ { t } \}$ . It produces a learning procedure $\mathcal F ( \cdot )$ , which, in turn, ingests the supervised training data of a task to produce a classifier $f ( \cdot )$ . The goal of $\mathcal { M }$ is to learn $\mathcal { F }$ such that, when faced with a meta-test time task $\mathcal { T } _ { t ^ { \prime } }$ held-out from $\{ \mathcal { T } _ { t } \}$ , $\mathcal { F }$ can learn a $f _ { t ^ { \prime } }$ that accomplishes $\mathcal { T } _ { t ^ { \prime } }$ . At a high level, the quintessential meta-learning strategy is to have $\mathcal { M }$ iterate over $\{ \mathcal { T } _ { t } \}$ , cycling between applying the current form of $\mathcal { F } _ { t }$ on training data from $\mathcal { T } _ { t }$ to learn $f _ { t }$ , assessing its performance by calculating some meta-loss $\mathcal { L }$ on held-out data from the task, and optimizing $\mathcal { L }$ to improve the learning procedure.
+
+We build upon two meta-learning algorithms: model agnostic meta-learning (MAML) (Finn et al., 2017) and prototypical networks (ProtoNets) (Snell et al., 2017). MAML aims to learn the initial parameters of a deep network such that one or a few gradient steps leads to effective generalization; it specifies $\mathcal { F }$ as gradient descent starting from the meta-learned parameters. ProtoNets aim to metalearn a representation in which a class is effectively identified by its prototype, defined to be the mean of the class’ training examples in the meta-learned space; $\mathcal { F }$ is the computation of these class prototypes, and $f$ is a linear classifier that predicts the class whose prototype is closest in Euclidean distance to the query’s representation.
+
+Task generation for meta-learning. We briefly summarize how tasks are typically generated from labeled datasets $\left\{ \left( \mathbf { x } _ { i } , \mathbf { y } _ { i } \right) \right\}$ for supervised meta-learning, as introduced by Santoro et al. (2016). For simplicity, consider the case where the labels are discrete scalar values $y _ { i }$ . To construct an $N$ -way classification task $\tau$ (assuming $N$ is not greater than the number of unique $y _ { i }$ ), we can sample $N$ classes, sample $R$ datapoints $\{ { \bf { x } } _ { r } \} _ { n }$ for each of the $N$ classes, and sample a permutation of $N$ distinct one-hot vectors $( \ell _ { n } )$ to serve as task-specific labels of the $N$ sampled classes. The task is then defined as $\mathcal { T } = \{ ( \mathbf { x } _ { n , r } , \ell _ { n } ) ~ | ~ \mathbf { x } _ { n , r } \in \{ \mathbf { x } _ { r } \} _ { n } \}$ . Of course, this procedure is only possible with labeled data; in the next section, we discuss how we can construct tasks without ground-truth labels.
+
+# 2.3 UNSUPERVISED META-LEARNING WITH AUTOMATICALLY CONSTRUCTED TASKS
+
+We approach our problem from a meta-learning perspective, framing the problem as the acquisition, from unlabeled data, of an efficient learning procedure that is transferable to human-designed tasks. In particular, we aim to construct classification tasks from the unlabeled data and then learn how to efficiently learn these tasks. If such tasks are adequately diverse and structured, then metalearning these tasks should enable fast learning of new, human-provided tasks. A key question, then, is how to automatically construct such tasks from unlabeled data $\mathcal { D } = \left\{ \mathbf { x } _ { i } \right\}$ . Notice that in the supervised meta-learning task generation procedure detailed in Section 2.2, the labels $y _ { i }$ induce a partition $\mathcal { P } = \{ \mathcal { C } _ { c } \}$ over $\{ { \bf { x } } _ { i } \}$ by assigning all datapoints with label $y _ { c }$ to subset $\mathcal { C } _ { c }$ . Once a partition is obtained, task generation is simple; we can reduce the problem of constructing tasks to that of constructing a partition over $\{ { \bf { x } } _ { i } \}$ . All that’s left is to find a principled alternative to human labels for defining the partition.
+
+A na¨ıve approach is to randomly partition the data $\mathcal { D }$ . While such a scheme introduces diverse tasks, there is no structure; that is, there is no consistency between a task’s training data and query data, and hence nothing to be learned during each task, let alone across tasks. As seen in Table 3, providing a meta-learner with purely random tasks results in failed meta-learning.
+
+To construct tasks with structure that resembles that of human-specified labels, we need to group datapoints into consistent and distinct subsets based on salient features. With this motivation in mind, we propose to use $k$ -means clustering. Consider the partition $\mathcal { P } = \{ \mathcal { C } _ { c } \}$ learned by $k$ -means as a simplification of a Gaussian mixture model $p ( \mathbf { x } | c ) p ( \bar { c } )$ . If the clusters can recover a semblance of the true class-conditional generative distributions $p ( \mathbf { x } | c )$ , creating tasks based on treating these clusters as classes should result in useful unsupervised meta-training. However, the result of $k$ -means is critically dependent on the metric space on which its objective is defined. Clustering in pixel-space is unappealing for two reasons: (1) distance in pixel-space correlates poorly with semantic meaning, and (2) the high dimensionality of raw images renders clustering difficult in practice. We empirically show in Table 3 that meta-learning with tasks defined by pixel-space clusters, with preprocessing as directed by Coates & $\mathrm { N g }$ (2012), also fails.
+
+We are now motivated to cluster in spaces in which common distance functions correlate to semantic meaning. However, we must satisfy the constraints of our problem statement in the process of learning such spaces. To these ends, we use state-of-the-art unsupervised learning methods to produce useful embedding spaces. For qualitative evidence in the unsupervised learning literature that such embedding spaces exhibit semantic meaning, see Cheung et al. (2015); Bojanowski & Joulin (2017); Donahue et al. (2017). We note that while a given embedding space may not be directly suitable for highly-efficient learning of new tasks (which would require the embedding space to be precisely aligned or adaptable to the classes of those tasks), we can still leverage it for the construction of structured tasks, a process for which requirements are less strict.
+
+Thus, we first run an out-of-the-box unsupervised embedding learning algorithm $\mathcal { E }$ on $\mathcal { D }$ , then map the data $\{ { \bf { x } } _ { i } \}$ into the embedding space $\mathcal { Z }$ , producing $\left\{ \mathbf { z } _ { i } \right\}$ . To produce a diverse task set, we generate $P$ partitions $\{ \mathcal P _ { p } \}$ by running clustering $P$ times, applying random scaling to the dimensions of $\mathcal { Z }$ to induce a different metric, represented by diagonal matrix A, for each run of clustering. With $\pmb { \mu } _ { c }$ denoting the learned centroid of cluster $\mathcal { C } _ { c }$ , a single run of clustering can be summarized with
+
+$$
+\mathcal { P } , \{ \pmb { \mu } _ { c } \} = \underset { \{ \mathcal { C } _ { c } \} , \{ \pmb { \mu } _ { c } \} } { \arg \operatorname* { m i n } } \sum _ { c = 1 } ^ { k } \sum _ { \mathbf { z } \in \mathcal { C } _ { c } } \| \mathbf { z } - \pmb { \mu } _ { c } \| _ { \mathbf { A } } ^ { 2 }
+$$
+
+We derive tasks for meta-learning from the partitions using the procedure detailed in Section 2.2, except we begin the construction of each task by sampling a partition from the uniform distribution $\mathcal { U } ( \mathcal { P } )$ , and for ${ \bf x } _ { i } \in \mathcal { C } _ { c }$ , specify $y _ { i } = c$ . To avoid imbalanced clusters dominating the meta-training tasks, we opt not to sample from $p ( c ) \propto | \mathcal { C } _ { c } |$ , but instead sample $N$ clusters uniformly without replacement for each task. We note that Caron et al. (2018) are similarly motivated in their design decision of sampling data from a uniform distribution over clusters.
+
+With the partitions being constructed over $\left\{ \mathbf { z } _ { i } \right\}$ , we have one more design decision to make: should we perform meta-learning on embeddings or images? We consider that, to successfully solve new tasks at meta-test time, a learning procedure $\mathcal { F }$ that takes embeddings as input would depend on the embedding function’s ability to generalize to out-of-distribution observations. On the other hand, by meta-learning on images, $\mathcal { F }$ can separately adapt $f$ to each evaluation task from the rawest level of representation. Thus, we choose to meta-learn on images.
+
+We call our method clustering to automatically construct tasks for unsupervised meta-learning (CACTUs). We detail the task construction algorithm in Algorithm 1, and provide an illustration of the complete unsupervised meta-learning approach for classification in Figure 1.
+
+# 3 RELATED WORK
+
+The method we propose aims to address the unsupervised learning problem (Hastie et al., 2009; Le et al., 2013), namely acquiring a transferable learning procedure without labels. We show that our
+
+# Algorithm 1 CACTUs for classification
+
+<table><tr><td colspan="2">1: procedure CACTUs(ε,D,P,k,T,N,Km-tr, Q)</td><td colspan="4"></td></tr><tr><td>2:</td><td colspan="4">Run embedding learning algorithm ε on D and produce embeddings {zi} from observations {xi}.</td></tr><tr><td>3:</td><td colspan="4">Run k-means on {zi} P times (with random scaling) to generate a set of partitions {Pp = {Cc}p}.</td></tr><tr><td>4:</td><td colspan="4">for t from 1 to the number of desired tasks T do</td></tr><tr><td>5:</td><td colspan="4">Sample a partition P uniformly at random from the set of partitions {Pp}.</td></tr><tr><td>6:</td><td colspan="4">Sample a cluster Cn uniformly without replacement from P for each of the N classes desired for a task.</td></tr><tr><td>7:</td><td colspan="4">Sample an embedding Zr without replacement from Cn for each of the R= Km-tr+Q training and</td></tr><tr><td>8:</td><td colspan="4">query examples desired for each class, and record the corresponding datapoint Xn,r. Sample a permutation(ln) of N one-hot labels.</td></tr><tr><td>9:</td><td colspan="4">Construct Tt ={(xn,r,ln)}.</td></tr><tr><td>10:</td><td colspan="4">return {Tt}</td></tr></table>
+
+method is complementary to a number of unsupervised learning methods, including ACAI (Berthelot et al., 2018), BiGAN (Donahue et al., 2017; Dumoulin et al., 2017), DeepCluster (Caron et al., 2018), and InfoGAN (Chen et al., 2016): we leverage these prior methods to learn embeddings used for constructing meta-learning tasks, and demonstrate that our method learns a more useful representation than the embeddings. The ability to use what was learned during unsupervised pretraining to better or more efficiently learn a variety of downstream tasks is arguably one of the most practical applications of unsupervised learning methods, which has a long history in neural network training (Hinton et al., 2006; Bengio et al., 2007; Ranzato et al., 2006; Vincent et al., 2008; Erhan et al., 2010). Unsupervised pre-training has demonstrated success in a number of domains, including speech recognition (Yu et al., 2010), image classification (Zhang et al., 2017), machine translation (Ramachandran et al., 2017), and text classification (Dai & Le, 2015; Howard & Ruder, 2018; Radford et al., 2018). Our approach, unsupervised meta-learning, can be viewed as an unsupervised learning algorithm that explicitly optimizes for few-shot transferability. As a result, we can expect it to better learn human-specified downstream tasks, compared to unsupervised learning methods that optimize for other metrics, such as reconstruction (Vincent et al., 2010; Higgins et al., 2017), fidelity of constructed images (Radford et al., 2016; Salimans et al., 2016; Donahue et al., 2017; Dumoulin et al., 2017), representation interpolation (Berthelot et al., 2018), disentanglement (Bengio et al., 2013; Reed et al., 2014; Cheung et al., 2015; Chen et al., 2016; Mathieu et al., 2016; Denton & Birodkar, 2017), and clustering (Coates & Ng, 2012; Krahenb ¨ uhl et al., 2016; Bojanowski & Joulin, ¨ 2017; Caron et al., 2018). We empirically evaluate this hypothesis in the next section. In contrast to many previous evaluations of unsupervised pre-training, we focus on settings in which only a small amount of data for the downstream tasks is available, since this is where the unlabeled data can be maximally useful.
+
+Unsupervised pre-training followed by supervised learning can be viewed as a special case of the semi-supervised learning problem (Zhu, 2011; Kingma et al., 2014; Rasmus et al., 2015; Oliver et al., 2018). However, in contrast to our problem statement, semi-supervised learning methods assume that a significant proportion of the unlabeled data, if not all of it, shares underlying labels with the labeled data. Additionally, our approach and other unsupervised learning methods are wellsuited for transferring their learned representation to many possible downstream tasks or labelings, whereas semi-supervised learning methods typically optimize for performance on a single task, with respect to a single labeling of the data.
+
+Our method builds upon the ideas of meta-learning (Schmidhuber, 1987; Bengio et al., 1991; Naik & Mammone, 1992) and few-shot learning (Santoro et al., 2016; Vinyals et al., 2016; Ravi & Larochelle, 2017; Munkhdalai & Yu, 2017; Snell et al., 2017). We apply two meta-learning algorithms, model-agnostic meta-learning (Finn et al., 2017) and prototypical networks (Snell et al., 2017), to tasks constructed in an unsupervised manner. Similar to our problem setting, some prior works have aimed to learn an unsupervised learning procedure with supervised data (Garg & Kalai, 2017; Metz et al., 2018). Instead, we consider a problem setting that is entirely unsupervised, aiming to learn efficient learning algorithms using unlabeled datasets. Our problem setting is similar to that considered by Gupta et al. (2018), but we develop an approach that is suitable for supervised downstream tasks, rather than reinforcement learning problems, and demonstrate our algorithm on problems with high-dimensional visual observations.
+
+# 4 EXPERIMENTS
+
+We begin the experimental section by presenting our research questions and how our experiments are designed to address them. Links to code for the experiments can be found at https://sites. google.com/view/unsupervised-via-meta.
+
+Benefit of meta-learning. Is there any significant benefit to doing meta-learning on tasks derived from embeddings, or is the embedding function already sufficient for downstream supervised learning of new tasks? To investigate this, we run MAML and ProtoNets on tasks generated via CACTUs (CACTUs-MAML, CACTUs-ProtoNets). We compare to five alternate algorithms, with four being supervised learning methods on top of the embedding function. i) Embedding $k _ { \mathrm { n n } }$ -nearest neighbors first infers the embeddings of the downstream task images. For a query test image, it predicts the plurality vote of the labels of the $k _ { \mathrm { n n } }$ training images that are closest in the embedding space to the query’s embedding. ii) Embedding linear classifier also begins by inferring the embeddings of the downstream task images. It then fits a linear classifier using the $N K$ training embeddings and labels, and predicts labels for the query embeddings using the classifier. iii) Embedding multilayer perceptron instead uses a network with one hidden layer of 128 units and tuned dropout (Srivastava et al., 2014). iv) To isolate the effect of meta-learning on images, we also compare to embedding cluster matching, i.e. directly using the meta-training clusters for classification by labeling clusters with a task’s training data via plurality vote. If a query datapoint maps to an unlabeled cluster, the closest labeled cluster is used. v) As a baseline, we forgo any unsupervised pre-training and train a model with the MAML architecture from standard random network initialization via gradient descent separately for each evaluation task.
+
+Different embedding spaces. Does CACTUs result in successful meta-learning for many distinct task-generating embeddings? To investigate this, we run unsupervised meta-learning using four embedding learning algorithms: ACAI (Berthelot et al., 2018), BiGAN (Donahue et al., 2017), DeepCluster (Caron et al., 2018), and InfoGAN (Chen et al., 2016). These four approaches collectively cover the following range of objectives and frameworks in the unsupervised learning literature: generative modeling, two-player games, reconstruction, representation interpolation, discriminative clustering, and information maximization. We describe these methods in more detail in Appendix A.
+
+Applicability to different tasks. Can unsupervised meta-learning yield a good prior for a variety of task types? In other words, can unsupervised meta-learning yield a good representation for tasks that assess the ability to distinguish between features on different scales, or tasks with various amounts of supervision signal? To investigate this, we evaluate our procedure on tasks assessing recognition of character identity, object identity, and facial attributes. For this purpose we choose to use the existing Omniglot (Santoro et al., 2016) and miniImageNet (Ravi & Larochelle, 2017) datasets and few-shot classification tasks and, inspired by Finn et al. (2018), also construct a new few-shot classification benchmark based on the CelebA dataset and its binary attribute annotations. For miniImageNet, we consider both few-shot downstream tasks and tasks involving larger datasets (up to 50-shot). Specifics on the datasets and human-designed tasks are presented in Appendix B.
+
+Oracle. How does the performance of our unsupervised meta-learning method compare to supervised meta-learning with a human-specified, near-optimal task distribution derived from a labeled dataset? To investigate this, we use labeled versions of the meta-training datasets to run MAML and ProtoNets as supervised meta-learning algorithms (Oracle-MAML, Oracle-ProtoNets). To facilitate fair comparison with the unsupervised variants, we control for the relevant hyperparameters.
+
+Task construction ablation. How do the alternatives for constructing tasks from the embeddings compare? To investigate this, we run MAML on tasks constructed via clustering (CACTUs-MAML) and MAML on tasks constructed via random hyperplane slices of the embedding space with varying margin (Hyperplanes-MAML). The latter partitioning procedure is detailed in Appendix C. For the experiments where tasks are constructed via clustering, we also investigate the effect of sampling based on a single partition versus multiple partitions. We additionally experiment with tasks based on random assignments of images to “clusters” (Random-MAML) and tasks based on pixel-space clusters (Pixels CACTUs-MAML) with the Omniglot dataset.
+
+To investigate the limitations of our method, we also consider an easier version of our problem statement where the data distributions at meta-training and meta-test time perfectly overlap, i.e. the images share a common set of underlying labels (Appendix D). Finally, we present results on miniImageNet after unsupervised meta-learning on most of ILSVRC 2012 (Appendix G).
+
+![](images/da015e73e499847b381f6ba35cc8ae17e2cc6b8b08026a9f2a626ccbe7e0ef3c.jpg)  
+Figure 2: Examples of three DeepCluster-embedding cluster-based classes (a) and a 2-way 5-shot test task (b) for two datasets. (a) Some of the clusters correspond well to unseen labels (top left, bottom left). Others exhibit semantic meaning despite members not being grouped as such in the labeled version of the dataset (top middle: pair of objects, bottom middle: white hat). Still others are uninterpretable (top right) or are based on image artifacts (bottom right). (b) We evaluate unsupervised pre-training based on the ability to learn downstream, human-designed tasks with held-out images and underlying classes.
+
+# 4.1 EXPERIMENTAL PROTOCOL SUMMARY
+
+As discussed by Oliver et al. (2018), keeping proper experimental protocol is particularly important when evaluating unsupervised and semi-supervised learning algorithms. Our foremost concern is to avoid falsely embellishing the capabilities of our approach by overfitting to the specific datasets and task types that we consider. To this end, we adhere to two key principles. We do not perform any architecture engineering: we use architectures from prior work as-is, or lightly adapt them to our needs if necessary. We also keep hyperparameters related to the unsupervised meta-learning stage as constant as possible across all experiments, including the MAML and ProtoNets model architectures. Details on hyperparameters and architectures are presented in Appendix E. We assume knowledge of an upper bound on the number of classes $N$ present in each downstream meta-testing task for each dataset. However, regardless of the number of shots $K$ , we do not assume knowledge of $K$ during unsupervised meta-learning. We use $N$ -way 1-shot tasks during meta-training, but test on larger values of $K$ during meta-testing.
+
+We partition each dataset into meta-training, meta-validation, and meta-testing splits. For Omniglot and miniImageNet, these splits contain disjoint sets of classes. For all algorithms, we run unsupervised pre-training on the unlabeled meta-training split and report performance on downstream tasks dictated by the labeled data of the meta-testing split, generated using the procedure from prior work recounted in Section 2.2. For the supervised meta-learning oracles, meta-training tasks are constructed in the same manner but from the dataset’s meta-training split. See Figure 2 for illustrative examples of embedding-derived clusters and human-designed test tasks.
+
+To facilitate analysis on meta-overfitting, we use the labels of the meta-validation split (instead of clustering embeddings) to construct tasks for meta-validation. However, because our aim is to perform meta-learning without supervision, we do not tune hyperparameters on this labeled data. We use a fixed number of meta-training iterations, since there is no suitable criterion for early stopping.
+
+When we experiment with the embedding-plus-supervised-learning methods used as fair comparisons to unsupervised meta-learning, we err on the side of providing more supervision and data than technically allowed. Specifically, we separately tune the supervised learning hyperparameters for each dataset and each task difficulty on the labeled version of the meta-validation split. With DeepCluster embeddings, we also use the entire meta-testing split’s statistics to perform dimensionality reduction (via PCA) and whitening, which is unfair as this shares information across tasks.
+
+# 4.2 RESULTS
+
+Our primary results are summarized in Tables 1 and 2. Task construction ablations are summarized in Tables 3 and 4.
+
+Benefit of meta-learning. CACTUs-MAML consistently yields a learning procedure that results in more successful downstream task performance than all other unsupervised methods, including those that learn on top of the embedding that generated meta-training tasks for MAML. We find the same result for CACTUs-ProtoNets for 1-shot downstream tasks. However, as noted by Snell et al. (2017), ProtoNets perform best when meta-training shot and meta-testing shot are matched; this characteristic prevents ProtoNets from improving upon ACAI for 20-way 5-shot Omniglot and upon DeepCluster for 50-shot miniImageNet. We attribute the success of CACTUs-based meta-learning over the embedding-based methods to two factors: its practice in distinguishing between many distinct sets of clusters from modest amounts of signal, and the underlying classes of the meta-testing split data being out-of-distribution. In principle, the latter factor is solely responsible for the success over embedding cluster matching, since this algorithm can be viewed as a meta-learner on embeddings that trivially obtains perfect accuracy (via memorization) on the meta-training tasks. The same factor also helps explain why training from standard network initialization is, in general, competitive with directly using the task-generating embedding as a representation. On the other hand, the MNIST results (Table 7 in Appendix F) suggest that when the meta-training and meta-testing data distributions have perfect overlap and the embedding is well-suited enough that embedding cluster matching can already achieve high performance, CACTUs-MAML yields only a small benefit, as we would expect.
+
+Table 1: Results of unsupervised learning on Omniglot images, averaged over 1000 downstream character recognition tasks. CACTUs experiments use $k = 5 0 0$ clusters for each of $P = 1 0 0$ partitions. Embedding cluster matching uses the same $k$ . For complete results with confidence intervals, see Table 8 in Appendix F.   
+
+<table><tr><td>Algorithm</td><td>(way, shot)</td><td>(5,1)</td><td>(5,5)</td><td>(20,1)</td><td>(20,5)</td></tr><tr><td>Training from scratch</td><td>52.50%</td><td></td><td>74.78%</td><td>24.91%</td><td>47.62%</td></tr><tr><td>ACAI knn-nearest neighbors</td><td></td><td>57.46%</td><td>81.16%</td><td>39.73%</td><td>66.38%</td></tr><tr><td>ACAIlinear classifier</td><td></td><td>61.08%</td><td>81.82%</td><td>43.20%</td><td>66.33%</td></tr><tr><td>ACAI MLP with dropout</td><td></td><td>51.95%</td><td>77.20%</td><td>30.65%</td><td>58.62%</td></tr><tr><td>ACAI cluster matching</td><td></td><td>54.94%</td><td>71.09%</td><td>32.19%</td><td>45.93%</td></tr><tr><td>ACAI CACTUs-MAML (ours)</td><td>68.84%</td><td></td><td>87.78%</td><td>48.09%</td><td>73.36%</td></tr><tr><td>ACAI CACTUs-ProtoNets (ours)</td><td>68.12%</td><td></td><td>83.58%</td><td>47.75%</td><td>66.27%</td></tr><tr><td>BiGAN knn-nearest neighbors</td><td>49.55%</td><td></td><td>68.06%</td><td>27.37%</td><td>46.70%</td></tr><tr><td>BiGAN linearclassifier</td><td>48.28%</td><td></td><td>68.72%</td><td>27.80%</td><td>45.82%</td></tr><tr><td>BiGAN MLP with dropout</td><td>40.54%</td><td></td><td>62.56%</td><td>19.92%</td><td>40.71%</td></tr><tr><td>BiGAN cluster matching</td><td>43.96%</td><td></td><td>58.62%</td><td>21.54%</td><td>31.06%</td></tr><tr><td>BiGAN CACTUs-MAML (ours)</td><td>58.18%</td><td></td><td>78.66%</td><td>35.56%</td><td>58.62%</td></tr><tr><td>BiGAN CACTUs-ProtoNets (ours)</td><td>54.74%</td><td></td><td>71.69%</td><td>33.40%</td><td>50.62%</td></tr><tr><td>Oracle-MAML (control)</td><td>94.46%</td><td></td><td>98.83%</td><td>84.60%</td><td>96.29%</td></tr><tr><td>Oracle-ProtoNets (control)</td><td>98.35%</td><td></td><td>99.58%</td><td>95.31%</td><td>98.81%</td></tr></table>
+
+Different embedding spaces. CACTUs is effective for a variety of embedding learning methods used for task generation. The performance of unsupervised meta-learning can largely be predicted by the performance of the embedding-based non-meta-learning methods. For example, the ACAI embedding does well with Omniglot, leading to the best unsupervised results with ACAI CACTUsMAML. Likewise, on miniImageNet, the best performing prior embedding (DeepCluster) also corresponds to the best performing unsupervised meta-learner (DeepCluster CACTUs-MAML).
+
+Applicability to different tasks. CACTUs-MAML learns an effective prior for a variety of task types. This can be attributed to the application-agnostic task-generation process and the expressive power of MAML (Finn & Levine, 2018). We also observe that, despite all meta-learning models being trained for $N$ -way 1-shot classification of unsupervised tasks, the models work well for a variety of $M$ -way $K$ -shot tasks, where $M \ \leq \ N$ and $K \ \leq \ 5 0$ . As mentioned previously, the representation that CACTUs-ProtoNets learns is best suited for downstream tasks which match the single shot used for meta-training.
+
+Oracle. The penalty for not having ground truth labels to construct near-optimal tasks ranges from substantial to severe, depending on the difficulty of the downstream task. Easier downstream tasks (which have fewer classes and/or more supervision) incur less of a penalty. We conjecture that with such tasks, the difference in the usefulness of the priors matters less since the downstream task-specific evidence has more power to shape the posterior.
+
+Table 2: Results of unsupervised learning on miniImageNet and CelebA images, averaged over 1000 downstream human-designed tasks. CACTUs experiments use $k = 5 0 0$ for each of $P = 5 0$ partitions. Embedding cluster matching uses the same $k$ . For complete results with confidence intervals, see Tables 9 and 10 in Appendix F.   
+
+<table><tr><td></td><td colspan="4">miniImageNet</td><td>CelebA</td></tr><tr><td></td><td>(5,1)</td><td>(5,5)</td><td>(5,20)</td><td>(5,50)</td><td>(2,5)</td></tr><tr><td>Training from scratch</td><td>27.59%</td><td>38.48%</td><td>51.53%</td><td>59.63%</td><td>63.19%</td></tr><tr><td>BiGAN knn-nearest neighbors</td><td>25.56%</td><td>31.10%</td><td>37.31%</td><td>43.60%</td><td>56.15%</td></tr><tr><td>BiGAN linear classifier</td><td>27.08%</td><td>33.91%</td><td>44.00%</td><td>50.41%</td><td>58.44%</td></tr><tr><td>BiGAN MLP with dropout</td><td>22.91%</td><td>29.06%</td><td>40.06%</td><td>48.36%</td><td>56.26%</td></tr><tr><td>BiGAN cluster matching</td><td>24.63%</td><td>29.49%</td><td>33.89%</td><td>36.13%</td><td>56.20%</td></tr><tr><td>BiGAN CACTUs-MAML (ours)</td><td>36.24%</td><td>51.28%</td><td>61.33%</td><td>66.91%</td><td>74.98%</td></tr><tr><td>BiGAN CACTUs-ProtoNets (ours)</td><td>36.62%</td><td>50.16%</td><td>59.56%</td><td>63.27%</td><td>65.58%</td></tr><tr><td>DeepCluster knn-nearest neighbors</td><td>28.90%</td><td>42.25%</td><td>56.44%</td><td>63.90%</td><td>61.47%</td></tr><tr><td>DeepCluster linear classifier</td><td>29.44%</td><td>39.79%</td><td>56.19%</td><td>65.28%</td><td>59.57%</td></tr><tr><td>DeepCluster MLP with dropout</td><td>29.03%</td><td>39.67%</td><td>52.71%</td><td>60.95%</td><td>60.65%</td></tr><tr><td>DeepCluster cluster matching</td><td>22.20%</td><td>23.50%</td><td>24.97%</td><td>26.87%</td><td>51.51%</td></tr><tr><td>DeepCluster CACTUs-MAML (ours)</td><td>39.90%</td><td>53.97%</td><td>63.84%</td><td>69.64%</td><td>73.79%</td></tr><tr><td>DeepCluster CACTUs-ProtoNets (ours)</td><td>39.18%</td><td>53.36%</td><td>61.54%</td><td>63.55%</td><td>74.15%</td></tr><tr><td>Oracle-MAML (control)</td><td>46.81%</td><td>62.13%</td><td>71.03%</td><td>75.54%</td><td>87.10%</td></tr><tr><td>Oracle-ProtoNets (control)</td><td>46.56%</td><td>62.29%</td><td>70.05%</td><td>72.04%</td><td>85.13%</td></tr></table>
+
+Task construction ablation. As seen in Tables 3 and 4, CACTUs-MAML consistently outperforms Hyperplanes-MAML with any margin. We hypothesize that this is due to the issues with zero-margin Hyperplanes-MAML pointed out in Appendix C, and the fact that nonzero-margin HyperplanesMAML is able to use less of the meta-training split to generate tasks than CACTUs-MAML is. We find that using multiple partitions for CACTUs-MAML, while beneficial, is not strictly necessary. Using non-zero margin with Hyperplanes-MAML is crucial for miniImageNet, but not for Omniglot. We conjecture that the enforced degree of separation between classes is needed for miniImageNet because of the dataset’s high diversity. Meta-learning on random tasks or tasks derived from pixel-space clustering (Table 3) results in a prior that is much less useful than any other considered algorithm, including a random network initialization; evidently, practicing badly is worse than not practicing at all.
+
+Note on overfitting. Because of the combinatorially many unsupervised tasks we can create from multiple partitions of the dataset, we do not observe substantial overfitting to the unsupervised metatraining tasks. However, we observe that meta-training performance is sometimes worse than metatest time performance, which is likely due to a portion of the automatically generated tasks being based on nonsensical clusters (for examples, see Figure 2). Additionally, we find that, with a few exceptions, using multiple partitions has a regularizing effect on the meta-learner: a diverse task set reduces overfitting to the meta-training tasks and increases the applicability of the learned prior.
+
+Table 3: Ablation study of task construction methods on Omniglot. For a more complete set of results with confidence intervals, see Table 8 in Appendix F.   
+
+<table><tr><td>Algorithm</td><td>(5,1)</td><td>(5,5)</td><td>(20,1)</td><td>(20,5)</td></tr><tr><td>Random-MAML,P= 2400,k = 500</td><td>25.99%</td><td>25.74%</td><td>6.51%</td><td>6.74%</td></tr><tr><td>Pixels CACTUs-MAML,P=1, k = 500</td><td>30.55%</td><td>40.19%</td><td>12.05%</td><td>19.01%</td></tr><tr><td>ACAIHyperplanes-MAML,P= 2400,m= 0</td><td>62.34%</td><td>81.81%</td><td>39.30%</td><td>63.18%</td></tr><tr><td>ACAI Hyperplanes-MAML,P= 2400,m =1.2</td><td>62.44%</td><td>83.20%</td><td>41.86%</td><td>65.23%</td></tr><tr><td>ACAI CACTUs-MAML,P=1,k = 500</td><td>66.49%</td><td>85.60%</td><td>45.04%</td><td>69.14%</td></tr><tr><td>ACAICACTUs-MAML,P=100,k = 500</td><td>68.84%</td><td>87.78%</td><td>48.09%</td><td>73.36%</td></tr><tr><td>BiGANHyperplanes-MAML,P= 2400,m = 0</td><td>53.60%</td><td>74.60%</td><td>29.02%</td><td>50.77%</td></tr><tr><td>BiGANHyperplanes-MAML,P= 2400,m = 0.5</td><td>53.18%</td><td>73.55%</td><td>29.98%</td><td>50.14%</td></tr><tr><td>BiGANCACTUs-MAML,P=1,k= 500</td><td>55.92%</td><td>76.28%</td><td>32.44%</td><td>54.22%</td></tr><tr><td>BiGANCACTUs-MAML,P=100,k= 500</td><td>58.18%</td><td>78.66%</td><td>35.56%</td><td>58.62%</td></tr></table>
+
+Table 4: Ablation study of task construction methods on miniImageNet. For a more complete set of results with confidence intervals, see Table 9 in Appendix F.   
+
+<table><tr><td>Algorithm</td><td>(5,1)</td><td>(5,5)</td><td>(5,20)</td><td>(5,50)</td></tr><tr><td>BiGANHyperplanes-MAML,P= 4800,m =0</td><td>20.00%</td><td>20.00%</td><td>20.00%</td><td>20.00%</td></tr><tr><td>BiGAN Hyperplanes-MAML,P= 4800,m = 0.9</td><td>29.67%</td><td>41.92%</td><td>51.32%</td><td>54.72%</td></tr><tr><td>BiGAN CACTUs-MAML,P=1,k= 500</td><td>37.75%</td><td>52.59%</td><td>62.70%</td><td>67.98%</td></tr><tr><td>BiGANCACTUs-MAML,P= 50,k= 500</td><td>36.24%</td><td>51.28%</td><td>61.33%</td><td>66.91%</td></tr><tr><td>DeepCluster Hyperplanes-MAML,P= 4800,m = 0</td><td>20.02%</td><td>20.01%</td><td>20.00%</td><td>20.01%</td></tr><tr><td>DeepClusterHyperplanes-MAML,P= 4800,m= 0.1</td><td>35.85%</td><td>49.54%</td><td>60.68%</td><td>65.55%</td></tr><tr><td>DeepCluster CACTUs-MAML,P= 1,k = 500</td><td>38.75%</td><td>52.73%</td><td>62.72%</td><td>67.77%</td></tr><tr><td>DeepCluster CACTUs-MAML,P= 50,k = 500</td><td>39.90%</td><td>53.97%</td><td>63.84%</td><td>69.64%</td></tr></table>
+
+# 5 DISCUSSION
+
+We demonstrate that meta-learning on tasks produced using simple mechanisms based on embeddings improves upon the utility of these representations in learning downstream, human-specified tasks. We empirically show that this holds across benchmark datasets and tasks in the few-shot classification literature (Santoro et al., 2016; Ravi & Larochelle, 2017; Finn et al., 2018), task difficulties, and embedding learning methods while fixing key hyperparameters across all experiments.
+
+In a sense, CACTUs can be seen as a facilitating interface between an embedding learning method and a meta-learning algorithm. As shown in the results, the meta-learner’s performance significantly depends on the nature and quality of the task-generating embeddings. We can expect our method to yield better performance as the methods that produce these embedding functions improve, becoming better suited for generating diverse yet distinctive clusterings of the data. However, the gap between unsupervised and supervised meta-learning will likely persist because, with the latter, the meta-training task distribution is human-designed to mimic the expected evaluation task distribution as much as possible. Indeed, to some extent, supervised meta-learning algorithms offload the effort of designing and tuning algorithms onto the effort of designing and tuning task distributions. With its evaluation-agnostic task generation, CACTUs-based meta-learning trades off performance in specific use-cases for broad applicability and the ability to train on unlabeled data. In principle, CACTUs-based meta-learning may outperform supervised meta-learning when the latter is trained on a misaligned task distribution. We leave this investigation to future work.
+
+While we have demonstrated that $k$ -means is a broadly useful mechanism for constructing tasks from embeddings, it is unlikely that combinations of $k$ -means clusters in learned embedding spaces are universal approximations of arbitrary class definitions. An important direction for future work is to find examples of datasets and human-designed tasks for which CACTUs-based meta-learning results in ineffective downstream learning. This will result in better understanding of the practical scope of applicability for our method, and spur further development in automatic task construction mechanisms for unsupervised meta-learning.
+
+A potential concern of our experimental evaluation is that MNIST, Omniglot, and miniImageNet exhibit particular structure in the underlying class distribution (i.e., perfectly balanced classes), since they were designed to be supervised learning benchmarks. In more practical applications of machine learning, such structure would likely not exist. Our CelebA results indicate that CACTUs is effective even in the case of a dataset without neatly balanced classes or attributes. An interesting direction for future work is to better characterize the performance of CACTUs and other unsupervised pretraining methods with highly-unstructured, unlabeled datasets.
+
+Since MAML and ProtoNets produce nothing more than a learned representation, our method can be viewed as deriving, from a previous unsupervised representation, a new representation particularly suited for learning downstream tasks. Beyond visual classification tasks, the notion of using unsupervised pre-training is generally applicable to a wide range of domains, including regression, speech (Oord et al., 2018), language (Howard & Ruder, 2018), and reinforcement learning (Shelhamer et al., 2017). Hence, our unsupervised meta-learning approach has the potential to improve unsupervised representations for a variety of such domains, an exciting avenue for future work.
+
+# ACKNOWLEDGMENTS
+
+We thank Kelvin Xu, Richard Zhang, Brian Cheung, Ben Poole, Aaron van den Oord, Luke Metz, ¨ Siddharth Reddy, and the anonymous reviewers for feedback on an early draft of this paper.
+
+# REFERENCES
+
+Yoshua Bengio, Samy Bengio, and Jocelyn Cloutier. Learning a synaptic learning rule. In International Joint Conference on Neural Networks (IJCNN), 1991.
+
+Yoshua Bengio, Pascal Lamblin, Dan Popovici, and Hugo Larochelle. Greedy layer-wise training of deep networks. In Advances in Neural Information Processing Systems (NIPS), 2007.
+
+Yoshua Bengio, Aaron Courville, and Pascal Vincent. Representation learning: A review and new perspectives. IEEE Transactions on Pattern Analysis and Machine Intelligence (TPAMI), 2013.
+
+David Berthelot, Colin Raffel, Aurko Roy, and Ian Goodfellow. Understanding and improving interpolation in autoencoders via an adversarial regularizer. arXiv preprint arXiv:1807.07543, 2018.
+
+Piotr Bojanowski and Armand Joulin. Unsupervised learning by predicting noise. In International Conference on Machine Learning (ICML), 2017.
+
+Mathilde Caron, Piotr Bojanowski, Armand Joulin, and Matthijs Douze. Deep clustering for unsupervised learning of visual features. In European Conference on Computer Vision (ECCV), 2018.
+
+Xi Chen, Yan Duan, Rein Houthooft, John Schulman, Ilya Sutskever, and Pieter Abbeel. InfoGAN: Interpretable representation learning by information maximizing generative adversarial nets. In Neural Information Processing Systems (NIPS), 2016.
+
+Brian Cheung, Jesse A Livezey, Arjun K Bansal, and Bruno A Olshausen. Discovering hidden factors of variation in deep networks. In International Conference on Learning Representations (ICLR), 2015.
+
+Adam Coates and Andrew Y Ng. Learning feature representations with k-means. In Neural Networks: Tricks of the Trade. Springer, 2012.
+
+Andrew M Dai and Quoc V Le. Semi-supervised sequence learning. In Neural Information Processing Systems (NIPS), 2015.
+
+Emily L Denton and Vighnesh Birodkar. Unsupervised learning of disentangled representations from video. In Neural Information Processing Systems (NIPS), 2017.
+
+Jeff Donahue, Philipp Krahenb ¨ uhl, and Trevor Darrell. Adversarial feature learning. In ¨ International Conference on Learning Representations (ICLR), 2017.
+
+Vincent Dumoulin, Ishmael Belghazi, Ben Poole, Olivier Mastropietro, Alex Lamb, Martin Arjovsky, and Aaron Courville. Adversarially learned inference. In International Conference on Learning Representations (ICLR), 2017.
+
+Dumitru Erhan, Yoshua Bengio, Aaron Courville, Pierre-Antoine Manzagol, Pascal Vincent, and Samy Bengio. Why does unsupervised pre-training help deep learning? Journal of Machine Learning Research (JMLR), 2010.
+
+Chelsea Finn and Sergey Levine. Meta-learning and universality: Deep representations and gradient descent can approximate any learning algorithm. In International Conference on Learning Representations (ICLR), 2018.
+
+Chelsea Finn, Pieter Abbeel, and Sergey Levine. Model-agnostic meta-learning for fast adaptation of deep networks. In International Conference on Machine Learning (ICML), 2017.
+
+Chelsea Finn, Kelvin Xu, and Sergey Levine. Probabilistic model-agnostic meta-learning. In Neural Information Processing Systems (NIPS), 2018.
+
+Vikas K Garg and Adam Kalai. Supervising unsupervised learning. arXiv preprint arXiv:1709.05262, 2017.
+
+Abhishek Gupta, Benjamin Eysenbach, Chelsea Finn, and Sergey Levine. Unsupervised metalearning for reinforcement learning. arXiv preprint arXiv:1806.04640, 2018.
+
+Trevor Hastie, Robert Tibshirani, and Jerome Friedman. Unsupervised learning. In The Elements of Statistical Learning. Springer, 2009.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Identity mappings in deep residual networks. European Conference on Computer Vision (ECCV), 2016.
+
+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 (ICLR), 2017.
+
+Geoffrey E Hinton, Simon Osindero, and Yee-Whye Teh. A fast learning algorithm for deep belief nets. Neural Computation, 2006.
+
+Jeremy Howard and Sebastian Ruder. Universal language model fine-tuning for text classification. In Association for Computational Linguistics (ACL), 2018.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In International Conference on Machine Learning (ICML), 2015.
+
+Jaehong Kim, Sangyeul Lee, Sungwan Kim, Moonsu Cha, Jung Kwon Lee, Youngduck Choi, Yongseok Choi, Dong-Yeon Cho, and Jiwon Kim. Auto-Meta: Automated gradient based meta learner search. arXiv preprint arXiv:1806.06927, 2018.
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In Proceedings of the 3rd International Conference on Learning Representations (ICLR), 2014.
+
+Diederik P Kingma, Shakir Mohamed, Danilo Jimenez Rezende, and Max Welling. Semi-supervised learning with deep generative models. In Neural Information Processing Systems (NIPS), 2014.
+
+Philipp Krahenb ¨ uhl, Carl Doersch, Jeff Donahue, and Trevor Darrell. Data-dependent initializa- ¨ tions of convolutional neural networks. In International Conference on Learning Representations (ICLR), 2016.
+
+Quoc V Le, Marc’Aurelio Ranzato, Rajat Monga, Matthieu Devin, Gregory S. Corrado, Kai Chen, Jeffrey Dean, and Andrew Y Ng. Building high-level features using large scale unsupervised learning. In International Conference on Acoustics, Speech and Signal Processing (ICASSP), 2013.
+
+Michael F Mathieu, Junbo Jake Zhao, Junbo Zhao, Aditya Ramesh, Pablo Sprechmann, and Yann LeCun. Disentangling factors of variation in deep representation using adversarial training. In Neural Information Processing Systems (NIPS), 2016.
+
+Luke Metz, Niru Maheswaranathan, Brian Cheung, and Jascha Sohl-Dickstein. Learning to learn without labels. In International Conference on Learning Representations (ICLR), 2018.
+
+Tsendsuren Munkhdalai and Hong Yu. Meta networks. In International Conference on Machine Learning (ICML), 2017.
+
+Devang K Naik and RJ Mammone. Meta-neural networks that learn by learning. In International Joint Conference on Neural Networks (IJCNN), 1992.
+
+Avital Oliver, Augustus Odena, Colin Raffel, Ekin D Cubuk, and Ian J Goodfellow. Realistic evaluation of deep semi-supervised learning algorithms. In International Conference on Learning Representations (ICLR), 2018.
+
+Aaron van den Oord, Yazhe Li, and Oriol Vinyals. Representation learning with contrastive predictive coding. arXiv preprint arXiv:1807.03748, 2018.
+
+Alec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. In International Conference on Learning Representations (ICLR), 2016.
+
+Alec Radford, Karthik Narasimhan, Tim Salimans, and Ilya Sutskever. Improving language understanding by generative pre-training. Preprint, 2018.
+
+Prajit Ramachandran, Peter J Liu, and Quoc V Le. Unsupervised pretraining for sequence to sequence learning. In Empirical Methods in Natural Language Processing (EMNLP), 2017.
+
+Marc’Aurelio Ranzato, Christopher Poultney, Sumit Chopra, and Yann LeCun. Efficient learning of sparse representations with an energy-based model. In Neural Information Processing Systems (NIPS), 2006.
+
+Antti Rasmus, Mathias Berglund, Mikko Honkala, Harri Valpola, and Tapani Raiko. Semisupervised learning with ladder networks. In Neural Information Processing Systems (NIPS), 2015.
+
+Sachin Ravi and Hugo Larochelle. Optimization as a model for few-shot learning. In International Conference on Learning Representations (ICLR), 2017.
+
+Scott Reed, Kihyuk Sohn, Yuting Zhang, and Honglak Lee. Learning to disentangle factors of variation with manifold interaction. In International Conference on Machine Learning (ICML), 2014.
+
+Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, Alexander C. Berg, and Fei-Fei Li. ImageNet large scale visual recognition challenge. International Journal of Computer Vision (IJCV), 2015.
+
+Tim Salimans, Ian Goodfellow, Wojciech Zaremba, Vicki Cheung, Alec Radford, and Xi Chen. Improved techniques for training GANs. In Neural Information Processing Systems (NIPS), 2016.
+
+Adam Santoro, Sergey Bartunov, Matthew Botvinick, Daan Wierstra, and Timothy Lillicrap. Metalearning with memory-augmented neural networks. In International Conference on Machine Learning (ICML), 2016.
+
+Jurgen Schmidhuber. ¨ Evolutionary principles in self-referential learning. PhD thesis, Institut fur¨ Informatik, Technische Universitat M¨ unchen, 1987.¨
+
+Evan Shelhamer, Parsa Mahmoudieh, Max Argus, and Trevor Darrell. Loss is its own reward: Selfsupervision for reinforcement learning. In International Conference on Learning Representations (ICLR), 2017.
+
+Jake Snell, Kevin Swersky, and Richard S Zemel. Prototypical networks for few-shot learning. In Neural Information Processing Systems (NIPS), 2017.
+
+Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: A simple way to prevent neural networks from overfitting. Journal of Machine Learning Research (JMLR), 2014.
+
+Pascal Vincent, Hugo Larochelle, Yoshua Bengio, and Pierre-Antoine Manzagol. Extracting and composing robust features with denoising autoencoders. In International Conference on Machine Learning (ICML), 2008.
+
+Pascal Vincent, Hugo Larochelle, Isabelle Lajoie, Yoshua Bengio, and Pierre-Antoine Manzagol. Stacked denoising autoencoders: Learning useful representations in a deep network with a local denoising criterion. Journal of Machine Learning Research (JMLR), 2010.
+
+Oriol Vinyals, Charles Blundell, Timothy Lillicrap, Koray Kavukcuoglu, and Daan Wierstra. Matching networks for one shot learning. In Neural Information Processing Systems (NIPS), 2016.
+
+Dong Yu, Li Deng, and George Dahl. Roles of pre-training and fine-tuning in context-dependent DBN-HMMs for real-world speech recognition. In NIPS Workshop on Deep Learning and Unsupervised Feature Learning, 2010.
+
+Richard Zhang, Phillip Isola, and Alexei A Efros. Split-brain autoencoders: Unsupervised learning by cross-channel prediction. In Computer Vision and Pattern Recognition (CVPR), 2017.
+
+Xiaojin Zhu. Semi-supervised learning. In Encyclopedia of Machine Learning. Springer, 2011.
+
+# APPENDIX A THE EMBEDDING LEARNING ZOO
+
+We evaluate four distinct methods from prior work for learning the task-generating embeddings.
+
+In adversarially constrained autoencoder interpolation (ACAI), a convolutional autoencoder’s pixelwise $L ^ { 2 }$ loss is regularized with a term encouraging meaningful interpolations in the latent space (Berthelot et al., 2018). Specifically, a critic network takes as input a synthetic image generated from a convex combination of the latents of two dataset samples, and regresses to the mixing factor. The decoder of the autoencoder and the generator for the critic are one and the same. The regularization term is minimized when the autoencoder fools the critic into predicting that the synthetic image is a real sample.
+
+The bidirectional GAN (BiGAN) is an instance of a generative-adversarial framework in which the generator produces both synthetic image and embedding from real embedding and image, respectively (Donahue et al., 2017; Dumoulin et al., 2017). Discrimination is done in joint imageembedding space.
+
+The DeepCluster method does discriminative clustering by alternating between clustering the features of a convolutional neural network and using the clusters as labels to optimize the network weights via backpropagating a standard classification loss (Caron et al., 2018).
+
+The InfoGAN framework conceptually decomposes the generator’s input into a latent code and incompressible noise (Chen et al., 2016). The structure of the latent code is hand-specified based on knowledge of the dataset. The canonical GAN minimax objective is regularized with a mutual information term between the code and the generated image. In practice, this term is optimized using variational inference, involving the approximation of the posterior with an auxiliary distribution $Q$ (code|image) parameterized by a recognition network.
+
+Whereas ACAI explicitly optimizes pixel-wise reconstruction error, BiGAN only encourages the fidelity of generated image and latent samples with respect to their respective prior distributions. While InfoGAN also encourages the fidelity of generated images, it leverages domain-specific knowledge to impose a favorable structure on the embedding space and information-theoretic methods for optimization. DeepCluster departs from the aforementioned methods in that it is not concerned with generation or decoding, and only seeks to learn general-purpose visual features by way of end-to-end discriminative clustering.
+
+# APPENDIX B DATASET INFORMATION
+
+The Omniglot dataset consists of 1623 characters each with 20 hand-drawn examples. Ignoring the alphabets from which the characters originate, we use 1100, 100, and 423 characters for our meta-training, meta-validation, and meta-testing splits. The miniImageNet dataset consists of 100 classes each with 600 examples. The images are predominantly natural and realistic. We use the same meta-training/meta-validation/meta-testing splits of 64/16/20 classes as proposed by Ravi & Larochelle (2017). The CelebA dataset includes 202,599 facial images of celebrities and 40 binary attributes that annotate every image. We follow the prescribed 162,770/19,867/19,962 data split.
+
+For Omniglot and miniImageNet, supervised meta-learning tasks and evaluation tasks are constructed exactly as detailed in Section 2.2: for an $N$ -way $K$ -shot task with $Q$ queries per class, we sample $N$ classes from the data split and $K + Q$ datapoints per class, labeling the task’s data with a random permutation of $N$ one-hot vectors.
+
+For CelebA, we consider binary classification tasks (i.e., 2-way), each defined by 3 attributes and an ordering of 3 Booleans, one for each attribute. Every image in a task-specific class shares all task-specific attributes with each other and none with images in the other class. For example, the task illustrated in Figure 2 involves distinguishing between images whose subjects satisfy not Sideburns, Straight Hair, and not Young, and those whose subjects satisfy Sideburns, not Straight Hair, and Young. To keep with the idea of having distinct classes for meta-training and meta-testing, we split the task-defining attributes. For the supervised meta-learning oracle, we construct meta-training tasks from the first 20 attributes (when alphabetically ordered), meta-validation tasks from the next 10, and meta-testing tasks from the last 10. Discarding tasks with too few examples in either class, this results in 4287, 391, and 402 task prototypes (but many more possible tasks). We use the same meta-test time tasks to evaluate the unsupervised methods. We only consider assessment with 5-shot tasks because, given that there are multiple attributes other than the task-defining ones, any 1-shot task is likely to be ill-defined.
+
+# APPENDIX C TASK CONSTRUCTION VIA RANDOM HYPERPLANES
+
+Given a set of embedding points $\left\{ \mathbf { z } _ { i } \right\}$ in a space $\mathcal { Z }$ , a simple way of defining a partition $\mathcal { P } = \{ \mathcal { C } _ { c } \}$ on $\left\{ \mathbf { z } _ { i } \right\}$ is to use random hyperplanes to slice $\mathcal { Z }$ into subspaces and assign the embeddings that lie in the $c$ -th subspace to subset $\mathcal { C } _ { c }$ . However, a hyperplane slicing can group together two arbitrarily far embeddings, or separate two arbitrarily close ones; given our assumption that good embedding spaces have a semantically meaningful metric, this creates ill-defined classes. This problem can be partially alleviated by extending the hyperplane boundaries with a non-zero margin, as empirically shown in Section 4.2.
+
+We now describe how to generate tasks via random hyperplanes in the embedding space. We first describe a procedure to generate a partition $\mathcal { P }$ of the set of embeddings $\left\{ \mathbf { z } _ { i } \right\}$ for constructing metatraining tasks. A given hyperplane slices the embedding space into two, so for an $N$ -way task, we need $\bar { H } = \lceil \log _ { 2 } \bar { N } \rceil$ hyperplanes to define sufficiently many subsets/classes for a task. To randomly define a hyperplane in $d$ -dimensional embedding space, we sample a normal vector $\mathbf { n }$ and a point on the plane $\mathbf { z } _ { 0 }$ , each with $d$ elements. For an embedding point $\mathbf { z }$ , the signed point-plane distance is given by $\frac { \mathbf { n } } { \left| \mathbf { n } \right| _ { 2 } } \cdot \left( \mathbf { z } - \mathbf { z } _ { 0 } \right)$ . Defining $H$ hyperplanes in this manner, we discard embeddings for which the signed point-plane distance to any of the $H$ hyperplanes lies within $( - m , m )$ , where $m$ is a desired margin. The $H$ hyperplanes collectively define $\mathbf { \bar { 2 } } ^ { H }$ subspaces. We assign embedding points in the $c$ -th subspace to subset $\mathcal { C } _ { c }$ . We define the partition as $\mathcal { P } = \{ \mathcal { C } _ { c } \}$ . We prune subsets that do not have at least $R = K _ { \mathrm { m - t r } } + Q$ members, and check that the partition has at least $N$ remaining subsets; if not, we reject the partition and restart the procedure. After obtaining partitions $\{ \mathcal P _ { p } \}$ , meta-training tasks can be generated by following Algorithm 1 from Line 4.
+
+In terms of practical implementation, we pre-compute 1000 hyperplanes and pruned pairs of subsets of $\left\{ \mathbf { z } _ { i } \right\}$ . We generate partitions by sampling combinations of the hyperplanes and taking intersections of their associated subsets to define the elements of the partition. We determine the number of partitions needed for a given Hyperplanes-MAML run by the number of meta-training tasks desired for the meta-learner: we fix 100 tasks per partition.
+
+# APPENDIX D MNIST EXPERIMENTS
+
+The MNIST dataset consists of 70,000 hand-drawn examples of the 10 numerical digits. Our split respects the original MNIST 60,000/10,000 training/testing split. We assess on 10-way classification tasks. This setup results in examples from all 10 digits being present for both meta-training and meta-testing, making the probem setting essentially equivalent to that of semi-supervised learning sans a fixed permutation of the labels. The MNIST scenario is thus a special case of the problem setting considered in the rest of the paper. For MNIST, we only experiment with MAML as the meta-learning algorithm.
+
+For ACAI and InfoGAN we constructed the meta-validation split from the last 5,000 examples of the meta-training split; for BiGAN this figure was 10,000. After training the ACAI model and inferring embeddings, manually assigning labels to 10 clusters by inspection results in a classification accuracy of $9 6 . 0 0 \%$ on the testing split. As the ACAI authors observe, we found it important to whiten the ACAI embeddings before clustering. The same metric for the InfoGAN embedding (taking an argmax over the categorical dimensions instead of actually running clustering) is $9 6 . 8 3 \%$ . Note that these results are an upper-bound for embedding cluster matching. To see this, consider the 10-way 1-shot scenario. 1 example sampled from each cluster is insufficient to guarantee the optimal label for that cluster; 1 example sampled from each label is not guaranteed to each end up in the optimal category.
+
+Aside from CACTUs-MAML, embedding $k _ { \mathrm { n n } }$ -nearest neighbors, embedding linear classifier, and embedding direct clustering, we also ran CACTUs-MAML on embeddings instead of raw images, using a simple model with 2 hidden layers with 64 units each and ReLU activation, and all other MAML hyperparameters being the same as in Table 5.
+
+Departing from the fixed $k = 5 0 0$ used for all other datasets, we deliberately use $k = 1 0$ to better understand the limitations of CACTUs-MAML. The results can be seen in Table 7 in Appendix B. In brief, with the better embeddings (ACAI and InfoGAN), there is only little benefit of CACTUsMAML over embedding cluster matching. Additionally, even in the best cases, CACTUs-MAML falls short of state-of-the-art semi-supervised learning methods.
+
+# APPENDIX E HYPERPARAMETERS AND ARCHITECTURES
+
+# E.1 MAML
+
+Table 5: MAML hyperparameter summary.   
+
+<table><tr><td>Hyperparameter</td><td>MNIST</td><td>Omniglot</td><td>miniImageNet</td><td>CelebA</td></tr><tr><td>Input size</td><td>28×28</td><td>28×28</td><td>84 ×84×3</td><td>84 ×84×3</td></tr><tr><td>Outer (meta) learning rate</td><td>0.001</td><td>0.001</td><td>0.001</td><td>0.001</td></tr><tr><td>Inner learning rate</td><td>0.05</td><td>0.05</td><td>0.05</td><td>0.05</td></tr><tr><td>Task batch size</td><td>8</td><td>8</td><td>8</td><td>8</td></tr><tr><td>Inner adaptation steps (meta-training)</td><td>5</td><td></td><td>5</td><td>5</td></tr><tr><td>Meta-training iterations</td><td>30,000</td><td>5 30,000</td><td>60,000</td><td>60,000</td></tr><tr><td>Adaptation steps (evaluation)</td><td>50</td><td>50</td><td>50</td><td>50</td></tr><tr><td>Classes per task (meta-training)</td><td>10</td><td>20</td><td>5</td><td>2</td></tr><tr><td>Shots per class (meta-training)</td><td>1</td><td>1</td><td>1</td><td>1</td></tr><tr><td>Queries per class</td><td>5</td><td>5</td><td>5</td><td>5</td></tr></table>
+
+For MNIST and Omniglot we use the same 4-block convolutional architecture as used by Finn et al. (2017) for their Omniglot experiments, but with 32 filters (instead of 64) for each convolutional layer for consistency with the model used for miniImageNet and CelebA, which is the same as what Finn et al. (2017) used for their miniImageNet experiments. When evaluating the meta-learned 20-way Omniglot model with 5-way tasks, we prune the unused output dimensions. The outer optimizer is Adam (Kingma & Ba, 2014), and the inner optimizer is SGD. We build on the authors’ publicly available codebase found at https://github.com/cbfinn/maml.
+
+When using batch normalization (Ioffe & Szegedy, 2015) to process a task’s training or query inputs, we observe that using only 1 query datapoint per class can allow the model to exploit batch statistics, learning a strategy analogous to a process of elimination that causes significant, but spurious, improvement in accuracy. To mitigate this, we fix 5 queries per class for every task’s evaluation phase, meta-training or meta-testing.
+
+# E.2 PROTONETS
+
+Table 6: ProtoNets hyperparameter summary.   
+
+<table><tr><td>Hyperparameter</td><td>Omniglot</td><td>miniImageNet</td><td>CelebA</td></tr><tr><td>Input size</td><td>28×28</td><td>84×84×3</td><td>84×84×3</td></tr><tr><td>Learning rate</td><td>0.001</td><td>0.001</td><td>0.001</td></tr><tr><td>Task batch size</td><td>1</td><td>1</td><td>1</td></tr><tr><td>Training iterations</td><td>30,000</td><td>60,000</td><td>60,000</td></tr><tr><td>Classes per task (meta-training)</td><td>20</td><td>5</td><td>2</td></tr><tr><td>Shots per class (meta-training)</td><td>1</td><td>1</td><td>1</td></tr><tr><td>Queries per class (meta-training/meta-testing)</td><td>15/5</td><td>15/5</td><td>15/5</td></tr></table>
+
+For the three considered datasets we use the same architecture as used by Snell et al. (2017) for their Omniglot and miniImageNet experiments. This is a 4-block convolutional architecture with each block consisting of a convolutional layer with $6 4 \ 3 \times 3$ filters, stride 1, and padding 1, followed by BatchNorm, ReLU activation, and $2 \times 2$ MaxPooling. The ProtoNets embedding is simply the flattened output of the last block. We follow the authors and use the Adam optimizer, but do not use a learning rate scheduler. We build upon the authors’ publicly available codebase found at https://github.com/jakesnell/prototypical-networks.
+
+# E.3 CACTUS
+
+For Omniglot, miniImageNet, and CelebA we fix the number of clusters $k$ to be 500. For Omniglot we choose the number of partitions $P = 1 0 0$ , but in the interest of keeping runtime manageable, choose $P = 5 0$ for miniImageNet and CelebA.
+
+# E.4 USE OF UNSUPERVISED LEARNING METHODS
+
+ACAI (Berthelot et al., 2018): We run ACAI for MNIST and Omniglot. We pad the images by 2 and use the authors’ architecture. We use a 256-dimensional embedding for all datasets. We build upon the authors’ publicly available codebase found at https://github.com/ brain-research/acai.
+
+We unsuccessfully try running ACAI on $6 4 \times 6 4$ miniImageNet and CelebA. To facilitate this input size, we add one block consisting of two convolutional layers (512 filters each) and one downsampling/upsampling layer to the encoder and decoder. However, because of ACAI’s pixel-wise reconstruction loss, for these datasets the ACAI embedding prioritizes information about the few “features” that dominate the reconstruction pixel count, resulting in clusters that only corresponded to a limited range of factors, such as background color and pose. For curiosity’s sake, we tried running meta-learning on tasks derived from these uninteresting clusters anyways, and found that the meta-learner quickly produced a learning procedure that obtained high accuracy on the meta-training tasks. However, this learned prior was not useful for solving downstream tasks.
+
+BiGAN (Donahue et al., 2017): For MNIST, we follow the BiGAN authors and specify a uniform 50-dimensional prior on the unit hypercube for the latent. The BiGAN authors use a 200- dimensional version of the same prior for their ImageNet experiments, so we follow suit for Omniglot, miniImageNet, and CelebA. For MNIST and Omniglot, we use the permutation-invariant architecture (i.e. fully connected layers only) used by the authors for their MNIST results; for miniImageNet and CelebA, we randomly crop to $6 4 \times 6 4$ and use the AlexNet-inspired architecture used by Donahue et al. (2017) for their ImageNet results. We build upon the authors’ publicly available codebase found at https://github.com/jeffdonahue/bigan.
+
+DeepCluster (Caron et al., 2018): We run DeepCluster for miniImageNet and CelebA, which we respectively randomly crop and resize to $6 4 \times 6 4$ . We modify the first layer of the AlexNet architecture used by the authors to accommodate this input size. We follow the authors and use the input to the (linear) output layer as the embedding. These are 4096-dimensional, so we follow the authors and apply PCA to reduce the dimensionality to 256, followed by whitening. We build upon the authors’ publicly available codebase found at https://github.com/facebookresearch/ deepcluster.
+
+InfoGAN (Chen et al., 2016): We only run InfoGAN for MNIST. We follow the InfoGAN authors and specify the product of a 10-way categorical distribution and a 2-dimensional uniform distribution as the latent code. We use the authors’ architecture. Given an image, we use the recognition network to obtain its embedding. We build upon the authors’ publicly available codebase found at https: //github.com/openai/InfoGAN.
+
+# APPENDIX F EXPERIMENTAL RESULTS
+
+This section containsfull experimental results for the MNIST, Omniglot, miniImageNet, and CelebA datasets, including consolidated versions of the tables found in the main text. The metric is classification accuracy averaged over 1000 tasks based on human-specified labels of the testing split, with $9 5 \%$ confidence intervals. $d$ : dimensionality of embedding, $h$ : number of hidden units in a fully connected layer, $k$ : number of clusters in a partition, $P$ : number of partitions used during meta-learning, $m$ : margin on boundary-defining hyperplanes.
+
+<table><tr><td rowspan=1 colspan=1>(0101)</td><td rowspan=4 colspan=1>% LI&#x27;0干06&#x27;16% 01.0581555% 71&#x27;0 干 10&#x27;96% 710 67&#x27;96% II&#x27;0干08&#x27;96% L70干08&#x27;88% 11011.55% 910 76.56% 71&#x27;0干80&#x27;96% 110 干 9596% 780 6444% 18031.95% 7109 8535% 40.0 99.56% 870 LL&#x27;46C[ = y[= T (sani) sSuiPPq Tt Tr-shyt[ = y[ = T (sA) P T T-SAT r rrrrret gaasetr Srrpeirrlrer iaerrertrrnrrltgFaraeregarrgrrirrettA4=P444</td><td rowspan=2 colspan=1>% 0509 86:10% 1£&#x27;0干0L09%50055672% 67089&#x27;89% 0000658% 104530% 01004535% 44061.44% 141 65:14%70015:35%03.0335.55% 0ε0干 S0&#x27;LL% 51081:14%41044:44</td><td rowspan=1 colspan=1>% 700 47.99% 11&#x27;0干 58&#x27;96% 01&#x27;0干 66&#x27;96% 010 干 87&#x27; L6% 600 干13&#x27; L6% 01756% 010  6</td><td rowspan=1 colspan=1>% L0&#x27;0 干 1S&#x27;86</td></tr><tr><td rowspan=2 colspan=1>(s01)</td><td rowspan=2 colspan=1>% LI&#x27;0干 S0&#x27;96% 170干19&#x27;96% 110T 6696% 010干8126% 010776% 010干£1L6% 010干 80&#x27;L6</td><td rowspan=2 colspan=1>% L00干1S&#x27;86</td></tr><tr><td rowspan=1 colspan=1>% 44061.44% 141 65:14%70015:35%03.0335.55% 0ε0干 S0&#x27;LL% 51081:14%41044:44</td></tr><tr><td rowspan=1 colspan=1>(101)(tous em)1oila</td><td rowspan=1 colspan=1>%230325:65% 680 F980%57025224%944144% 14011.64%85033335% 3：271:31[[ = y O = T‘(sIni) suipP-qs u Tr-t[ = y  = (sani) supPqa uu Trn-st[[ = y OII = T (I1I) SSA- V T-NC[ = yI=T sa   -T=grrrraree geasepr rripegahrlerserrerarrnriirenggareregaerrriipetP=P-14</td><td rowspan=1 colspan=1>% 155311:55% 7408126% 31.074.16%050333:5% 610干80&#x27;96% LI0干 6996% L10 干8596C = y[= T(sa) supq c -[[ = y O = T‘(sni) sYuiPPqs uu Tr-sntC = y O = T () P 1 TI-sC=y[= T(I)A T T-sAg rrirpre aaetr rrirearrger serrerarrnriirertggaraerrarrrriiiertt=p 4</td><td rowspan=1 colspan=1>% L1&#x27;0干Iε&#x27;L6Surreend pasiersnnGOLnaier Giii-larei</td></tr></table>
+
+ers per convolutional layer, 3×data augmentation, and folded the validation set   
+  
+
+<table><tr><td rowspan=7 colspan=1>(s 0)(107)(s‘s)(1‘s)(ous em)oiiral</td><td rowspan=7 colspan=1>% 944% 810 449% 67&#x27;0干 10&#x27;61% 110013.55% 810 11&#x27;9%1102555% 6908&#x27;44% 690441% 1∠&#x27;06100%20035174% 32056577%33357530PPT =γ[= TIIII-SALAI SI11.1ay = y  = 111A1--4111rres ionnaieraBeesees</td><td rowspan=4 colspan=1>% 90.038399% 33.333339% 350 79:11  %80085.8  % 990 41.69 % 1333 3334% L00干 L7&#x27;996%83033139% 670227/4%3330730 % 30033331% 8109835% 4404 44.14  % 1 1124</td><td rowspan=1 colspan=1>% 90001.95% 2102 78.14% 401141% L£&#x27;0干90% 6£&#x27;0干 LL&#x27;0  %37:227755% 8057788</td><td rowspan=1 colspan=2>% 0105 6796% L0&#x27;0干18&#x27;86</td></tr><tr><td rowspan=1 colspan=1>% 90001.95% 2102 78.14% 401141% L£&#x27;0干90% 6£&#x27;0干 LL&#x27;0  %37:227755% 8057788% 30:0377.3050</td><td rowspan=2 colspan=2>% 0105 6796% L0&#x27;0干18&#x27;86% 700339:55% 810533.55</td></tr><tr><td rowspan=2 colspan=1>%11033135% 190 08:27% 770955.66%71224115% 210370.65% 200586.655210224555%335395559% 33033151</td></tr><tr><td></td><td rowspan=1 colspan=1>土+</td></tr><tr><td rowspan=3 colspan=1>% LS0干9118%8107818%S9007&#x27;LL% LL&#x27;0干60&#x27;IL% 09&#x27;0干18&#x27;18%8703355% 353355.55% 0S&#x27;0 干8L&#x27;L8% 3903 8138% 1113 1511% 711 819% 7.0 16:14  %7.055  % 08&#x27;0 干 64&#x27;99  % 480  71896260 =   =  () T-       CCT = y TT=1 (In) s11T1II-SSCC = γ OII = 1 ‘(S.I1I) T1I1-SALOCY =γ[=T (SIAI) TIII-SAI8 = Y inodop p PT SuippggregreemysppegarierereereirrA44=P4444</td><td rowspan=1 colspan=1></td><td></td></tr><tr><td rowspan=1 colspan=1>% I∠&#x27;0干 90&#x27;89% 99&#x27;0 干7L&#x27;89% 6/0 9579%8/07985% 69&#x27;009&#x27;L% 6905555% 19085.94% S9&#x27;0 干99&#x27;8L% L0干69</td><td rowspan=2 colspan=2>% 710£8&#x27;86% 60&#x27;0干85&#x27;66% 11.03.9555% 773523:32Surureree peseeedn  GDi Drirr eoeiiioriireri（OLDLier Girr-aarei</td></tr><tr><td rowspan=1 colspan=1>% 71 1171% 1742 1185% 6104544% 080 964% 5039.02 % 0807650% 18081&#x27;89% 71:044440 =  O = P (I) T-sdHP&#x27; =   = P(s) -s-L CC =y OII = 1 (SIAN) TSII-SA/S0C = y =  (i) sTod-snt8 = Y inidoip pm d SuippqC =yI =1 (SIA) T-SAagrrpaee easeta Srrplgrhgier neeennr neipreggarerrgrereippegPP =P 4400</td></tr></table>
+
+denotes a 95% confidence interval. d: dimensionality of embedding,
+
+<table><tr><td rowspan=1 colspan=1>(0s&#x27;s)(2 &#x27;0)(s‘s)(1‘s)(ous Xem)Woirai</td><td rowspan=1 colspan=1>% 5/.05 39.61% 533112% 9908589% 67003735Yrirlrriiir reirraperreeees</td><td rowspan=1 colspan=1>% 230309.3% 31:15:11% 1/.0 91&#x27;81%55333.99% 00&#x27;0干00&#x27;  % 89&#x27;0干 86&#x27;L% 89&#x27;0干 16&#x27;99% L9:0 17:99546%344231.21% 100404% 7/0 9000     %8900L&#x27;79%57003515% 5703.31%£9090:65%81096565% 0000000 %15457171% 850 87.15%05099511% 3513 95:75% 1 8 2 470036.74     %990干8000干（09.4士22.5519&#x27;6725&#x27;330 = w Xs =  (s) Ti-H6&#x27;0 = 1 O = P (s) T--H CC1 = yO1= P (SIA4） PIII-SA/CT1 =yFT= (sT) s1TI-sg = Y iniip pi P grippC =y[=1 (SIA) TI-SAS =yrrrpaee gaisnpa Seippegger nsereny iprgasereresteippeggPP=P4440</td><td rowspan=1 colspan=1>% 8030639%5500854% £9&#x27;0干 56:09% 1555585% 70&#x27;0干I0% 99055% 79&#x27;0LL% £90干 5969% 553515:396566% 1440444.94%5506554  %41:045.44       % 0105809% 89045:1989&#x27;0921% 42:015%0706/:66 277333755 %1/044:64% 71172% 010 1690% 3303.73.51% 17:5--55.85%%   %%119.03 30.67990干  5503066120.00555555830 =  Os = P (sI1I) Tt--AdL1HT&#x27;0 = 1s= P sa) T-H C=yE1=PIA S-ACC = y I= P （(I) sTTd-SHg = Y iniip pi P grippaggC1 =yT=1A） T-SNarrpiereisepaSerpggrhler errrairrireigrrsesereesseippeggz =pashisea4</td><td rowspan=1 colspan=1>% 77:045:14% 09044% 69000.14% 590F 50.00% 7/0511.79% 1/0 6777% LL&#x27;0干 18&#x27;94% 9/0 95.94Surererrer lseeetdnnODTLr) Giii-rriOrnerer eeeinerrceeret</td></tr></table>
+
+denotes a 95% confidence interval. d: dimensionality of embeddi
+
+Table 10: CelebA facial attribute classification results averaged over 1000 tasks. $\pm$ denotes a $9 5 \%$ confidence interval. $d$ : dimensionality of embedding, $h$ : number of hidden units in a fully connected layer, $k$ : number of clusters in a partition, $P$ : number of partitions used during meta-learning.   
+
+<table><tr><td>Algorithm</td><td>(2,5)</td></tr><tr><td>Baselines Training from scratch</td><td>63.19 ± 1.06 %</td></tr><tr><td>BiGAN,d= 200</td><td></td></tr><tr><td>Embedding knn-nearest neighbors Embedding linearclassifier</td><td>56.15 ± 0.89 % 58.44 ± 0.90 %</td></tr><tr><td>Embedding MLP with dropout,h = 128</td><td>56.26 ± 0.94 %</td></tr><tr><td>Embedding cluster matching,k = 500</td><td>56.20 ±1.00 %</td></tr><tr><td>CACTUs-MAML(ours),P= 50,k= 500 CACTUs-ProtoNets (ours),P= 50,k = 500</td><td>74.98 ± 1.02 %</td></tr><tr><td></td><td>65.58 ± 1.04 %</td></tr><tr><td>DeepCluster,d= 256 Embedding knn-nearest neighbors</td><td></td></tr><tr><td>Embedding linear classifier</td><td>61.47 ± 0.99 % 59.57 ± 0.98 %</td></tr><tr><td>Embedding MLP with dropout,h = 128</td><td>60.65 ± 0.98 %</td></tr><tr><td>Embedding cluster matching,k = 500</td><td>51.51 ± 0.89 %</td></tr><tr><td>CACTUs-MAML (ours),P= 50,k = 500</td><td>73.79 ± 1.01 %</td></tr><tr><td>CACTUs-ProtoNets (ours),P= 50,k = 500</td><td>74.15 ± 1.02 %</td></tr><tr><td></td><td></td></tr><tr><td>Supervised meta-learning</td><td></td></tr><tr><td>Oracle-MAML (control)</td><td>87.10 ± 0.85 %</td></tr><tr><td></td><td></td></tr><tr><td>Oracle-ProtoNets (control)</td><td>85.13 ± 0.92 %</td></tr></table>
+
+# APPENDIX G IMAGENET EXPERIMENTS
+
+We investigate unsupervised meta-learning in the context of a larger unsupervised meta-training dataset by using the ILSVRC 2012 dataset’s training split (Russakovsky et al., 2015), which is a superset of the miniImageNet dataset (including meta-validation and meta-testing data) consisting of 1000 classes and over 1,200,000 images. To facilitate comparison to the previous miniImageNet experiments, for meta-validation and meta-test we use the miniImageNet meta-validation and metatest splits. To avoid task leakage, we hold out all data from these 36 underlying classes from the rest of the data to construct the meta-training split.
+
+For CACTUs, we use the best-performing unsupervised learning method from the previous experiments, DeepCluster, to obtain the embeddings. Following Caron et al. (2018), we run DeepCluster using the VGG-16 architecture with a 256-dimensional feature space and 10,000 clusters on the meta-training data until the normalized mutual information between the data-cluster mappings of two consecutive epochs converges. To our knowledge, no prior works have yet been published on using MAML for ImageNet-sized meta-learning. We extend the standard convolutional neural network model class with residual connections (He et al., 2016), validate hyperparameters with supervised meta-learning, then use it for unsupervised meta-learning without further tuning. See Table 11 for MAML hyperparameters. The training from scratch, embedding $k _ { \mathrm { n n } }$ -nearest neighbors, and embedding linear classifier algorithms are the same as they were in the previous sets of experiments. For Oracle-MAML, we generated tasks using the ground-truth 964 ImageNet meta-training classes. We also run semi-supervised MAML, with the meta-training tasks consisting of CACTUs-based tasks as well as tasks constructed from the 64 miniImageNet meta-training classes. The unsupervised/supervised task proportion split was fixed according to the ratio of the number of data available to each task proposal method. As before, the meta-learning methods only meta-learned on 1-shot tasks.
+
+Table 11: MAML hyperparameter summary for ImageNet.   
+
+<table><tr><td>Hyperparameter</td><td>Value</td></tr><tr><td>Input size</td><td>224× 224</td></tr><tr><td>Outer (meta) learning rate</td><td>0.0001</td></tr><tr><td>Inner learning rate</td><td>0.001</td></tr><tr><td>Task batch size</td><td>3</td></tr><tr><td>Inner adaptation steps (meta-training)</td><td>5</td></tr><tr><td>Meta-training iterations</td><td>240,000</td></tr><tr><td>Adaptation steps (evaluation)</td><td>100</td></tr><tr><td>Classes per task (meta-training)</td><td>5</td></tr><tr><td>Shots per class (meta-training)</td><td>1</td></tr><tr><td>Queries per class</td><td>5</td></tr><tr><td>Residual blocks</td><td>5</td></tr><tr><td>Layers per residual block</td><td>2</td></tr></table>
+
+We find that the vastly increased amount of unlabeled meta-training data (in comparison to miniImageNet) results in significant increases for all methods over their counterparts in Table 9 (other than training from scratch, which does not use this data). We find that CACTUs-MAML slightly outperforms embedding linear classifier for the 1-shot test tasks, but that the linear classifier on top of the unsupervised embedding becomes better as the amount of test time supervision increases. Augmenting the unsupervised tasks with (a small number of) supervised tasks during meta-training results in slight improvement for the 1-shot test tasks. The lackluster performance of CACTUs-MAML is unsurprising insofar as meta-learning with large task spaces is still an open problem: higher shot Oracle-MAML only marginally stays ahead of the embedding linear classifier, which is not the case in the other, smaller-scale experiments. We expect that using a larger architecture in conjunction with MAML (such as Kim et al. (2018)) would result in increased performance for all methods based on MAML. Further, given the extensive degree to which unsupervised learning methods have been studied, we suspect that unsupervised task construction coupled with better meta-learning algorithms and architectures will result in improved performance on the entire unsupervised learning problem. We leave such investigation to future work.
+
+denotes a 95% confidence interval. d: dimensionality of   
+
+<table><tr><td>(os&#x27;s) （07&#x27;s) (s‘s) (1‘s) (ous xem) 1loirrra</td><td>% LL0干 89&#x27;6S% SL0干 L9&#x27;εS % 3901/30% 11:059:85 Ppt =pessstsesg Yrrlrriiir liiiiera reneseg</td><td>% 41:0 4244 % L70 干 0106 % 3705 75.77 % 040 18.61 % 130 11:11 % 990F 5878 % 17034355 % 00 1064 % 1/0494 % I9&#x27;0 干 LI&#x27;01 % 7703181 % 4101109 [[V[ = γ[=1 ‘(SJ1) TII-SALO0 ohhgrer serrerarg nrippegg garreerrnrilpestg</td><td>% 190  L728 % 690£8&#x27;78 %0/0£494 % SL&#x27;0 干 SL&#x27;19 Sururersritu prseetdeesntts Jra psrsN-</td><td>% 1/0 £7&#x27;98 % L/071:4 Srinerniar peseadn DEDLLrr Tirr-larrt</td><td>% 990 干 90℃6% 69&#x27;0干4116</td></tr></table>

parse/train/ryg7vA4tPB/ryg7vA4tPB.md

@@ -0,0 +1,363 @@
+# RIGGING THE LOTTERY: MAKING ALL TICKETS WINNERS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Sparse neural networks have been shown to be more parameter and compute efficient compared to dense networks and in some cases they are even successfully used to decrease wall clock inference times. There is a large body of work on training dense networks to yield sparse networks for inference (Molchanov et al., 2017; Zhu & Gupta, 2018; Louizos et al., 2017; Li et al., 2016; Guo et al., 2016). This limits the size of the largest trainable sparse model to that of the largest trainable dense model. In this paper we introduce a method to train sparse neural networks with a fixed parameter count and a fixed computational cost throughout training, without sacrificing accuracy relative to existing dense-to-sparse training methods. Our method updates the topology of the network during training by using parameter magnitudes and infrequent gradient calculations. We show that this approach requires fewer floating-point operations (FLOPs) to achieve a given level of accuracy compared to prior techniques. We demonstrate state-of-the-art sparse training results with ResNet-50, MobileNet v1 and MobileNet v2 on the ImageNet-2012 dataset, WideResNets on the CIFAR-10 dataset and RNNs on the WikiText-103 dataset. Finally, we provide some insights into why allowing the topology to change during the optimization can overcome local minima encountered when the topology remains static.
+
+# 1 INTRODUCTION
+
+The parameter and floating point operation (FLOP) efficiency of sparse neural networks is now well demonstrated on a variety of problems (Han et al., 2015; Srinivas et al., 2017). Some work has even shown inference time speedups are possible on Recurrent Neural Networks (RNNs) (Kalchbrenner et al., 2018) and Convolutional Neural Networks (ConvNets) (Park et al., 2016). Currently, the most accurate sparse models are obtained with techniques that require, at a minimum, the cost of training a dense model in terms of memory and FLOPs (Zhu & Gupta, 2018; Guo et al., 2016), and sometimes significantly more (Molchanov et al., 2017). This paradigm has two main limitations:
+
+1. The maximum size of sparse models is limited to the largest dense model that can be trained. Even if sparse models are more parameter efficient, we can’t use pruning to train models that are larger and more accurate than the largest possible dense models.   
+2. It is inefficient. Large amounts of computation must be performed for parameters that are zero valued or that will be zero during inference.
+
+Additionally, it remains unknown if the performance of the current best pruning algorithms are an upper bound on the quality of sparse models. Gale et al. (2019) found that three different dense-tosparse training algorithms all achieve about the same sparsity / accuracy trade-off. However, this is far from conclusive proof that no better performance is possible. In this work we show the surprising result that dynamic sparse training, which includes the method we introduce below, can find more accurate models than the current best approaches to pruning initially dense networks. Importantly, our method does not change the FLOPs required to execute the model during training, allowing one to decide on a specific inference cost prior to training.
+
+The Lottery Ticket Hypothesis (Frankle & Carbin, 2019) hypothesized that if we can find a sparse neural network with iterative pruning, then we can train that sparse network from scratch, to the same level of accuracy, by starting from the original initial conditions. In this paper we introduce a new method for training sparse models without the need of a “lucky” initialization; for this reason, we call our method “The Rigged Lottery” or $R i g L ^ { * }$ . We show that this method is:
+
+• Memory efficient: It requires memory only proportional to the size of the sparse model. It never requires storing quantities that are the size of the dense model. This is in contrast to Dettmers & Zettlemoyer (2019) which requires storing the momentum for all parameters, even those that are zero valued.   
+• Computationally efficient: The amount of computation required to train the model is proportional to the number of nonzero parameters in the model.   
+• Accurate: The performance achieved by the method matches and sometimes exceeds the performance of pruning based approaches.
+
+Our method works by infrequently using instantaneous gradient information to inform a re-wiring of the network. We show that this allows the optimization to escape local minima where it would otherwise become trapped if the sparsity pattern were to remain static. Crucially, as long as the full gradient information is needed less than every $\frac { 1 } { 1 - s p a r s i t y }$ iterations, then the overall work remains proportional to the model sparsity.
+
+# 2 RELATED WORK
+
+Research on finding sparse neural networks dates back decades; for example, at least to Thimm & Fiesler (1995) who concluded that pruning weights based on magnitude was a simple and powerful technique. Strom (1997) later introduced the idea of retraining the previously pruned network to ¨ increase accuracy. Han et al. (2016b) went further and introduced multiple rounds of magnitude pruning and retraining. This is, however, relatively inefficient, requiring ten rounds of retraining when removing $2 0 \%$ of the connections to reach a final sparsity of $9 0 \%$ . To overcome this problem, Narang et al. (2017) introduced gradual pruning, where connections are slowly removed over the course of a single round of training. Zhu & Gupta (2018) refined the technique to minimize the amount of hyper-parameter selection required.
+
+A diversity of approaches not based on magnitude based pruning have also been proposed. LeCun et al. (1990) and Hassibi & Stork (1993) are some early examples, but impractical for modern neural networks as they use information from the Hessian to prune a trained network. More recent work includes $L _ { 0 }$ Regularization (Christos Louizos, 2018), Variational Dropout (Molchanov et al., 2017), Dynamic Network Surgery (Guo et al., 2016) and Sensitivity Driven Regularization (Tartaglione et al., 2018). Gale et al. (2019) examined magnitude pruning, $L _ { 0 }$ Regularization and Variational Dropout and concluded that they all achieve about the same accuracy versus sparsity trade-off on ResNet-50 and Transformer architectures.
+
+Training techniques that allow for sparsity throughout the entire training process were, to our knowledge, first introduced in Deep Rewiring (DeepR) (Bellec et al., 2017). In DeepR, the standard Stochastic Gradient Descent (SGD) optimizer is augmented with a random walk in parameter space. Additionally, connections have a pre-defined sign assigned at random; when the optimizer would normally flip the sign, the weight is set to 0 instead and new weights are activated at random.
+
+Sparse Evolutionary Training (SET) (Mocanu et al., 2018) proposed a simpler scheme where weights are pruned according to the standard magnitude criterion used in pruning and are added back at random. The method is simple and achieves reasonable performance in practice. Dynamic Sparse Reparameterization (DSR) (Mostafa & Wang, 2019) introduced the idea of allowing the parameter budget to shift between different layers of the model, allowing for non-uniform sparsity. This allows the model to distribute parameters where they are most effective. Unfortunately, the models under consideration are mostly convolutional networks, so the result of this parameter reallocation (which is to decrease the sparsity of early layers and increase the sparsity of later layers) has the overall effect of increasing the FLOP count because the spatial size is largest at the beginning. Sparse Networks from Scratch (SNFS) (Dettmers & Zettlemoyer, 2019) introduces the idea of using the momentum of each parameter as the criterion to be used for growing weights and demonstrates it leads to an improvement in test accuracy. Like DSR, they allow the sparsity of each layer to change and focus on a constant parameter, not FLOP, budget. Importantly, the method requires computing gradients and updating the momentum for every parameter in the model, even those that are zero, at every iteration. This can result in a significant amount of overall computation. Additionally, depending on the model and training setup, the required storage for the full momentum tensor could be prohibitive. Single-Shot Network Pruning (SNIP) (Lee et al., 2019) attempts to find an initial mask with one-shot pruning and uses the saliency score of parameters to decide which parameters to keep. After pruning training proceeds with this static sparse network. Properties of the different sparse training techniques are summarized in Table 1.
+
+Table 1: Comparison of different sparse training techniques. Drop and Grow columns correspond to the strategies used during the mask update. Selectable $F L O P s$ is possible if the cost of training the model is fixed at the beginning of training.   
+
+<table><tr><td>Method</td><td>Drop</td><td>Grow</td><td>Selectable FLOPs</td><td>Space &amp;FLOPs X</td></tr><tr><td>SNIP</td><td>min(10 * VL(0)I)</td><td>none</td><td>yes</td><td>sparse</td></tr><tr><td>DeepR</td><td>stochastic</td><td>random</td><td>yes</td><td>sparse</td></tr><tr><td>SET</td><td>min(l0))</td><td>random</td><td>yes</td><td>sparse</td></tr><tr><td>DSR</td><td>min(le)</td><td>random</td><td>no</td><td>sparse</td></tr><tr><td>SNFS</td><td>min(l0))</td><td>momentum</td><td>no</td><td>dense</td></tr><tr><td>RigL (ours)</td><td>min(l0)</td><td>gradient</td><td>yes</td><td>sparse</td></tr></table>
+
+There has also been a line of work investigating the Lottery Ticket Hypothesis (Frankle & Carbin, 2019). Frankle et al. (2019) showed that the formulation must be weakened to apply to larger networks such as ResNet-50 (He et al., 2015). In large networks, instead of the original initialization, the values after thousands of optimization steps must be used for initialization. Zhou et al. (2019) showed that lottery tickets obtain non-random accuracies even before the training has started. Though the possibility of training sparse neural networks with a fixed sparsity mask using lottery tickets is intriguing, it remains unclear whether it is possible to generate such initializations – for both masks and parameters – de novo.
+
+# 3 RIGGING THE LOTTERY
+
+Our method, RigL, is illustrated in Figure 1. At regularly spaced intervals our method removes a fraction of connections based on weight magnitudes and activates new ones using instantaneous gradient information. After updating the connectivity, training continues with the updated network until the next update. The main parts of our algorithm, Sparsity Distribution, Update Schedule, Drop Criterion, Grow Criterion, and the various options we considered for each, are explained below. The improved performance of $R i g L$ is due to two reasons: the use of a new method for activating connections that is efficient and more effective than choosing at random, and the use of a natural extension to an existing method for distributing parameters statically among convolutional layers.
+
+(0) Notation. Given a dataset $D$ with individual inputs $x _ { i }$ and targets $y _ { i }$ , one can train a neural network to minimize the loss function $\textstyle \sum _ { i } L ( f _ { \theta } ( x _ { i } ) , y _ { i } )$ , where $f _ { \boldsymbol { \theta } } ( \boldsymbol { x } )$ is the neural network with parameters $\theta$ of length $N$ . The vector $\theta$ can be decomposed into parameters $\theta ^ { l }$ , of length $N ^ { l }$ , for each layer $l$ . A sparse network keeps only a fraction $D \in ( 0 , 1 )$ of all connections, resulting in a sparsity of $S = 1 - D$ . More precisely, denoting the sparsity of individual layers with $s ^ { l }$ , the total parameter count of the sparse neural network satisfies $\begin{array} { r } { \dot { \sum _ { l } } ( 1 - s ^ { l } ) N ^ { l } = ( 1 - \bar { S } ) * N } \end{array}$ .
+
+![](images/c4f8c255dd49151f0525882b1c8f56ef8e1197a1ff58bb53e4c69623eb1ec0b1.jpg)  
+Figure 1: Dynamic sparse training aims to change connectivity during training to help out optimzation.
+
+(1) Sparsity Distribution. There are many ways of distributing the non-zero weights across the layers while satisfying the equality above. We avoid re-allocating parameters between layers during the training process as it makes it difficult to target a specific final FLOP budget, which is important for many inference applications. We consider the following three strategies:
+
+1. Uniform: The sparsity $s ^ { l }$ of each individual layer is the same as the total sparsity $S$ . We keep the first layer dense $\boldsymbol s ^ { 0 } = 0 ,$ ), since it has negligible number of parameters.   
+2. Erdos-R ˝ enyi: ´ As introduced in Mocanu et al. (2018), $s ^ { l }$ scales with n +n nl−1∗nl , where nl denotes number of neurons at layer l. This enables the number of connections in a sparse layer to scale with the sum of the number of output and input channels.   
+3. Erdos-R ˝ enyi-Kernel (ERK): ´ This method modifies the original Erdos-R ˝ enyi formulation ´ by including the kernel dimensions in the scaling factors. In other words, the number of parameters of the sparse convolutional layers are scaled proportional to 1− nl−1+nl+wl+hlnl−1∗nl∗wl∗hl , where $w ^ { l }$ and $h ^ { l }$ are the width and the height of the $\mathbf { \nabla } _ { l } ,$ ’th convolutional kernel. Sparsity of the fully connected layers scale as in the original Erdos-R ˝ enyi formulation. Similar to Erd ´ os- ˝ Renyi, ERK allocates higher sparsities to the layers with more parameters while allocating ´ lower sparsities to the smaller ones.
+
+In all methods, the bias and batch-norm parameters are kept dense.
+
+(2) Update Schedule. The update schedule is defined by the following parameters: (1) the number of iterations between sparse connectivity updates $( \Delta T )$ , (2) the iteration at which to stop updating the sparse connectivity $( T _ { e n d } )$ , (3) the initial fraction of connections updated $( \alpha )$ and (4) a function $f _ { d e c a y }$ , invoked every $\Delta T$ iterations until $T _ { e n d }$ , possibly decaying the fraction of updated connections over time. For the latter we choose to use cosine annealing, as we find it slightly outperforms the other methods considered.
+
+$$
+f _ { d e c a y } ( t ) = \frac { \alpha } { 2 } \left( 1 + c o s \left( \frac { t \pi } { T _ { e n d } } \right) \right)
+$$
+
+Alternatives to cosine annealing like a constant schedule and inverse power annealing are studied in the Appendix F.
+
+(3) Drop criterion. Over the course of training, we drop the lowest magnitude weights according to the update schedule since they are expected to effect the training loss least. Specifically, we drop the connections given by
+
+$T o p K ( - | \theta ^ { l } | , f _ { d e c a y } ( t ) \dot { ( } 1 - s ^ { l } ) N ^ { l } ) ^ { \ddag } .$
+
+(4) Grow criterion. The novelty of our method lies in how we grow new connections. We grow the connections with highest magnitude gradients, $T o p K _ { w \notin \theta _ { a c t i v e } ^ { l } } \breve { ( | { g r a d ( \theta ^ { l } ) } | } , f _ { d e c a y } ( t ) ( 1 - s ^ { l } ) \breve { N } ^ { l } ) .$ , where $\theta _ { a c t i v e } ^ { l }$ is the set of active connections after the drop step. Newly activated connections are initialized to zero and therefore don’t effect the output of the network. However they are expected to receive gradients with high magnitudes in the next iteration and therefore reduce the loss fastest. This procedure can be applied to each layer in sequence and the dense gradients can be discarded immediately after selecting the top connections. If a layer is too large to materialize the full gradient with respect to the weights, then we can further reduce the memory requirements by performing an iterative calculation:
+
+1. Initialize the set $T K = \{ \}$ .   
+2. Materialize a subset of size M of the full gradient, which we denote $G _ { i : i + M }$ .   
+3. Update $T K$ to contain the Top- $\mathbf { \nabla } \cdot \mathbf { K }$ elements of $G _ { i : i + M }$ concatenated with $T K$ .   
+4. Repeat steps 1 through 3 until all of the gradients have been materialized. The final set $T K$   
+contains the connections we wish to grow.
+
+![](images/dfa7237fe18adc99e80cc225a8c395a896800044e15fa934ef6beb417685da6e.jpg)  
+Figure 2: (left) Performance of various dynamic sparse training methods on ImageNet-2012 classification task. We use $80 \%$ sparse ResNet-50 architecture with uniform sparsity distribution. Points at each curve correspond to the individual training runs with training multipliers from 1 to 5 (except pruning which is scaled between 0.5 and 2). We repeat training 3 times at every multiplier and report the mean accuracies. The number of FLOPs required to train a standard dense Resnet-50 along with its performance is indicated with a dashed red line. (right) Performance of RigL at different sparsity levels with extended training. Results are averaged over 3 runs.
+
+As long as $\Delta T > \frac { 1 } { 1 - s }$ the total work in calculating dense gradients is amortized and still proportional to $1 - S$ . This is in contrast to the method of Dettmers & Zettlemoyer (2019), which requires calculating and storing the full gradients at each optimization step.
+
+# 4 EMPIRICAL EVALUATION
+
+Our experiments include image classification using CNNs on the ImageNet-2012 (Russakovsky et al., 2015) and CIFAR-10 (Krizhevsky et al.) datasets and character based language modelling using RNNs with the WikiText-103 dataset (Merity et al., 2016). We use the TensorFlow Model Pruning library (Zhu & Gupta, 2018) for our pruning baselines. A Tensorflow (Abadi et al., 2015) implementation of our method along with three other baselines (SET, SNFS, SNIP) will be open sourced. When we increase the training steps by a factor $M$ , the anchor epochs of the learning rate schedule and the end iteration of the mask update schedule are also scaled by the same factor; we indicate this scaling with a subscript (e.g. ${ \mathrm { R i g L } } _ { M \times } ,$ ).
+
+# 4.1 IMAGENET-2012 DATASET
+
+In all experiments in this section, we use SGD with momentum as our optimizer. We set the momentum coefficient of the optimizer to 0.9, $L _ { 2 }$ regularization coefficient to 0.0001, and label smoothing (Szegedy et al., 2016) to 0.1. The learning rate schedule starts with a linear warm up reaching its maximum value of 1.6 at epoch 5 which is then dropped by a factor of 10 at epochs 30, 70 and 90. We train our networks with a batch size of 4096 for 32000 steps which roughly corresponds to 100 epochs of training. Our training pipeline uses standard data augmentation, which includes random flips and crops.
+
+# 4.1.1 RESNET-50
+
+Figure 2-left summarizes the performance of various methods on training an $80 \%$ sparse ResNet-50. We also train small dense networks with equivalent parameter count. All sparse networks use the constant sparsity distribution and a cosine update schedule $\mathrm { ~ \ : ( \alpha ~ ) = ~ 0 . 3 ~ }$ , $\Delta T = 1 0 0$ ). Overall, we observe that the performance of all methods improves with training time; thus, for each method we run extended training with up to $5 \times$ the training steps of the original.
+
+As noted by Gale et al. (2019), Evci et al. (2019), Frankle et al. (2019), and Mostafa & Wang (2019), training a network with fixed sparsity from scratch (Static) leads to inferior performance. Training a small dense network with the same number of parameters gets better results than Static, but fails to match the performance of dynamic sparse models. Similarly $S E T$ improves the performance over Small-Dense, however saturates around $7 5 \%$ accuracy indicating the limits of growing new connec
+
+<table><tr><td>Method</td><td>Top-1 Accuracy</td><td>FLOPs (Train)</td><td>FLOPs (Test)</td><td>Top-1 Accuracy</td><td>FLOPs (Train)</td><td>FLOPs (Test)</td></tr><tr><td>Dense</td><td>76.8±0.09</td><td>1x (3.2e18)</td><td>1x (8.2e9)</td><td colspan="3"></td></tr><tr><td>Static</td><td colspan="3">S=0.8</td><td colspan="3">S=0.9</td></tr><tr><td>SNIP</td><td>70.6±0.06 72.0±0.10</td><td>0.23x 0.23x</td><td>0.23x 0.23x</td><td>65.8±0.04 67.2±0.12</td><td>0.10x 0.10x</td><td>0.10x 0.10x</td></tr><tr><td>Small-Dense</td><td>72.1±0.12</td><td>0.20x</td><td>0.20x</td><td>68.9±0.10</td><td>0.12x</td><td>0.12x</td></tr><tr><td>SET</td><td>72.9±0.39</td><td>0.23x</td><td>0.23x</td><td>69.6±0.23</td><td>0.10x</td><td>0.10x</td></tr><tr><td>RigL</td><td>74.6±0.06</td><td>0.23x</td><td>0.23x</td><td>72.0±0.05</td><td>0.10x</td><td>0.10x</td></tr><tr><td>Small-Dense5x RigL5x</td><td>73.9±0.07</td><td>1.01x</td><td>0.20x</td><td>71.3±0.10</td><td>0.60x</td><td>0.12x</td></tr><tr><td>Static (ERK)</td><td>76.6±0.06</td><td>1.14x</td><td>0.23x</td><td>75.7±0.06</td><td>0.52x</td><td>0.10x</td></tr><tr><td>DSR*</td><td>72.1±0.04 73.3</td><td>0.42x 0.40x</td><td>0.42x 0.40x</td><td>67.7±0.12</td><td>0.24x</td><td>0.24x</td></tr><tr><td></td><td></td><td></td><td></td><td>71.6</td><td>0.30x</td><td>0.30x</td></tr><tr><td>RigL (ERK)</td><td>75.1±0.05</td><td>0.42x</td><td>0.42x</td><td>73.0±0.04</td><td>0.25x</td><td>0.24x</td></tr><tr><td>RigL5x (ERK)</td><td>77.1±0.06</td><td>2.09x</td><td>0.42x</td><td>76.4±0.05</td><td>1.23x</td><td>0.24x</td></tr><tr><td>SNFS*</td><td>74.2</td><td>n/a</td><td>n/a</td><td>72.3</td><td>n/a</td><td>n/a</td></tr><tr><td>SNFS (ERK)</td><td>75.2±0.11</td><td>0.61x</td><td>0.42x</td><td>72.9±0.06</td><td>0.50x</td><td>0.24x</td></tr><tr><td>Pruning* (Zhu)</td><td>73.2</td><td>1.00x</td><td>0.23x</td><td>70.3</td><td>1.00x</td><td>0.10x</td></tr><tr><td>Pruning* (Gale)</td><td>75.6</td><td>1.00x</td><td>0.23x</td><td>73.9</td><td>1.00x</td><td>0.10x</td></tr><tr><td>Pruning1.5× (Gale)</td><td>76.5</td><td>1.50x</td><td>0.23x</td><td></td><td>1.50x</td><td></td></tr><tr><td></td><td></td><td></td><td></td><td>75.2</td><td></td><td>0.10x</td></tr></table>
+
+Table 2: Performance and cost of sparse training methods on training $80 \%$ and $90 \%$ sparse ResNet50s. FLOPs needed for training and test are normalized with the FLOPs of a dense model (see Appendix G for details on how FLOPs are calculated). Methods with a subscript indicate a rescaled training time, whereas ‘\*’ indicates reported results. (ERK) corresponds to the sparse networks with Erdos-Renyi-Kernel sparsity distribution.˝ $\mathrm { R i g L } _ { \mathrm { 5 } \times }$ (ERK) achieves $7 7 . 1 \%$ Top-1 Accuracy using only $20 \%$ of the parameters of a dense model and $42 \%$ of its FLOPs.
+
+tions randomly. Methods that use gradient information to grow new connections (RigL and SNFS) obtain higher accuracies, but RigL achieves the highest accuracy and does so while consistently requiring fewer FLOPs than the other methods.
+
+Given that different applications or scenarios might require a limit on the number of FLOPs for inference, we investigate the performance of our method at various sparsity levels. As mentioned previously, one strength of our method is that its resource requirements are constant throughout training and we can choose the level of sparsity that fits our training and/or inference constraints. In Figure 2-right we show the performance of our method at different sparsities and compare them with the pruning results of Gale et al. (2019), which uses $1 . 5 \mathrm { x }$ training steps, relative to the original 32k iterations. To make a fair comparison with regards to FLOPs, we scale the learning schedule of all other methods by ${ 5 } \mathbf { x }$ . Note that even after extending the training, it takes less FLOPs to train sparse networks using rigL (except for the $80 \%$ sparse RigL-ERK) compared to the pruning method.
+
+RigL, our method with constant sparsity distribution, exceeds the performance of magnitude based iterative pruning in all sparsity levels while requiring less FLOPs to train. Sparse networks that use Erdos-Renyi-Kernel (ERK) ˝ sparsity distribution obtains even greater performance. For example ResNet-50 with $9 6 . 5 \%$ sparsity achieves a remarkable $7 2 . 7 5 \%$ Top-1 Accuracy, around $3 . 5 \%$ higher than the extended magnitude pruning results reported by Gale et al. (2019). As observed earlier, smaller dense models (with the same number of parameters) or sparse models with a static connectivity can not perform at a comparable level.
+
+A more fine grained comparison of sparse training methods is presented in Table 2. Methods using uniform sparsity distribution and whose FLOP/memory footprint scales directly with (1-S) are placed in the first sub-group of the table. The second sub-group includes DSR and networks with ERK sparsity distribution which require a higher number of FLOPs for inference with same parameter count. The final sub-group includes methods that require the space and the work proportional to training a dense model.
+
+![](images/8ad076c5d43264442c51ef52152072882fb12f6803ab3f5d550b0ad517566e72.jpg)  
+Figure 3: (left) RigL significantly improves the performance of Sparse MobileNets on ImageNet2012 dataset and exceeds the pruning results reported by Zhu & Gupta (2018). Performance of the dense MobileNets are indicated with red lines. (right) Performance of sparse MobileNet-v1 architectures presented with their inference FLOPs. Networks with ERK distribution get better performance with the same number of parameters but take more FLOPs to run. Training wider sparse models with RigL (Big-Sparse) yields a significant performance improvement over the dense model.
+
+<table><tr><td rowspan=1 colspan=1>S</td><td rowspan=1 colspan=1>Method</td><td rowspan=1 colspan=1>Top-1</td><td rowspan=1 colspan=1>FLOPs</td></tr><tr><td rowspan=1 colspan=1>0.75</td><td rowspan=1 colspan=1>Small-Dense5×Pruning (Zhu)RigL5×RigL5x(ERK)</td><td rowspan=1 colspan=1>66.0±0.1167.771.5±0.0671.9±0.01</td><td rowspan=1 colspan=1>0.23x0.27x0.27x0.52x</td></tr><tr><td rowspan=1 colspan=1>0.90</td><td rowspan=1 colspan=1>Small-Dense5xPruning (Zhu)RigL5×RigL5x(ERK)</td><td rowspan=1 colspan=1>57.7±0.3461.867.0±0.1768.1±0.11</td><td rowspan=1 colspan=1>0.09x0.12x0.12x0.27x</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Dense</td><td rowspan=1 colspan=1>72.1±0.17</td><td rowspan=1 colspan=1>1x (1.1e9)</td></tr><tr><td rowspan=1 colspan=1>0.75</td><td rowspan=1 colspan=1>Big-Sparse5×Big-Sparse5x(ERK)</td><td rowspan=1 colspan=1>76.4±0.0577.0±0.08</td><td rowspan=1 colspan=1>0.98x1.91x</td></tr></table>
+
+# 4.1.2 MOBILENET
+
+MobileNet is a compact architecture that performs remarkably well in resource constrained settings. Due to its compact nature with separable convolutions it is known to be difficult to sparsify (Zhu & Gupta, 2018). In this section we apply our method to MobileNet-v1 (Howard et al., 2017) and MobileNet-v2 (Sandler et al., 2018). Due to its low parameter count we keep the first layer dense, and use ERK and Uniform sparsity distributions to sparsify the remaining layers.
+
+The performance of sparse MobileNets trained with RigL as well as the baselines are shown in Figure 3. We do extended training (5x of the original number of steps) for all runs in this section. Although MobileNets are more sensitive to sparsity compared to the ResNet-50 architecture, RigL successfully trains sparse MobileNets at high sparsities and exceeds the performance of previously reported pruning results.
+
+To demonstrate the advantages of sparse models, next, we train wider MobileNets while keeping the FLOPs and total number of parameters the same as the dense baseline using sparsity. A sparse MobileNet-v1 with width multiplier 1.98 and constant $7 5 \%$ sparsity has the same FLOPs and parameter count as the dense baseline. Training this network with RigL yields an impressive $4 . 3 \%$ absolute improvement in Top-1 Accuracy.
+
+# 4.2 CHARACTER LEVEL LANGUAGE MODELLING
+
+Most prior work has only examined sparse training on vision networks [the exception is the earliest work - Deep Rewiring (Bellec et al., 2017) which trained an LSTM (Hochreiter & Schmidhuber, 1997) on the TIMIT (Garofolo et al., 1993) dataset]. To fully understand these techniques it is important to examine different architectures on different datasets. Kalchbrenner et al. (2018) found sparse GRUs (Cho et al., 2014) to be very effective at modeling speech, however the dataset they used is not available. We choose a proxy task with similar characteristics (dataset size and vocabulary size are approximately the same) - character level language modeling on the publicly available WikiText-103 (Merity et al., 2016) dataset.
+
+Our network consists of a shared embedding with dimensionality 128, a vocabulary size of 256, a GRU with a state size of 512, a readout from the GRU state consisting of two linear layers with 256 units and 128 units respectively. We train the next step prediction task with the standard cross entropy loss, the Adam optimizer, a learning rate of $7 e - 4$ , an L2 regularization coefficient of $5 e { - 4 }$ , a sequence length of 512, a batch size of 32 and gradient absolute value clipping of values larger (in magnitude) than 10. Baseline training length is 200,000 iterations. When inducing sparsity with magnitude pruning (Zhu & Gupta, 2018), we perform pruning between iterations 50,000 and
+
+![](images/f16a2ec71b43df85e1a6ff38138e0337a2c670eede9c85bef31c854aa486fd2f.jpg)  
+Figure 4: (left) Final validation loss of various sparse training methods on character level language modelling task. Cross entropy loss is converted to bits (from nats). Performance and the training cost of a dense model is indicated with dashed red lines. (right) Test accuracies of sparse WideResNet22-2’s on CIFAR-10 task.
+
+150,000 with a pruning frequency of 1,000. We initialize sparse networks with a uniform sparsity distribution and use a cosine update schedule with $\alpha = 0 . 1$ and $\Delta T = 1 0 0$ . Unlike the previous experiments we keep updating the mask until the end of the training; we observed this performed slightly better than stopping at iteration 150,000.
+
+In Figure 4-left we report the validation loss of various solutions at the end of the training. For each method we perform extended runs to see how they scale with increasing training time. As observed before, SET performs worst than the other dynamic training methods and its performance improves only slightly with increased training time. On the other hand the performance of RigL and SNFS improves constantly with more training steps. Both of these methods falls short of matching the pruning performance.
+
+# 4.3 WIDERESNET-22-2 ON CIFAR-10
+
+In this section, we evaluate the performance of RigL on CIFAR-10 image classification benchmark. We train Wide Residual Network’s (Zagoruyko & Komodakis, 2016) with 22 layers using a width multiplier of 2 for 250 epochs (97656 steps). Learning rate starts at 0.1 and scaled down by a factor of 5 every 30,000 iterations. We use an L2 regularization coefficient of 5e-4, a batch size of 128 and a momentum coefficient of 0.9. We keep the hyper-parameters specific to RigL same as the ImageNet experiments, except the final iteration for mask updates; which is adjusted to 75000. Results with different mask update intervals can be found in Appendix H.
+
+Performance of RigL across different sparsity levels is presented in Figure 4-right. Corresponding final training losses of the trained networks can be found in Appendix H. The dense baseline obtains $9 4 . 1 \%$ test accuracy. Networks with half of the connections removed $50 \%$ sparsity) achieves roughly the same accuracy as the dense baseline. Surprisingly, some of the networks at this sparsity level generalize better than the dense baseline demonstrating the regularization aspect of using sparsity. With increased sparsity, we start to see a performance gap between the Static and Pruning solutions. Training static RigL networks longer seems to have limited effect on the final performance. On the other hand, RigL, matches the performance of pruning using only a fraction of resources needed for training a dense network.
+
+# 4.4 ANALYZING THE PERFORMANCE OF RigL
+
+In this section we study the effect of sparsity distributions, update schedules, and dynamic connections on the performance of our method. The results for SET and SNFS are similar and are discussed in Appendices B and E.
+
+Effect of Mask Initialization: Figure 5-left shows how the sparsity distribution affects the final test accuracy of sparse ResNet-50s trained with RigL. Erdos-R ˝ enyi-Kernel (ERK) performs consis- ´ tently better than the other two distributions. ERK automatically allocates more parameters to the layers with few parameters by decreasing their sparsities†. This reallocation seems to be crucial for preserving the capacity of the network at high sparsity levels where ERK outperforms other distributions by a greater margin. Though it performs better, the ERK distribution requires approximately twice as many FLOPs compared to a uniform distribution. This highlights an interesting trade-off between accuracy and computational efficiency even though both models have the same number of parameters.
+
+![](images/5800160114d0737b3e2907dc82a457c52f3b8ccbcf1ecf67ee038a009c690904.jpg)  
+Figure 5: (left) Performance of RigL at different sparsities using different sparsity masks (right) Ablation study on cosine schedule. Other methods are in the appendix.
+
+Effect of Update Schedule and Frequency: In Figure 5-right, we evaluate the performance of our method on update intervals $\Delta T \in [ 5 0 , 1 0 0 , 5 0 0 , 1 0 0 0 ]$ and initial drop fractions $\alpha \in [ 0 . 1 , 0 . 3 , 0 . 5$ ]. The best accuracies are obtained when the mask is updated every 100 iterations with an initial drop fraction of 0.3 or 0.5. Notably, even with frequent update intervals (e.g. every 1000 iterations), RigL performs above $7 3 . 5 \%$ .
+
+Effect of Dynamic connections: Frankle et al. (2019) and Mostafa & Wang (2019) observed that static sparse training converges to a solution with a higher loss than dynamic sparse training. In Figure 6-left we examine the loss landscape lying between a solution found via static sparse training and a solution found via pruning to understand whether former lies in a basin isolated from the latter. Performing a linear interpolation between the two reveals the expected result – high-loss barrier – demonstrating that the loss landscape is not trivially connected. However, this is only one of infinitely many paths between the two points optimization can be used to find parametric curves that connects solutions (Garipov et al., 2018; Draxler et al., 2018) subject to constraints. For example Garipov et al. (2018) showed different dense solutions lie in the same basin by finding 2nd order Bezier curves with low energy between the two solutions. Following their method, we attempt ´ to find quadratic and cubic Bezier curves between the two sparse solutions. Surprisingly, even with a ´ cubic curve, we fail to find a path without a high-loss barrier. These results suggest that static sparse training can get stuck at local minima that are isolated from improved solutions. On the other hand, when we optimize the quadratic Bezier curve across the full ´ dense space we find a near-monotonic path to the improved solution, suggesting that allowing new connections to grow lends dynamic sparse training greater flexibility in navigating the loss landscape.
+
+![](images/96e95693d928d87ad902426e986b917f4232a0de25740f3cd1cb80a5c1a6297c.jpg)  
+Figure 6: (left) Training loss evaluated at various points on interpolation curves between a magnitude pruning model (0.0) and a model trained with static sparsity (1.0). (right) Training loss of RigL and Static methods starting from the static sparse solution, and their final accuracies.
+
+In Figure 6-right we train RigL starting from the sub-optimal solution found by static sparse training, demonstrating that it is able to escape the local minimum, whereas re-training with static sparse training cannot. RigL first removes connections with the smallest magnitudes since removing these connections have been shown to have a minimal effect on the loss (Han et al., 2015; Evci, 2018). Next, it activates connections with the high gradients, since these connections are expected to decrease the loss fastest. We hypothesize in Appendix A that RigL escapes bad critical points by replacing saddle directions with high gradient dimensions.
+
+# 5 DISCUSSION & CONCLUSION
+
+In this work we introduced ‘Rigged Lottery’ or RigL, an algorithm for training sparse neural networks efficiently. For a given computational budget RigL achieves higher accuracies than existing dense-to-sparse and sparse-to-sparse training algorithms. RigL is useful in three different scenarios: (1) To improve the accuracy of sparse models intended for deployment; (2) To improve the accuracy of large sparse models which can only be trained for a limited number of iterations; and (3) Combined with sparse primitives to enable training of extremely large sparse models which otherwise would not be possible.
+
+The third scenario is unexplored due to the lack of hardware and software support for sparsity. Nonetheless, work continues to improve the performance of sparse networks on current hardware (Hong et al., 2019; Merrill & Garland, 2016), and new types of hardware accelerators will have better support for parameter sparsity (Wang et al., 2018; Mike Ashby, 2019; Liu et al., 2018; Han et al., 2016a; Chen et al., 2019). RigL provides the tools to take advantage of, and motivation for, such advances.
+
+# REFERENCES
+
+Mart´ın Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Greg S. Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Ian Goodfellow, Andrew Harp, Geoffrey Irving, Michael Isard, Yangqing Jia, Rafal Jozefowicz, Lukasz Kaiser, Manjunath Kudlur, Josh Levenberg, Dan Mane, Rajat Monga, Sherry Moore, Derek Murray, Chris Olah, ´ Mike Schuster, Jonathon Shlens, Benoit Steiner, Ilya Sutskever, Kunal Talwar, Paul Tucker, Vincent Vanhoucke, Vijay Vasudevan, Fernanda Viegas, Oriol Vinyals, Pete Warden, Martin Watten- ´ berg, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng. TensorFlow: Large-scale machine learning on heterogeneous systems, 2015. URL http://tensorflow.org/.
+
+Guillaume Bellec, David Kappel, Wolfgang Maass, and Robert A. Legenstein. Deep rewiring: Training very sparse deep networks. CoRR, abs/1711.05136, 2017. URL http://arxiv. org/abs/1711.05136.
+
+Y. Chen, T. Yang, J. Emer, and V. Sze. Eyeriss v2: A flexible accelerator for emerging deep neural networks on mobile devices. IEEE Journal on Emerging and Selected Topics in Circuits and Systems, 9(2):292–308, June 2019. doi: 10.1109/JETCAS.2019.2910232.
+
+Kyunghyun Cho, B van Merrienboer, Caglar Gulcehre, F Bougares, H Schwenk, and Yoshua Bengio. Learning phrase representations using rnn encoder-decoder for statistical machine translation. In Conference on Empirical Methods in Natural Language Processing (EMNLP 2014), 2014.
+
+Diederik P. Kingma Christos Louizos, Max Welling. Learning sparse neural networks through $l _ { 0 }$ regularization. In International Conference on Learning Representations, 2018.
+
+Tim Dettmers and Luke Zettlemoyer. Sparse networks from scratch: Faster training without losing performance. ArXiv, 2019. URL http://arxiv.org/abs/1907.04840.
+
+Felix Draxler, Kambis Veschgini, Manfred Salmhofer, and Fred A Hamprecht. Essentially No Barriers in Neural Network Energy Landscape. In International Conference on Machine Learning, 2018.
+
+Utku Evci. Detecting dead weights and units in neural networks. CoRR, 2018. URL http: //arxiv.org/abs/1806.06068.
+
+Utku Evci, Fabian Pedregosa, Aidan N. Gomez, and Erich Elsen. The difficulty of training sparse neural networks. ArXiv, 2019. URL http://arxiv.org/abs/1906.10732.
+
+Jonathan Frankle and Michael Carbin. The lottery ticket hypothesis: Finding sparse, trainable neural networks. In 7th International Conference on Learning Representations, ICLR 2019, New Orleans, LA, USA, May 6-9, 2019, 2019. URL https://openreview.net/forum?id $=$ rJl-b3RcF7.
+
+Jonathan Frankle, Gintare Karolina Dziugaite, Daniel M. Roy, and Michael Carbin. The lottery ticket hypothesis at scale. ArXiv, 2019. URL http://arxiv.org/abs/1903.01611.
+
+Trevor Gale, Erich Elsen, and Sara Hooker. The state of sparsity in deep neural networks. CoRR, abs/1902.09574, 2019. URL http://arxiv.org/abs/1902.09574.
+
+Timur Garipov, Pavel Izmailov, Dmitrii Podoprikhin, Dmitry P Vetrov, and Andrew Gordon Wilson. Loss surfaces, mode connectivity, and fast ensembling of dnns. In Advances in Neural Information Processing Systems, 2018.
+
+J. S. Garofolo, L. F. Lamel, W. M. Fisher, J. G. Fiscus, D. S. Pallett, and N. L. Dahlgren. Darpa timit acoustic phonetic continuous speech corpus cdrom, 1993.
+
+Yiwen Guo, Anbang Yao, and Yurong Chen. Dynamic network surgery for efficient DNNs. CoRR, abs/1608.04493, 2016. URL http://arxiv.org/abs/1608.04493.
+
+Song Han, Jeff Pool, John Tran, and William Dally. Learning both weights and connections for efficient neural network. In Advances in neural information processing systems, 2015.
+
+Song Han, Xingyu Liu, Huizi Mao, Jing Pu, Ardavan Pedram, Mark A. Horowitz, and William J. Dally. EIE: Efficient Inference Engine on compressed deep neural network. In Proceedings of the 43rd International Symposium on Computer Architecture, 2016a.
+
+Song Han, Huizi Mao, and William J. Dally. Deep compression: Compressing deep neural network with pruning, trained quantization and huffman coding. In 4th International Conference on Learning Representations, ICLR 2016, San Juan, Puerto Rico, May 2-4, 2016, Conference Track Proceedings, 2016b. URL http://arxiv.org/abs/1510.00149.
+
+B. Hassibi and D. Stork. Second order derivatives for network pruning: Optimal Brain Surgeon. 1993.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. In Proceedings of the 2015 IEEE International Conference on Computer Vision (ICCV), 2015.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural Comput., 9(8):1735– 1780, November 1997. ISSN 0899-7667. doi: 10.1162/neco.1997.9.8.1735. URL http://dx. doi.org/10.1162/neco.1997.9.8.1735.
+
+Changwan Hong, Aravind Sukumaran-Rajam, Israt Nisa, Kunal Singh, and P. Sadayappan. Adaptive sparse tiling for sparse matrix multiplication. In Proceedings of the 24th Symposium on Principles and Practice of Parallel Programming, PPoPP ’19, pp. 300–314, New York, NY, USA, 2019. ACM. ISBN 978-1-4503-6225-2. doi: 10.1145/3293883.3295712. URL http://doi.acm. org/10.1145/3293883.3295712.
+
+Andrew G. Howard, Menglong Zhu, Bo Chen, Dmitry Kalenichenko, Weijun Wang, Tobias Weyand, Marco Andreetto, and Hartwig Adam. Mobilenets: Efficient convolutional neural networks for mobile vision applications. CoRR, abs/1704.04861, 2017. URL http://arxiv.org/abs/ 1704.04861.
+
+Nal Kalchbrenner, Erich Elsen, Karen Simonyan, Seb Noury, Norman Casagrande, Edward Lockhart, Florian Stimberg, Aaron Oord, Sander Dieleman, and Koray Kavukcuoglu. Efficient neural audio synthesis. In International Conference on Machine Learning (ICML), 2018.
+
+Alex Krizhevsky, Vinod Nair, and Geoffrey Hinton. Cifar-10 (canadian institute for advanced research). URL http://www.cs.toronto.edu/˜kriz/cifar.html.
+
+Yann LeCun, John S. Denker, and Sara A. Solla. Optimal Brain Damage. In Advances in Neural Information Processing Systems, 1990.
+
+Namhoon Lee, Thalaiyasingam Ajanthan, and Philip H. S. Torr. SNIP: Single-shot Network Pruning based on Connection Sensitivity. In International Conference on Learning Representations (ICLR), 2019, 2019.
+
+Hao Li, Asim Kadav, Igor Durdanovic, Hanan Samet, and Hans Peter Graf. Pruning filters for efficient convnets. In International Conference on Learning Representations, 2016.
+
+Chen Liu, Guillaume Bellec, Bernhard Vogginger, David Kappel, Johannes Partzsch, Felix Neumaerker, Sebastian Hoppner, Wolfgang Maass, Stephen B. Furber, Robert A. Legenstein, and ¨ Christian Mayr. Memory-efficient deep learning on a spinnaker 2 prototype. In Front. Neurosci., 2018.
+
+Christos Louizos, Karen Ullrich, and Max Welling. Bayesian compression for deep learning. In Advances in Neural Information Processing Systems, 2017.
+
+Stephen Merity, Caiming Xiong, James Bradbury, and Richard Socher. Pointer sentinel mixture models. ArXiv, 2016. URL http://arxiv.org/abs/1609.07843.
+
+Duane Merrill and Michael Garland. Merge-based sparse matrix-vector multiplication (spmv) using the csr storage format. In Proceedings of the 21st ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, PPoPP ’16, pp. 43:1–43:2, New York, NY, USA, 2016. ACM. ISBN 978-1-4503-4092-2. doi: 10.1145/2851141.2851190. URL http://doi.acm.org/ 10.1145/2851141.2851190.
+
+Peter Baldwin Martijn Bastiaan Oliver Bunting Aiken Cairncross Christopher Chalmers Liz Corrigan Sam Davis Nathan van Doorn Jon Fowler Graham Hazel Basile Henry David Page Jonny Shipton Shaun Steenkamp Mike Ashby, Christiaan Baaij. Exploiting unstructured sparsity on next-generation datacenter hardware. 2019. URL https://myrtle.ai/wp-content/ uploads/2019/06/IEEEformatMyrtle.ai_.21.06.19_b.pdf.
+
+Decebal Constantin Mocanu, Elena Mocanu, Peter Stone, Phuong H Nguyen, Madeleine Gibescu, and Antonio Liotta. Scalable training of artificial neural networks with adaptive sparse connectivity inspired by network science. Nature Communications, 2018.
+
+Dmitry Molchanov, Arsenii Ashukha, and Dmitry P. Vetrov. Variational Dropout Sparsifies Deep Neural Networks. In Proceedings of the 34th International Conference on Machine Learning, ICML 2017, Sydney, NSW, Australia, 6-11 August 2017, pp. 2498–2507, 2017.
+
+Pavlo Molchanov, Stephen Tyree, Tero Karras, Timo Aila, and Jan Kautz. Pruning Convolutional Neural Networks for Resource Efficient Transfer Learning. CoRR, abs/1611.06440, 2016.
+
+Hesham Mostafa and Xin Wang. Parameter efficient training of deep convolutional neural networks by dynamic sparse reparameterization. In Proceedings of the 36th International Conference on Machine Learning, ICML 2019, 9-15 June 2019, Long Beach, California, USA, pp. 4646–4655, 2019. URL http://proceedings.mlr.press/v97/mostafa19a.html.
+
+Sharan Narang, Greg Diamos, Shubho Sengupta, and Erich Elsen. Exploring sparsity in recurrent neural networks. In 5th International Conference on Learning Representations, ICLR 2017, Toulon, France, April 24-26, 2017, Conference Track Proceedings, 2017. URL https: //openreview.net/forum?id=BylSPv9gx.
+
+Jongsoo Park, Sheng R. Li, Wei Wen, Hai Li, Yiran Chen, and Pradeep Dubey. Holistic SparseCNN: Forging the trident of accuracy, speed, and size. CoRR, abs/1608.01409, 2016. URL http: //arxiv.org/abs/1608.01409.
+
+Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, Alexander C. Berg, and Li FeiFei. Imagenet large scale visual recognition challenge. International Journal of Computer Vision (IJCV), 2015.
+
+M. Sandler, A. Howard, M. Zhu, A. Zhmoginov, and L. Chen. Mobilenetv2: Inverted residuals and linear bottlenecks. In 2018 IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 4510–4520, June 2018. doi: 10.1109/CVPR.2018.00474.
+
+S. Srinivas, A. Subramanya, and R. V. Babu. Training sparse neural networks. In 2017 IEEE Conference on Computer Vision and Pattern Recognition Workshops (CVPRW), pp. 455–462, July 2017. doi: 10.1109/CVPRW.2017.61.
+
+Nikko Strom. Sparse Connection and Pruning in Large Dynamic Artificial Neural Networks. In ¨ EUROSPEECH, 1997.
+
+Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jonathon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. In Proceedings of IEEE Conference on Computer Vision and Pattern Recognition,, 2016. URL http://arxiv.org/abs/1512. 00567.
+
+Enzo Tartaglione, Skjalg Lepsøy, Attilio Fiandrotti, and Gianluca Francini. Learning sparse neural networks via sensitivity-driven regularization. In Proceedings of the 32nd International Conference on Neural Information Processing Systems, NIPS’18, pp. 3882–3892, USA, 2018. Curran Associates Inc. URL http://dl.acm.org/citation.cfm?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ 3327144.3327303.
+
+Georg Thimm and Emile Fiesler. Evaluating pruning methods. In National Chiao-Tung University, pp. 2, 1995.
+
+Peiqi Wang, Yu Ji, Chi Hong, Yongqiang Lyu, Dongsheng Wang, and Yuan Xie. Snrram: An efficient sparse neural network computation architecture based on resistive random-access memory. In Proceedings of the 55th Annual Design Automation Conference, DAC ’18, pp. 106:1–106:6, New York, NY, USA, 2018. ACM. ISBN 978-1-4503-5700-5. doi: 10.1145/3195970.3196116. URL http://doi.acm.org/10.1145/3195970.3196116.
+
+Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. In BMVC, 2016.
+
+Hattie Zhou, Janice Lan, Rosanne Liu, and Jason Yosinski. Deconstructing Lottery Tickets: Zeros, Signs, and the Supermask. ArXiv, 2019.
+
+Michael Zhu and Suyog Gupta. To Prune, or Not to Prune: Exploring the Efficacy of Pruning for Model Compression. In International Conference on Learning Representations Workshop, 2018.
+
+# A EFFECT OF MASK UPDATES ON THE ENERGY LANDSCAPE
+
+To update the connectivity of our sparse network, we first need to drop a fraction $d$ of the existing connections for each layer independently to create a budget for growing new connections. Following the recipe of magnitude based pruning(Han et al., 2015), we order parameters at layer $i$ by magnitude $| \theta _ { i } |$ and drop the $N * ( 1 - S ) * d$ parameters with lowest magnitude. The effectiveness of this simple criteria can be explained through the first order Taylor approximation of the loss $L$ around the current set of parameters $\theta$ .
+
+$$
+\Delta L = L ( \theta + \Delta \theta ) - L ( \theta ) = \nabla _ { \theta } L ( \theta ) \Delta \theta + R ( | | \Delta \theta | | _ { 2 } ^ { 2 } )
+$$
+
+The main goal of dropping connections is to remove parameters with minimal impact on the neural network and therefore on its performance. Since removing the connection $\theta _ { i }$ corresponds to setting it to zero, it incurs a change of $\Delta \theta ~ = ~ - \theta _ { i }$ in that direction and a change of $\begin{array} { r l } { \Delta L _ { i } } & { { } = } \end{array}$ $- \nabla _ { \boldsymbol { \theta } _ { i } } \mathbf { \bar { L } } ( \boldsymbol { \theta } ) \boldsymbol { \theta } _ { i } + R ( \boldsymbol { \theta } _ { i } ^ { 2 } )$ in the loss, where the first term is usually defined as the saliency of a connection. Though using saliency to remove connections has been used as a criteria for removing connections (Molchanov et al., 2016), it has been shown to produce inferior results compared to magnitude based removal, especially when used to remove multiple connections at once (Evci, 2018). In contrast, picking the lowest magnitude connections ensures a small remainder term in addition to a low saliency, limiting the damage we make when we drop connections. Additionally, we note that connections with small magnitude can only remain small if the gradient is also small, meaning that the saliency is likely small when the parameter itself is small. Therefore we argue that the connections removed by RigL are likely to be saddle directions of the energy landscape.
+
+After the removal of insignificant connections, we enable new connections that have the highest expected gradients. Since we initialize these new connections to zero, they are guaranteed to have high gradients in the proceeding iteration and therefore to reduce the loss quickly. By definition a direction with high magnitude gradient is not a saddle direction. Combining this observation with the previous ( $R i g L$ is likely to remove saddle directions) and the results in Section 4.4 we suggest that RigL improves the energy landscape of the optimization by replacing saddle directions with the ones with high gradient. This helps the optimization procedure to escape bad critical points and find solutions with higher quality.
+
+# B EFFECT OF SPARSITY DISTRIBUTION ON OTHER METHODS
+
+In Figure 7-left we show the effect of sparsity distribution choice on 4 different sparse training methods. ERK distribution performs better than other distributions for each training method.
+
+# C EFFECT OF MOMENTUM COEFFICIENT FOR SNFS
+
+In Figure 7 right we show the effect of the momentum coefficient on the performance of SNFS. Our results shows that using a coefficient of 0.99 brings the best performance. On the other hand using the most recent gradient only (coefficient of 0) performs as good as using a coefficient of 0.9. This result might be due to the large batch size we are using (4096), but it still motivates using RigL and instantaneous gradient information only when needed, instead of accumulating them.
+
+# D EXISTENCE OF LOTTERY TICKETS
+
+We perform the following experiment to see whether Lottery Tickets exist in our setting. We take the sparse network found by RigL and restart training using original initialization, both with RigL and with fixed topology as in the original Lottery Ticket Hypothesis. Results in table 3 demonstrate that training with a fixed topology is significantly worse than training with RigL and that RigL does not benefit from starting again with the final topology and the original initialization - training for twice as long instead of rewiring is more effective. In short, there are no special tickets, with RigL all tickets seems to win.
+
+![](images/f433bd443059bd764822e9e7a3060af7bbc37812c757ca9ad010a470abc0a839.jpg)  
+Figure 7: (left) Effect of sparsity distribution choice on sparse training methods at different sparsity levels. We average over 3 runs and report the standard deviations for each. (right) Effect of momentum value on the performance of SNFS algorithm. Setting the momentum coefficient of the SNFS algorithm to 0 seems to perform best, suggesting the accumulated values are not important.
+
+Table 3: Effect of lottery ticket initialization on the final performance. There are no special tickets and dynamic connectivity provided by RigL is critical for good performance.   
+
+<table><tr><td>Initialization</td><td>Training Method</td><td>Test Accuracy</td><td>Training FLOPs</td></tr><tr><td>Lottery</td><td>Static</td><td>70.82±0.07</td><td>0.46x</td></tr><tr><td>Lottery</td><td>RigL</td><td>73.93±0.09</td><td>0.46x</td></tr><tr><td>Random</td><td>RigL</td><td>74.55±0.06</td><td>0.23x</td></tr><tr><td>Random</td><td>RigL2x</td><td>76.06±0.09</td><td>0.46x</td></tr></table>
+
+# E EFFECT OF UPDATE SCHEDULES ON OTHER DYNAMIC SPARSE METHODS
+
+In Figure 8 we repeat the hyper-parameter sweep done for RigL in Figure 5-right, using SET and SNFS. Cosine schedule with $\Delta T = 5 0$ and $\alpha = 0 . 1$ seems to work best across all methods. An interesting observation is that higher drop fractions $( \alpha )$ seem to work better with longer intervals $\Delta T$ . For example, SET with $\Delta T = 1 0 0 0$ seems to work best with $\alpha = 0 . 5$ .
+
+# F ALTERNATIVE UPDATE SCHEDULES
+
+In Figure 9, we share the performance of two alternative annealing functions:
+
+1. Constant: $f _ { d e c a y } ( t ) = \alpha$ .   
+2. Inverse Power: The fraction of weights updated decreases similarly to the schedule used in Zhu & Gupta (2018) for iterative pruning: $\begin{array} { r } { f _ { d e c a y } ( t ) = \alpha ( 1 - \frac { t } { T _ { e n d } } ) ^ { k } } \end{array}$ )k. In our experiments we tried $k = 1$ which is the linear decay and their default $k = 3$ .
+
+Constant seems to perform well with low initial drop fractions like $\alpha = 0 . 1$ , but it starts to perform worse with increasing $\alpha$ . Inverse Power for ${ \bf k } = 3$ and ${ \mathrm { k } } { = } 1$ (Linear) seems to perform similarly for low $\alpha$ values. However the performance drops noticeably for ${ \bf k } = 3$ when we increase the update interval. As reported by Dettmers & Zettlemoyer (2019) linear $( \mathrm { k } { = } 1$ ) seems to provide similar results as the cosine schedule.
+
+# G CALCULATING FLOPS OF MODELS AND METHODS
+
+In order to calculate FLOPs needed for a single forward pass of a sparse model, we count the total number of multiplications and additions layer by layer for a given layer sparsity $s ^ { l }$ . The total FLOPs is then obtained by summing up all of these multiply and adds.
+
+Different sparsity distributions require different number of FLOPs to compute a single prediction. For example Erdos-Renyi-Kernel ˝ distributions usually cause earlier layers to be less sparse than the later layers (see Appendix I). The inputs of earlier layers have greater spatial dimensions, so a convolutional kernel that works on such inputs will require more FLOPs to compute the output features compared to later layers. Thus, having earlier layers which are less sparse results in a higher total number of FLOPs required by a model.
+
+![](images/b3e467a52c2f5b11283887318ea99ba50224d604ca1a45394151b61438546ee9.jpg)  
+Figure 8: Cosine update schedule hyper-parameter sweep done using dynamic sparse training methods SET (left) and SNFS (right).
+
+Training a neural network consists of 2 main steps:
+
+1. forward pass: Calculating the loss of the current set of parameters on a given batch of data. During this process layer activations are calculated in sequence using the previous activations and the parameters of the layer. Activation of layers are stored in memory for the backward pass.   
+2. backward pass: Using the loss value as the initial error signal, we back-propagate the error signal while calculating the gradient of parameters. During the backward pass each layer calculates 2 quantities: the gradient of the activations of the previous layer and the gradient of its parameters. Therefore in our calculations we count backward passes as two times the computational expense of the forward pass. We omit the FLOPs needed for batch normalization and cross entropy.
+
+Dynamic sparse training methods require some extra FLOPs to update the connectivity of the neural network. We omit FLOPs needed for dropping the lowest magnitude connections in our calculations. For a given dense architecture with FLOPs $f _ { D }$ and a sparse version with FLOPs $f _ { S }$ , the total FLOPs required to calculate the gradient on a single sample is computed as follows:
+
+• Static Sparse and Dense. Scales with $3 * f _ { S }$ and $3 * f _ { D }$ FLOPs, respectively.   
+• Snip. We omit the initial dense gradient calculation since it is negligible, which means Snip scales in the same way as Static methods: $3 * f _ { S }$ FLOPs.   
+• SET. We omit the extra FLOPs needed for growing random connections, since this operation can be done on chip efficiently. Therefore, the total FLOPs for SET scales with $3 * f _ { S }$ . SNFS. Forward pass and back-propagating the error signal needs $2 * f _ { S }$ FLOPs. However, the dense gradient needs to be calculated at every iteration. Thus, the total number of FLOPs scales with $2 * f _ { S } + f _ { D }$ . RigL. Iterations with no connection updates need $3 * f _ { S }$ FLOPs. However, at every $\Delta T$ iteration we need to calculate the dense gradients. This results in the average FLOPs for RigL given by $\frac { ( 3 * f _ { S } * \Delta T + 2 * f _ { S } + f _ { D } ) } { ( \Delta T + 1 ) }$ .
+
+# H ADDITIONAL PLOTS AND EXPERIMENTS FOR CIFAR-10
+
+In Figure 10-left, we plot the final training loss of experiments presented in Section 4.3 to investigate the generalization properties of the algorithms considered. Poor performance of Static reflects itself in training loss clearly across all sparsity levels. RigL achieves similar final loss as the pruning, despite having around half percent less accuracy. Training longer with RigL decreases the final loss further and the test accuracies start matching pruning (see Figure 4-right) performance. These results show that RigL improves the optimization as promised, however generalizes slightly worse than pruning.
+
+![](images/bf63372d44ae944bab2fb94af7feac16fac25a9bc8f8d3818b33dd4260972182.jpg)  
+Figure 9: Using other update schedules with RigL: (left) Constant (middle) Exponential $\left( \mathrm { k } \mathrm { = } 3 \right)$ and (right) Linear
+
+![](images/e207781847e04baa8da603b4cc537a5073cb27d1d766bb864de9512780d702bc.jpg)  
+Figure 10: Final training loss of sparse models (left) and performance of $R i g L$ at different mask update intervals (right).
+
+In Figure 10-right, we sweep mask update interval $\Delta T$ and plot the final test accuracies. We fix initial drop fraction $\alpha$ to 0.3 and evaluate two different sparsity distributions: Uniform and $E R K$ . Both curves follow a similar pattern as in Imagenet-2012 sweeps (see Figure 8) and best results are obtained when $\Delta T = 1 0 0$ .
+
+# I SPARSITY OF INDIVIDUAL LAYERS FOR SPARSE RESNET-50
+
+Sparsity of ResNet-50 layers given by the Erdos-R ˝ enyi-Kernel sparsity distribution plotted in Figure ´ 11.
+
+# J BUGS DISCOVERED DURING EXPERIMENTS
+
+Our initial implementations contained some subtle bugs, which while not affecting the general conclusion that RigL is more effective than other techniques, did result in lower accuracy for all sparse training techniques. We detail these issues here with the hope that others may learn from our mistakes.
+
+1. Random operations on multiple replicas. We use data parallelism to split a mini-batch among multiple replicas. Each replica independently calculates the gradients using a different sub-mini-batch of data. The gradients are aggregated using an ALL-REDUCE operation before the optimizer update. Our implementation of SET, SNFS and RigL depended on each replica independently choosing to drop and grow the same connections. However, due to the nature of random operations in Tensorflow, this did not happen. Instead, different replicas diverged after the first drop/grow step. This was most pronounced in SET where each replica chose at random and much less so for SNFS and RigL where randomness is only needed to break ties. If left unchecked this might be expected to be catastrophic, but due to the behavior of Estimators and/or TF-replicator, the values on the first replica are broadcast to the others periodically (every approximately 1000 steps in our case).
+
+We fixed this bug by using stateless random operations. As a result the performance of SET improved slightly $0 . 1 \%$ higher on Table 2).
+
+2. Synchronization between replicas. RigL and SNFS depend on calculating dense gradients with respect to the masked parameters. However, as explained above, in the multiple replica setting these gradients need to be aggregated. Normally this aggregation is automatically done by the optimizer, but in our case, this does not happen (only the gradients with respect to the unmasked parameters are aggregated automatically). This bug affected SNFS and RigL, but not SET since SET does not rely on the gradients to grow connections. Again, the synchronization of the parameters from the first replica every approximately 1000 steps masked this bug.
+
+We fixed this bug by explicitly calling ALL-REDUCE on the gradients with respect to the masked parameters. With this fix, the performance of RigL and SNFS improved significantly, particularly for default training lengths (around $0 . 5 – 1 \%$ improvement).
+
+![](images/0b1f9b452aac571c6f076bd13ec4d1e1e1f13be162984229dcfda1d2c8d58426.jpg)  
+Figure 11: Sparsities of individual layers of the ResNet-50.
+
+3. SNIP Experiments. Our first implementation of SNIP used the gradient magnitudes to decide which connections to keep causing its performance to be worse than static. Upon our discussions with the authors of SNIP, we realized that the correct metric is the saliency (gradient times parameter magnitude). With this correction SNIP performance improved dramatically to better than random (Static) even at Resnet-50/ImageNet scale. It is surprising that picking connections with the highest gradient magnitudes can be so detrimental to training (it resulted in much worse than random performance).