Add files using upload-large-folder tool

parse/train/9DlCh34E1bN/9DlCh34E1bN_content_list.json

@@ -0,0 +1,1370 @@
+[
+    {
+        "type": "text",
+        "text": "On the Expressivity of Markov Reward ",
+        "text_level": 1,
+        "bbox": [
+            259,
+            122,
+            740,
+            147
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "David Abel DeepMind dmabel@deepmind.com ",
+        "bbox": [
+            196,
+            200,
+            361,
+            243
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Will Dabney DeepMind wdabney@deepmind.com ",
+        "bbox": [
+            390,
+            200,
+            565,
+            243
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anna Harutyunyan DeepMind harutyunyan@deepmind.com ",
+        "bbox": [
+            593,
+            200,
+            802,
+            243
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Mark K. Ho Department of Computer Science Princeton University mho@princeton.edu ",
+        "bbox": [
+            240,
+            263,
+            462,
+            320
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Michael L. Littman Department of Computer Science Brown University mlittman@cs.brown.edu ",
+        "bbox": [
+            534,
+            263,
+            758,
+            320
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Doina Precup DeepMind doinap@deepmind.com ",
+        "bbox": [
+            277,
+            340,
+            444,
+            383
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Satinder Singh DeepMind baveja@deepmind.com ",
+        "bbox": [
+            553,
+            340,
+            720,
+            383
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            419,
+            535,
+            435
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Reward is the driving force for reinforcement-learning agents. This paper is dedicated to understanding the expressivity of reward as a way to capture tasks that we would want an agent to perform. We frame this study around three new abstract notions of “task” that might be desirable: (1) a set of acceptable behaviors, (2) a partial ordering over behaviors, or (3) a partial ordering over trajectories. Our main results prove that while reward can express many of these tasks, there exist instances of each task type that no Markov reward function can capture. We then provide a set of polynomial-time algorithms that construct a Markov reward function that allows an agent to optimize tasks of each of these three types, and correctly determine when no such reward function exists. We conclude with an empirical study that corroborates and illustrates our theoretical findings. ",
+        "bbox": [
+            233,
+            450,
+            766,
+            603
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            630,
+            310,
+            647
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "How are we to use algorithms for reinforcement learning (RL) to solve problems of relevance in the world? Reward plays a significant role as a general purpose signal: For any desired behavior, task, or other characteristic of agency, there must exist a reward signal that can incentivize an agent to learn to realize these desires. Indeed, the expressivity of reward is taken as a backdrop assumption that frames RL, sometimes called the reward hypothesis: “...all of what we mean by goals and purposes can be well thought of as maximization of the expected value of the cumulative sum of a received scalar signal (reward)” [53, 29, 6]. In this paper, we establish first steps toward a systematic study of the reward hypothesis by examining the expressivity of reward as a signal. We proceed in three steps. ",
+        "bbox": [
+            174,
+            662,
+            825,
+            773
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1. An Account of “Task”. As rewards encode tasks, goals, or desires, we first ask, “what is a task?”. We frame our study around a thought experiment (Figure 1) involving the interactions between a designer, Alice, and a learning agent, Bob, drawing inspiration from Ackley and Littman [2], Sorg [50], and Singh et al. [46]. In this thought experiment, we draw a distinction between how Alice thinks of a task (TASKQ) and the means by which Alice incentivizes Bob to pursue this task (EXPRESSIONQ). This distinction allows us to analyze the expressivity of reward as an answer to the latter question, conditioned on how we answer the former. Concretely, we study three answers to the TASKQ in the context of finite Markov Decision Processes (MDPs): A task is either (1) a set of acceptable behaviors (policies), (2) a partial ordering over behaviors, or (3) a partial ordering over trajectories. Further detail and motivation for these task types is provided in Section 3, but broadly they can be viewed as generalizations of typical notions of task such as a choice of goal or optimal behavior. Given these three answers to the TASKQ, we then examine the expressivity of reward. ",
+        "bbox": [
+            174,
+            789,
+            825,
+            900
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/e8e8abd164d3f79d4a7a8a028af7674de12a1b7ef923da00922c85226e319ab2.jpg",
+        "image_caption": [
+            "Figure 1: Alice, Bob, and the artifacts of task definition (blue) and task expression (purple). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            287,
+            87,
+            709,
+            224
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            272,
+            825,
+            328
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2. Expressivity of Markov Reward. The core of our study asks whether there are tasks Alice would like to convey—as captured by the answers to the TASKQ—that admit no characterization in terms of a Markov reward function. Our emphasis on Markov reward functions, as opposed to arbitrary history-based reward functions, is motivated by several factors. First, disciplines such as computer science, psychology, biology, and economics typically rely on a notion of reward as a numerical proxy for the immediate worth of states of affairs (such as the financial cost of buying a solar panel or the fitness benefits of a phenotype). Given an appropriate way to describe states of affairs, Markov reward functions can represent immediate worth in an intuitive manner that also allows for reasoning about combinations, sequences, or re-occurrences of such states of affairs. Second, it is not clear that general history-based rewards are a reasonable target for learning as they suffer from the curse of dimensionality in the length of the history. Lastly, Markov reward functions are the standard in RL. A rigorous analysis of which tasks they can and cannot convey may provide guidance into when it is necessary to draw on alternative formulations of a problem. Given our focus on Markov rewards, we treat a reward function as accurately expressing a task just when the value function it induces in an environment adheres to the constraints of a given task. ",
+        "bbox": [
+            174,
+            342,
+            825,
+            549
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3. Main Results. We find that, for all three task types, there are environment–task pairs for which there is no Markov reward function that realizes the task (Theorem 4.1). In light of this finding, we design polynomial-time algorithms that can determine, for any given task and environment, whether a reward function exists in the environment that captures the task (Theorem 4.3). When such a reward function does exist, the algorithms also return it. Finally, we conduct simple experiments with these procedures to provide empirical insight into the expressivity of reward (Section 5). ",
+        "bbox": [
+            173,
+            564,
+            825,
+            647
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Collectively, our results demonstrate that there are tasks that cannot be expressed by Markov reward in a rigorous sense, but we can efficiently construct such reward functions when they do exist (and determine when they do not). We take these findings to shed light on the nature of reward maximization as a principle, and highlight many pathways for further investigation. ",
+        "bbox": [
+            174,
+            654,
+            825,
+            710
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Background ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            728,
+            308,
+            746
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "RL defines the problem facing an agent that learns to improve its behavior over time by interacting with its environment. We make the typical assumption that the RL problem is well modeled by an agent interacting with a finite Markov Decision Process (MDP), defined by the tuple $( S , \\mathcal { A } , R , T , \\gamma , s _ { 0 } )$ . An MDP gives rise to deterministic behavioral policies, $\\pi : { \\mathcal { S } }  A$ , and the value, $V ^ { \\pi } : { \\mathcal { S } }  \\mathbb { R }$ , and action–value, $Q ^ { \\pi } : S \\times \\mathcal { A }  \\mathbb { R }$ , functions that measure their quality. We will refer to a Controlled Markov Process (CMP) as an MDP without a reward function, which we denote $E$ for environment. We assume that all reward functions are deterministic, and may be a function of either state, stateaction pairs, or state-action-state triples, but not history. Henceforth, we simply use “reward function” to refer to a deterministic Markov reward function for brevity, but note that more sophisticated settings beyond MDPs and deterministic Markov reward functions are important directions for future work. For more on MDPs or RL, see the books by Puterman [41] and Sutton and Barto [54] respectively. ",
+        "bbox": [
+            174,
+            758,
+            826,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 Other Perspectives on Reward ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            90,
+            423,
+            106
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We here briefly summarize relevant literature that provides distinct perspectives on reward. ",
+        "bbox": [
+            171,
+            116,
+            766,
+            131
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Two Roles of Reward. As Sorg [50] identifies (Chapter 2), reward can both define the task the agent learns to solve, and define the “bread crumbs” that allow agents to efficiently learn to solve the task. This distinction has been raised elsewhere [2, 46, 47], and is similar to the extrinsic-intrinsic reward divide [45, 66]. Tools such as reward design [34, 51] or reward shaping [36] focus on offering more efficient learning in a variety of environments, so as to avoid issues of sparsity and long-term credit assignment. We concentrate primarily on reward’s capacity to express a task, and defer learning dynamics to an (important) stage of future work. ",
+        "bbox": [
+            174,
+            145,
+            825,
+            242
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Discounts, Expectations, and Rationality. Another important facet of reward is how it is used in producing behavior. The classical view offered by the Bellman equation (and the reward hypothesis) is that the quantity of interest to maximize is expected, discounted, cumulative reward. Yet it is possible to disentangle reward from the expectation [5], to attend only to ordinal [60] or maximal rewards [26], or to adopt different forms of discounting [61, 11]. In this work, we take the standard view that agents will seek to maximize value for a particular discount factor $\\gamma$ , but recognize that there are interesting directions beyond these commitments, such as inspecting the limits of reward in constrained MDPs as studied by Szepesvári [56]. We also note the particular importance of work by Pitis [40], who examines the relationship between classical decision theory [59] and MDPs by incorporating additional axioms that account for stochastic processes with discounting [24, 35, 48, 49]. Drawing inspiration from Pitis [40] and Sunehag and Hutter [52], we foresee valuable pathways for future work that further makes contact between RL and various axioms of rationality. ",
+        "bbox": [
+            174,
+            257,
+            825,
+            422
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Preferences. In place of numerical rewards, preferences of different kinds may be used to evaluate an agent’s behaviors, drawing from the literature on preference-learning [25] and ordinal dynamic programming [8, 35, 48]. This premise gives rise to preference-based reinforcement learning (PbRL) in which an agent interacts with a CMP and receives evaluative signals in the form of preferences over states, actions, or trajectories. This kind of feedback inspires and closely parallels the task types we propose in this work. A comprehensive survey of PbRL by Wirth et al. [64] identifies critical differences in this setup from traditional RL, categorizes recent algorithmic approaches, and highlights important open questions. Recent work focuses on analysing the sample efficiency of such methods [65, 38] with close connections to learning from human feedback in real time [23, 32, 7]. ",
+        "bbox": [
+            174,
+            438,
+            825,
+            563
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Teaching and Inverse RL. The inverse RL (IRL) and apprenticeship learning literature examine the problem of learning directly from behavior [37, 1]. The classical problem of IRL is to identify which reward function (often up to an equivalence class) a given demonstrator is optimizing. We emphasize the relevance of two approaches: First, work by Syed et al. [55], who first illustrate the applicability of linear programming [22] to apprenticeship learning; and second, work by Amin et al. [4], who examine the repeated form of IRL. The methods of IRL have recently been expanded to include variations of cooperative IRL [14], and assistive learning [43], which offer different perspectives on how to frame interactive learning problems. ",
+        "bbox": [
+            174,
+            577,
+            825,
+            688
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Reward Misspecification. Reward is also notoriously hard to specify. As pointed out by Littman et al. [30], “putting a meaningful dollar figure on scuffing a wall or dropping a clean fork is challenging.” Along these lines, Hadfield-Menell et al. [16] identify cases in which well-intentioned designers create reward functions that produce unintended behavior [39]. MacGlashan et al. [33] find that human-provided rewards tend to depend on a learning agent’s entire policy, rather than just the current state. Further, work by Hadfield-Menell et al. [15] and Kumar et al. [27] suggest that there are problems with reward as a learning mechanism due to misspecification and reward tampering [10]. These problems have given rise to approaches to reward learning, in which a reward function is inferred from some evidence such as behavior or comparisons thereof [20]. ",
+        "bbox": [
+            174,
+            702,
+            825,
+            827
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Other Notions of Task. As a final note, we highlight alternative approaches to task specification. Building on the Free Energy Principle [13, 12], Hafner et al. [17] consider a variety of task types in terms of minimization of distance to a desired target distribution [3]. Alternatively, Littman et al. [30] and Li et al. [28] propose variations of linear temporal logic (LTL) as a mechanism for specifying a task to RL agents, with related literature extending LTL to the multi-task [58] and multi-agent [18] settings, or using reward machines for capturing task structure [19]. Jothimurugan et al. [21] take a similar approach and propose a task specification language for RL based on logical formulas that evaluate whether trajectories satisfy the task, similar in spirit to the logical task compositions framework developed by Tasse et al. [57]. Many of these notions of task are more general than those we consider. A natural direction for future work broadens our analysis to include these kinds of task. ",
+        "bbox": [
+            174,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            92,
+            825,
+            160
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 An Account of Reward’s Expressivity: The TASKQ and EXPRESSIONQ ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            184,
+            800,
+            203
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Consider an onlooker, Alice, and an earnest learning agent, Bob, engaged in the interaction pictured in Figure 1. Suppose that Alice has a particular task in mind that she would like Bob to learn to solve, and that Alice constructs a reward function to incentivize Bob to pursue this task. Here, Alice is playing the role of “all of what we mean by goals and purposes” for Bob to pursue, with Bob playing the role of the standard reward-maximizing RL agent. ",
+        "bbox": [
+            174,
+            219,
+            825,
+            290
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Two Questions About Task. To give us leverage to study the expressivity of reward, it is useful to draw a distinction between two stages of this process: 1) Alice thinks of a task that she would like Bob to learn to solve, and 2) Alice creates a reward function (and perhaps chooses $\\gamma$ ) that conveys the chosen task to Bob. We inspect these two separately, framed by the following two questions. The first we call the task-definition question (TASKQ) which asks: What is a task? The second we call the task-expression question (EXPRESSIONQ) which asks: Which learning signal can be used as a mechanism for expressing any task to Bob? ",
+        "bbox": [
+            174,
+            309,
+            825,
+            406
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Reward Answers The EXPRESSIONQ. We suggest that it may be useful to treat reward as an answer to the EXPRESSIONQ rather than the TASKQ. On this view, reward is treated as an expressive language for incentivizing reward-maximizing agents: Alice may attempt to translate any task into a reward function that incentivizes Bob to pursue the task, no matter which environment Bob inhabits, which task Alice has chosen, or how she has represented the task to herself. Indeed, it might be the case that Alice’s knowledge of the task far exceeds Bob’s representational or perceptual capacity. Alice may know every detail of the environment and define the task based on this holistic vantage, while Bob must learn to solve the task through interaction alone, relying only on a restricted class of functions for modeling and decision making. ",
+        "bbox": [
+            174,
+            426,
+            825,
+            551
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Under this view, we can assess the expressivity of reward as an answer to the EXPRESSIONQ conditioned on how we answer the TASKQ. For example, if the TASKQ is answered in terms of natural language descriptions of desired states of affairs, then reward may fail to convey the chosen task due to the apparent mismatch in abstraction between natural language and reward (though some work has studied such a proposal [31, 62]). ",
+        "bbox": [
+            174,
+            558,
+            825,
+            627
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 Answers to the TASKQ: What is a Task? ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            648,
+            493,
+            664
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In RL, tasks are often associated with a choice of goal, reward function $( R )$ , reward-discount pair $( R , \\gamma )$ , or perhaps a choice of optimal policy (alongside those task types surveyed previously, such as LTL). However, it is unclear whether these constructs capture the entirety of what we mean by “task”. ",
+        "bbox": [
+            176,
+            676,
+            823,
+            718
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For example, consider the Russell and Norvig [42] grid world: A $4 \\times 3$ grid with one wall, one terminal fire state, and one terminal goal state (pictured with a particular reward function in Figure 4a). In such an environment, how might we think about tasks? A standard view is that the task is to reach the goal as quickly as possible. This account, however, fails to distinguish between the non-optimal behaviors, such as the costly behavior of the agent moving directly into the fire and the neutral behavior of the agent spending its existence in the start state. Indeed, characterizing a task in terms of choice of $\\pi ^ { * }$ or goal fails to capture these distinctions. Our view is that a suitably rich account of task should allow for the characterization of this sort of preference, offering the flexibility to scale from specifying only the desirable behavior (or outcomes) to an arbitrary ordering over behaviors (or outcomes). ",
+        "bbox": [
+            174,
+            724,
+            825,
+            849
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In light of these considerations, we propose three answers to the TASKQ that can convey general preferences over behavior or outcome: 1) A set of acceptable policies, 2) A partial ordering over policies, or 3) A partial ordering over trajectories. We adopt these three as they can capture many kinds of task while also allowing a great deal of flexibility in the level of detail of the specification. ",
+        "bbox": [
+            176,
+            856,
+            823,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/5cfaee9a6d89f7040c6162dbf74013b3034be4fd35df387b50610650c954d1a6.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 1: A summary of the three proposed task types. We further list the constraints that determine whether a reward function realizes each task type in an MDP, where we take $\\oplus$ to be one of $\\cdot _ { < } , \\cdot >$ , or $\" = \"$ , and $G$ is the discounted return of the trajectory. "
+        ],
+        "table_body": "<table><tr><td></td><td></td><td></td><td>NameNotation GeneralizesConstraints Induced by F</td></tr><tr><td>SOAPIIG</td><td></td><td>task-as-π*</td><td>equal: V&quot;g(so)= V&quot;g&#x27;(s0)&gt; Vπb(s0),∀πg,πg∈IIG,πb∈IIB range: Vπg (so) &gt; Vπb(so),∀πg∈llg,πb∈IIB</td></tr><tr><td>PO</td><td>LI</td><td>SOAP</td><td>(π1④π2)∈LI =→V1(so)④V″²(s0)</td></tr><tr><td>TO</td><td>LT,N</td><td></td><td>task-as-g0al (T1 ④ T2) ∈ LT,N =→ G(T1; So) ④ G(T2; S0)</td></tr></table>",
+        "bbox": [
+            174,
+            88,
+            821,
+            208
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 SOAPs, POs, and TOs ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            290,
+            367,
+            305
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "(SOAP) Set Of Acceptable Policies. A classical view of the equivalence of two reward functions is based on the optimal policies they induce. For instance, $\\mathrm { N g }$ et al. [36] develop potential-based reward shaping by inspecting which shaped reward signals will ensure that the optimal policy is unchanged. Extrapolating, it is natural to say that for any environment $E$ , two reward functions are equivalent if the optimal policies they induce in $E$ are the same. In this way, a task is viewed as a choice of optimal policy. As discussed in the grid world example above, this notion of task fails to allow for the specification of the quality of other behaviors. For this reason, we generalize task-as-optimal-policy to a set of acceptable policies, defined as follows. ",
+        "bbox": [
+            174,
+            315,
+            825,
+            428
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Definition 3.1. A set of acceptable policies $( S O A P )$ is a non-empty subset of the deterministic policies, $\\Pi _ { G } \\subseteq \\Pi$ , with Π the set of all deterministic mappings from $s$ to $\\mathcal { A }$ for a given $E$ . ",
+        "bbox": [
+            174,
+            433,
+            820,
+            462
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "With one task type defined, it is important to address what it means for a reward function to properly realize, express, or capture a task in a given environment. We offer the following account. ",
+        "bbox": [
+            176,
+            473,
+            821,
+            501
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Definition 3.2. A reward function is said to realize a task $\\mathcal { T }$ in an environment $E$ just when the start-state value (or return) induced by the reward function exactly adheres to the constraints of $\\mathcal { T }$ ",
+        "bbox": [
+            174,
+            506,
+            820,
+            535
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Precise conditions for the realization of each task type are provided alongside each task definition, with a summary presented in column four of Table 1. ",
+        "bbox": [
+            176,
+            546,
+            823,
+            575
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For SOAPs, we take the start-state value $V ^ { \\pi } ( s _ { 0 } )$ to be the mechanism by which a reward function realizes a SOAP. That is, for a given $E$ and $\\Pi _ { G }$ , a reward function $R$ is said to realize the $\\Pi _ { G }$ in $E$ when the start-state value function is optimal for all good policies, and strictly higher than the start-state value of all other policies. It is clear that SOAP strictly generalizes a task in terms of a choice of optimal policy, as captured by the SOAP $\\Pi _ { G } = \\{ \\pi ^ { * } \\}$ . ",
+        "bbox": [
+            174,
+            582,
+            825,
+            651
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We note that there are two natural ways for a reward function to realize a SOAP: First, each $\\pi _ { g } \\in \\Pi _ { G }$ has optimal start-state value and all other policies are sub-optimal. We call this type equal-SOAP, or just SOAP for brevity. Alternatively, we might only require that the acceptable policies are each near-optimal, but are allowed to differ in start-state value so long as they are all better than every bad policy $\\pi _ { b } \\in \\Pi _ { B }$ . That is, in this second kind, there exists an $\\epsilon \\geq 0$ such that every $\\pi _ { g } \\in \\Pi _ { G }$ is $\\epsilon$ -optimal in start-state value, $V ^ { \\ast } ( s _ { 0 } ) - V ^ { \\pi _ { g } } ( s _ { 0 } ) \\leq \\epsilon$ , while all other policies are worse. We call this second realization condition range-SOAP. We note that the range realization generalizes the equal one: Every equal-SOAP is a range-SOAP (by letting $\\epsilon = 0$ ). However, there exist range-SOAPs that are expressible by Markov rewards that are not realizable as an equal-SOAP. We illustrate this fact with the following proposition. All proofs are presented in Appendix B. ",
+        "bbox": [
+            173,
+            657,
+            825,
+            796
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Proposition 3.1. There exists a CMP, $E$ , and choice of $\\Pi _ { G }$ such that $\\Pi _ { G }$ can be realized under the range-SOAP criterion, but cannot be realized under the equal-SOAP criterion. ",
+        "bbox": [
+            173,
+            801,
+            821,
+            829
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "One such CMP is pictured Figure 2b. Consider the SOAP $\\Pi _ { G } = \\left\\{ \\pi _ { 1 1 } , \\pi _ { 1 2 } , \\pi _ { 2 1 } \\right\\}$ : Under the equalSOAP criterion, if each of these three policies are made optimal, any reward function will also make $\\pi _ { 2 2 }$ (the only bad policy) optimal as well. In contrast, for the range criterion, we can choose a reward function that assigns lower rewards to $a _ { 2 }$ than $a _ { 1 }$ in both states. In general, we take the equal-SOAP realization as canonical, as it is naturally subsumed by our next task type. ",
+        "bbox": [
+            174,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "(PO) Partial Ordering on Policies. Next, we suppose that Alice chooses a partial ordering on the deterministic policy space. That is, Alice might identify a some great policies, some good, and some bad policies to strictly avoid, and remain indifferent to the rest. POs strictly generalize equal SOAPs, as any such SOAP is a special choice of PO with only two equivalence classes. We offer the following definition of a PO. ",
+        "bbox": [
+            174,
+            92,
+            825,
+            160
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Definition 3.3. A policy order $( P O )$ of the deterministic policies $\\Pi$ is a partial order, denoted $L _ { \\Pi }$ ",
+        "bbox": [
+            174,
+            164,
+            813,
+            179
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As with SOAPs, we take the start-state value $V ^ { \\pi } ( s _ { 0 } )$ induced by a reward function $R$ as the mechanism by which policies are ordered. That is, given $E$ and $L _ { \\Pi }$ , we say that a reward function $R$ realizes $L _ { \\Pi }$ in $E$ if and only if the resulting MDP, $M = ( E , R )$ , produces a start-state value function that orders $\\Pi$ according to $L _ { \\Pi }$ . ",
+        "bbox": [
+            176,
+            189,
+            825,
+            246
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "(TO) Partial Ordering on Trajectories. A natural generalization of goal specification enriches a notion of task to include the details of how a goal is satisfied—that is, for Alice to relay some preference over trajectory space [63], as is done in preference based RL [64]. Concretely, we suppose Alice specifies a partial ordering on length $N$ trajectories of $( s , a )$ pairs, defined as follows. ",
+        "bbox": [
+            174,
+            260,
+            823,
+            315
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Definition 3.4. A trajectory ordering $( T O )$ of length $N \\in  { \\mathbb { N } }$ is a partial ordering $L _ { \\tau , N }$ , with each trajectory $\\tau$ consisting of $N$ state–action pairs, $\\left\\{ ( s _ { 0 } , a _ { 0 } ) , \\ldots , ( a _ { N - 1 } , s _ { N - 1 } ) \\right\\}$ , with $s _ { 0 }$ the start state. ",
+        "bbox": [
+            174,
+            319,
+            823,
+            348
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As with PO, we say that a reward function realizes a trajectory ordering $L _ { \\tau , N }$ if the ordering determined by each trajectory’s cumulative discounted $N$ -step return from $s _ { 0 }$ , denoted $G ( \\tau ; s _ { 0 } )$ , matches that of the given $L _ { \\tau , N }$ . We note that trajectory orderings can generalize goal-based tasks at the expense of a larger specification. For instance, a TO can convey the task, “Safely reach the goal in less than thirty steps, or just get to the subgoal in less than twenty steps.” ",
+        "bbox": [
+            174,
+            358,
+            825,
+            428
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Recap. We propose to assess the expressivity of reward by first answering the TASKQ in terms of SOAPs, POs, or TOs, as summarized by Table 1. We say that a task $\\mathcal { T }$ is realized in an environment $E$ under reward function $R$ if the start-state value function (or return) produced by $R$ imposes the constraints specified by $\\mathcal { T }$ , and are interested in whether reward can always realize a given task in any choice of $E$ . We make a number of assumptions along the way, including: (1) Reward functions are Markov and deterministic, (2) Policies of interest are deterministic, (3) The environment is a finite CMP, (4) $\\gamma$ is part of the environment, (5) We ignore reward’s role in shaping the learning process, (6) Start-state value or return is the appropriate mechanism to determine if a reward function realizes a given task. Relaxation of these assumptions is a critical direction for future work. ",
+        "bbox": [
+            173,
+            443,
+            825,
+            568
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 Analysis: The Expressivity of Markov Reward ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            585,
+            593,
+            603
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "With our definitions and objectives in place, we now present our main results. ",
+        "bbox": [
+            176,
+            617,
+            679,
+            632
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 Express SOAPs, POs, and TOs ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            647,
+            426,
+            662
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We first ask whether reward can always realize a given SOAP, PO, or TO, for an arbitrary $E$ . Our first result states that the answer is “no”—there are tasks that cannot be realized by any reward function. ",
+        "bbox": [
+            174,
+            672,
+            825,
+            700
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Theorem 4.1. For each of SOAP, PO, and $T O$ , there exist $( E , \\mathcal { T } )$ pairs for which no Markow reward function realizes $\\mathcal { T }$ in $E$ . ",
+        "bbox": [
+            173,
+            704,
+            823,
+            733
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Thus, reward is incapable of capturing certain tasks. What tasks are they, precisely? Intuitively, inexpressible tasks involve policies or trajectories that must be correlated in value in an MDP. That is, if two policies are nearly identical in behavior, it is unlikely that reward can capture the PO that places them at opposite ends of the ordering. A simple example is the “always move the same direction” task in a grid world, with state defined as an $( x , y )$ pair. The SOAP $\\Pi _ { G } = \\{ \\pi _ { \\left. } , \\pi _ { \\uparrow } , \\pi _ { \\right. } , \\pi _ { \\downarrow } \\}$ conveys this task, but no Markov reward function can make these policies strictly higher in value than all others. ",
+        "bbox": [
+            173,
+            744,
+            825,
+            827
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Example: Inexpressible SOAPs. Observe the two CMPs pictured in Figure 2, depicting two kinds of inexpressible SOAPs. On the left, we consider the SOAP $\\bar { \\Pi } _ { G } = \\{ \\pi _ { 2 1 } \\}$ , containing only the policy that executes $a _ { 2 }$ in the left state $( s _ { 0 } )$ , and $a _ { 1 }$ in the right $( s _ { 1 } )$ . This SOAP is inexpressible through reward, but only because reward cannot distinguish the start-state value of $\\pi _ { 2 1 }$ and $\\pi _ { 2 2 }$ since the policies differ only in an unreachable state. This is reminiscent of Axiom 5 from Pitis [40], which explicitly excludes preferences of this sort. On the right, we find a more interesting case: The chosen SOAP is similar to the XOR function, $\\Pi _ { G } = \\{ \\pi _ { 1 2 } , \\pi _ { 2 1 } \\}$ . Here, the task requires that the agent choose each action in exactly one state. However, there cannot exist a reward function that makes only these policies optimal, as by consequence, both policies $\\pi _ { 1 1 }$ and $\\pi _ { 2 2 }$ must be optimal as well. ",
+        "bbox": [
+            174,
+            842,
+            823,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/7e2521434653bc359042031494792030a541697f55fdd0726f183527d25b6f71.jpg",
+        "image_caption": [
+            "Figure 2: Two CMPs in which there is a SOAP that is not expressible under any Markov reward function. On the left, $\\Pi _ { G } = \\{ \\pi _ { 2 1 } \\}$ is not realizable, as $\\pi _ { 2 1 }$ can not be made better than $\\pi _ { 2 2 }$ because $s _ { 1 }$ is never reached. On the right, the XOR-like-SOAP, $\\Pi _ { G } = \\{ \\pi _ { 1 2 } , \\pi _ { 2 1 } \\}$ is not realizable: To make these two policies optimal, it is entailed that $\\pi _ { 2 2 }$ and $\\pi _ { 1 1 }$ must be optimal, too. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            228,
+            102,
+            764,
+            185
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            273,
+            825,
+            330
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Next, we show that Theorem 4.1 is not limited to a particular choice of transition function or $\\gamma$ ",
+        "bbox": [
+            171,
+            335,
+            795,
+            349
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Proposition 4.2. There exist choices of $E _ { \\neg T } = ( S , A , \\gamma , s _ { 0 } )$ or $E _ { \\neg \\gamma } = ( S , A , T , s _ { 0 } )$ , together with a task $\\mathcal { T }$ , such that there is no $( T , R )$ pair that realizes $\\mathcal { T }$ in $E _ { \\neg T }$ or $( R , \\gamma )$ in $E _ { \\neg \\gamma }$ . ",
+        "bbox": [
+            171,
+            352,
+            823,
+            382
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "This result suggests that the scope of Theorem 4.1 is actually quite broad—even if the transition function or $\\gamma$ are taken as part of the reward specification, there are tasks that cannot be expressed. We suspect there are ways to give a precise characterization of all inexpressible tasks from an axiomatic perspective, which we hope to study in future work. ",
+        "bbox": [
+            173,
+            391,
+            825,
+            446
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 Constructive Algorithms: Task to Reward ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            463,
+            506,
+            478
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We now analyze how to determine whether an appropriate reward function can be constructed for any $( E , \\mathcal { T } )$ pair. We pose a general form of the reward-design problem [34, 51, 9] as follows. ",
+        "bbox": [
+            173,
+            488,
+            823,
+            517
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Definition 4.1. The REWARDDESIGN problem is: Given $E = ( \\mathcal { S } , \\mathcal { A } , T , \\gamma , s _ { 0 } )$ , and a $\\mathcal { T }$ , output a reward function $R _ { a l i c e }$ that ensures $\\mathcal { T }$ is realized in $M = \\left( E , R _ { a l i c e } \\right)$ . ",
+        "bbox": [
+            173,
+            518,
+            821,
+            549
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Indeed, for all three task types, there is an efficient algorithm for solving the reward-design problem. Theorem 4.3. The REWARDDESIGN problem can be solved in polynomial time, for any finite $E$ , and any $\\mathcal { T }$ , so long as reward functions with infinitely many outputs are considered. ",
+        "bbox": [
+            174,
+            558,
+            826,
+            603
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Therefore, for any choice of finite CMP, $E$ , and a SOAP, PO, or TO, we can find a reward function that perfectly realizes the task in the given environment, if such a reward function exists. Each of the three algorithms are based on forming a linear program that matches the constraints of the given task type, which is why reward functions with infinitely many outputs are required. Pseudo-code for SOAP-based reward design is presented in Algorithm 1. Intuitively, the algorithms compute the discounted expected-state visitation distribution for a collection of policies; in the case of SOAP, for instance, these policies include $\\Pi _ { G }$ and what we call the “fringe”, the set of policies that differ from a $\\pi _ { g } \\in \\Pi _ { G }$ by exactly one action. Then, we use these distributions to describe linear inequality constraints ensuring that the start-state value of the good policies are better than those of the fringe. ",
+        "bbox": [
+            174,
+            613,
+            825,
+            739
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "As highlighted by Theorem 4.1 there are SOAPs, POs, and TOs that are not realizable. Thus, it is important to determine how the algorithms mentioned in Theorem 4.3 will handle such cases. Our next corollary illustrates that the desirable outcome is achieved: For any $E$ and $\\mathcal { T }$ , the algorithms will output a reward function that realizes $\\mathcal { T }$ in $E$ , or output $_ { \\perp } ,$ when no such function exists. ",
+        "bbox": [
+            174,
+            744,
+            825,
+            800
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Corollary 4.4. For any task $\\mathcal { T }$ and environment $E$ , deciding whether $\\mathcal { T }$ is expressible in $E$ is solvable in polynomial time. ",
+        "bbox": [
+            173,
+            803,
+            825,
+            832
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Together, Theorem 4.1 and Theorem 4.3 constitute our main results: There are environment–task pairs in which Markov reward cannot express the chosen task for each of SOAPs, POs, and TOs. However, there are efficient algorithms for deciding whether a task is expressible, and for constructing the realizing reward function when it exists. We will study the use of one of these algorithms in Section 5, but first attend to other aspects of reward’s expressivity. ",
+        "bbox": [
+            174,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 SOAP Reward Design ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            90,
+            410,
+            106
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "INPUT: $E = ( { \\mathcal { S } } , A , T , \\gamma , s _ { 0 } ) , \\Pi _ { G }$ .   \nOUTPUT: $R$ , or $\\perp$ .   \n1: Πfringe = compute_fringe $\\left( \\Pi _ { G } \\right)$   \n2: for $\\bar { \\pi } _ { g , i } \\in \\Pi _ { G }$ do . Compute state-visitation distributions. 3: $\\rho _ { g , i } =$ compute_exp_visit $( \\pi _ { g , i } , E )$   \n4: for $\\pi _ { f , i } \\in \\Pi _ { \\mathrm { f r i n g e } }$ do   \n5: $\\rho _ { f , i } =$ compute_exp_visit $( \\pi _ { f , i } , E )$   \n6: $C _ { \\mathrm { { e q } } } = \\{ \\}$ . Make Equality Constraints. 7: for $\\pi _ { g , i } \\in \\Pi _ { G }$ do   \n8: $C _ { \\mathrm { e q . } } \\mathsf { a d d } ( \\rho _ { g , 0 } ( s _ { 0 } ) \\cdot X = \\rho _ { g , i } ( s _ { 0 } ) \\cdot X )$   \n9: $C _ { \\mathrm { i n e q } } = \\{ \\}$ . Make Inequality Constraints. 10: for $\\bar { \\pi } _ { f , j } \\in \\Pi _ { \\mathrm { f r i n g e } }$ do   \n11: $\\begin{array} { r } { \\check { C } _ { \\mathrm { i n e q . } } \\mathsf { a d d } ( \\check { \\rho _ { f , j } } ( s _ { 0 } ) \\cdot X + \\epsilon \\le \\rho _ { g , 0 } ( s _ { 0 } ) \\cdot X ) } \\end{array}$   \n12: $R _ { \\mathrm { o u t } }$ , $\\epsilon _ { \\mathrm { o u t } } =$ linear_programming(obj. $= { \\mathrm { m a x } } \\epsilon$ , constraints $= C _ { \\mathrm { i n e q } } , C _ { \\mathrm { e q } } )$ . Solve LP. 13: if $\\epsilon _ { \\mathrm { o u t } } > 0$ then $\\triangleright$ Check if successful. return $R _ { \\mathrm { o u t } }$   \n14: else   \nreturn ⊥ ",
+        "bbox": [
+            174,
+            108,
+            828,
+            434
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3 Other Aspects of Reward’s Expressivity ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            458,
+            490,
+            473
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We next briefly summarize other considerations about the expressivity of reward. As noted, Theorem 4.3 requires the use of a reward function that can produce infinitely many outputs. Our next result proves this requirement is strict for efficient reward design. ",
+        "bbox": [
+            174,
+            483,
+            825,
+            525
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Theorem 4.5. A variant of the REWARDDESIGN problem with finite reward outputs is NP-hard. ",
+        "bbox": [
+            171,
+            529,
+            807,
+            544
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We provide further details about the precise problem studied in Appendix B. Beyond reward functions with finitely-many outputs, we are also interested in extensions of our results to multiple environments. We next present a positive result indicating our algorithms can extend to the case where Alice would like to design a reward function for a single task across multiple environments. ",
+        "bbox": [
+            174,
+            553,
+            825,
+            609
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Proposition 4.6. For any SOAP, PO, or TO, given a finite set of CMPs, $\\mathcal { E } = \\{ E _ { 1 } , \\ldots , E _ { n } \\}$ , with shared state–action space, there exists a polynomial time algorithm that outputs one reward function that realizes the task (when possible) in all CMPs in $\\mathcal { E }$ . ",
+        "bbox": [
+            174,
+            613,
+            825,
+            655
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "A natural follow up question to the above result asks whether task realization is closed under a set of CMPs. Our next result answers this question in the negative. ",
+        "bbox": [
+            173,
+            665,
+            823,
+            694
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Theorem 4.7. Task realization is not closed under sets of CMPs with shared state-action space. That is, there exist choices of $\\mathcal { T }$ and $\\mathcal { E } = \\{ E _ { 1 } , \\ldots , E _ { n } \\}$ such that $\\mathcal { T }$ is realizable in each $E _ { i } \\in \\mathcal { E }$ independently, but there is not a single reward function that realizes $\\mathcal { T }$ in all $E _ { i } \\in \\mathcal { E }$ simultaneously. ",
+        "bbox": [
+            174,
+            696,
+            825,
+            739
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Intuitively, this shows that Alice must know precisely which environment Bob will inhabit if she is to design an appropriate reward function. Otherwise, her uncertainty over $E$ may prevent her from designing a realizing reward function. We foresee iterative extensions of our algorithms in which Alice and Bob can react to one another, drawing inspiration from repeated IRL by Amin et al. [4]. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            806
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            824,
+            312,
+            842
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We next conduct experiments to shed further light on the findings of our analysis. Our focus is on SOAPs, though we anticipate the insights extend to POs and TOs as well with little complication. In the first experiment, we study the fraction of SOAPs that are expressible in small CMPs as we vary aspects of the environment or task (Figure 3). In the second, we use one algorithm from Theorem 4.3 to design a reward function, and contrast learning curves under a SOAP-designed reward function compared to standard rewards. Full details about the experiments are found in Appendix C. ",
+        "bbox": [
+            174,
+            856,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/5005b54dfa05ba36af75a15b9ecb041099a770578c98353866ee22a5d1d671a8.jpg",
+        "image_caption": [
+            "Figure 3: The approximate fraction of SOAPs that are expressible by reward in CMPs with a handful of states and actions, with $9 5 \\%$ confidence intervals. In each plot, we vary a different parameter of the environment or task to illustrate how this change impacts the expressivity of reward, showing both equal (color) and range (grey) realization of SOAP. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            209,
+            106,
+            787,
+            351
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            443,
+            823,
+            472
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "SOAP Expressivity. First, we estimate the fraction of SOAPs that are expressible in small environments. For each data point, we sample 200 random SOAPs and run Algorithm 1 described by Theorem 4.3 to determine whether each SOAP is realizable in the given CMP. We ask this question for both the equal (color) variant of SOAP realization and the range (grey) variant. We inspect SOAP expressivity as we vary six different characteristics of $E$ or $\\Pi _ { G }$ : The number of actions, the number of states, the discount $\\gamma$ , the number of good policies in each SOAP, the Shannon entropy of $T$ at each $( s , a )$ pair, and the “spread” of each SOAP. The spread approximates average edit distance among policies in $\\Pi _ { G }$ determined by randomly permuting actions of a reference policy by a coin weighted according to the value on the $\\mathbf { X }$ -axis. We use the same set of CMPs for each environment up to any deviations explicitly made by the varied parameter (such as $\\gamma$ or entropy). Unless otherwise stated, each CMP has four states and three actions, with a fixed but randomly chosen transition function. ",
+        "bbox": [
+            173,
+            487,
+            825,
+            638
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Results are presented in Figure 3. We find that our theory is borne out in a number of ways. First, as Theorem 4.1 suggests, we find SOAP expressivity is strictly less than one in nearly all cases. This is evidence that inexpressible tasks are not only found in manufactured corner cases, but rather that expressivity is a spectrum. We further observe—as predicted by Proposition 3.1—clear separation between the expressivity of range-SOAP (grey) vs. equal-SOAP (color); there are many cases where we can find a reward function that makes the good policies near optimal and better than the bad, but cannot make those good policies all exactly optimal. Additionally, several trends emerge as we vary the parameter of environment or task, though we note that such trends are likely specific to the choice of CMP and may not hold in general. Perhaps the most striking trend is in Figure 3f, which shows a decrease in expressivity as the SOAPs become more spread out. This is quite sensible: A more spread out SOAP is likely to lead to more entailments of the kind discussed in Figure 2b. ",
+        "bbox": [
+            173,
+            646,
+            825,
+            797
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Learning with SOAP-designed Rewards. Next, we contrast the learning performance of Qlearning under a SOAP-designed reward function (visualized in Figure 4a) with that of the regular goal-based reward in the Russell and Norvig [42] grid world. In this domain, there is 0.35 slip probability such that, on a ‘slip’ event, the agent randomly applies one of the two orthogonal action effects. The regular goal-based reward function provides $+ 1$ when the agent enters the terminal flag cell, and $- 1$ when the agent enters the terminal fire cell. The bottom left state is the start-state, and the black cell is an impassable wall. ",
+        "bbox": [
+            174,
+            814,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/5d021953e8f8f26210e83664393ef931c7293318456b15ff88a24ede527d7e3a.jpg",
+        "image_caption": [
+            "Figure 4: A SOAP-designed reward function (left) and the resulting learning curves (right) for Qlearning compared to the traditional reward function for the Russell and Norvig [42] grid world. Each series presents average performance over 50 runs of the experiment with $9 5 \\%$ confidence intervals. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            104,
+            782,
+            256
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Results are presented in Figure 4. On the right, we present a particular kind of learning curve contrasting the performance of Q-learning with the SOAP reward (blue) and regular reward (green). The y-axis measures, at the end of each episode, the average (inverse) minimum edit distance between Q-learning’s greedy policy and any policy in the SOAP. Thus, when the series reaches 1.0, Q-learning’s greedy policy is identical to one of the two SOAP policies. We first find that Q-learning is able to quickly learn a $\\pi _ { g } \\in \\Pi _ { G }$ under the designed reward function. We further observe that the typical reward does not induce a perfect match in policy—at convergence, the green curve hovers slightly below the blue, indicating that the default reward function is incentivizing different policies to be optimal. This is entirely sensible, as the two SOAP policies are extremely cautious around the fire; they choose the orthogonal (and thus, safe) action in fire-adjacent states, relying on slip probability to progress. Lastly, as expected given the amount of knowledge contained in the SOAP, the SOAP reward function allows Q-learning to rapidly identify a good policy compared to the typical reward. ",
+        "bbox": [
+            174,
+            338,
+            825,
+            506
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            531,
+            297,
+            547
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We have here investigated the expressivity of Markov reward, framed around three new accounts of task. Our main results show that there exist choices of task and environment in which Markov reward cannot express the chosen task, but there are efficient algorithms that decide whether a task is expressible and construct a reward function that captures the task when such a function exists. We conclude with an empirical examination of our analysis, corroborating the findings of our theory. We take these to be first steps toward understanding the full scope of the reward hypothesis. ",
+        "bbox": [
+            174,
+            566,
+            825,
+            650
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "There are many routes forward. A key direction moves beyond the task types we study here, and relaxes our core assumptions—the environment might not be a finite CMP, Alice may not know the environment precisely, reward may be a function of history, or Alice may not know how Bob represents state. Along similar lines, a critical direction incorporates how reward impacts Bob’s learning dynamics rather than start-state value. Further, we note the potential relevance to the recent reward-is-enough hypothesis proposed by Silver et al. [44]; we foresee pathways to extend our analysis to examine this newer hypothesis, too. For instance, in future work, it is important to assess whether reward is capable of inducing the right kinds of attributes of cognition, not just behavior. ",
+        "bbox": [
+            174,
+            656,
+            825,
+            767
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments and Disclosure of Funding ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            792,
+            553,
+            810
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The authors would like to thank André Barreto, Diana Borsa, Michael Bowling, Wilka Carvalho, Brian Christian, Jess Hamrick, Steven Hansen, Zac Kenton, Ramana Kumar, Katrina McKinney, Rémi Munos, Matt Overlan, Hado van Hasselt, and Ben Van Roy for helpful discussions. We would also like to thank the anonymous reviewers for their thoughtful feedback, and Brendan O’Donoghue for catching a typo in the appendix. Michael Littman was supported in part by funding from DARPA L2M, ONR MURI, NSF FMitF, and NSF RI. ",
+        "bbox": [
+            174,
+            827,
+            825,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References   \n[1] Pieter Abbeel and Andrew Y. Ng. Apprenticeship learning via inverse reinforcement learning. In Proceedings of the International Conference on Machine learning, 2004.   \n[2] David Ackley and Michael L. Littman. Interactions between learning and evolution. Artificial Life II, 1992.   \n[3] Sundararaman Akshay, Nathalie Bertrand, Serge Haddad, and Loic Helouet. The steady-state control problem for Markov decision processes. In Proceedings of the International Conference on Quantitative Evaluation of Systems, 2013.   \n[4] Kareem Amin, Nan Jiang, and Satinder Singh. Repeated inverse reinforcement learning. In Advances in Neural Information Processing Systems, 2017.   \n[5] Marc G. Bellemare, Will Dabney, and Rémi Munos. A distributional perspective on reinforcement learning. In Proceedings of the International Conference on Machine Learning, 2017.   \n[6] Brian Christian. The Alignment Problem: Machine Learning and Human Values, pages 130–131. Atlantic Books, 2021.   \n[7] Paul F. Christiano, Jan Leike, Tom B. Brown, Miljan Martic, Shane Legg, and Dario Amodei. Deep reinforcement learning from human preferences. In Advances in Neural Information Processing Systems, 2017.   \n[8] Gerard Debreu. Representation of a preference ordering by a numerical function. Decision Processes, 3:159–165, 1954.   \n[9] Daniel Dewey. Reinforcement learning and the reward engineering principle. In Proceedings of the AAAI Spring Symposium Series, 2014.   \n[10] Tom Everitt, Victoria Krakovna, Laurent Orseau, Marcus Hutter, and Shane Legg. Reinforcement learning with a corrupted reward channel. In Proceedings of the International Joint Conference on Artificial Intelligence, 2017.   \n[11] William Fedus, Carles Gelada, Yoshua Bengio, Marc G. Bellemare, and Hugo Larochelle. Hyperbolic discounting and learning over multiple horizons. arXiv preprint arXiv:1902.06865, 2019.   \n[12] Karl J. Friston. The free-energy principle: a unified brain theory? Nature reviews neuroscience, 11(2):127–138, 2010.   \n[13] Karl J. Friston, Jean Daunizeau, and Stefan J. Kiebel. Reinforcement learning or active inference? PloS One, 4(7):e6421, 2009.   \n[14] Dylan Hadfield-Menell, Anca Dragan, Pieter Abbeel, and Stuart Russell. Cooperative inverse reinforcement learning. In Advances in Neural Information Processing Systems, 2016.   \n[15] Dylan Hadfield-Menell, Anca Dragan, Pieter Abbeel, and Stuart Russell. The off-switch game. In Proceedings of the International Joint Conference on Artificial Intelligence, 2017.   \n[16] Dylan Hadfield-Menell, Smitha Milli, Pieter Abbeel, Stuart Russell, and Anca Dragan. Inverse reward design. In Advances in Neural Information Processing Systems, 2017.   \n[17] Danijar Hafner, Pedro A. Ortega, Jimmy Ba, Thomas Parr, Karl J. Friston, and Nicolas Heess. Action and perception as divergence minimization. arXiv preprint arXiv:2009.01791, 2020.   \n[18] Lewis Hammond, Alessandro Abate, Julian Gutierrez, and Michael Wooldridge. Multi-agent reinforcement learning with temporal logic specifications. In Proceedings of the International Conference on Autonomous Agents and Multiagent Systems, 2021.   \n[19] Rodrigo Toro Icarte, Toryn Klassen, Richard Valenzano, and Sheila McIlraith. Using reward machines for high-level task specification and decomposition in reinforcement learning. In Proceedings of the International Conference on Machine Learning, 2018. ",
+        "bbox": [
+            171,
+            68,
+            828,
+            916
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[20] Hong Jun Jeon, Smitha Milli, and Anca Dragan. Reward-rational (implicit) choice: A unifying formalism for reward learning. In Advances in Neural Information Processing Systems, 2020. ",
+        "bbox": [
+            173,
+            90,
+            825,
+            121
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[21] Kishor Jothimurugan, Rajeev Alur, and Osbert Bastani. A composable specification language for reinforcement learning tasks. In Advances in Neural Information Processing Systems, 2020. ",
+        "bbox": [
+            176,
+            128,
+            823,
+            159
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[22] Narendra Karmarkar. A new polynomial-time algorithm for linear programming. In Proceedings of the Annual ACM Symposium on Theory of Computing, 1984. ",
+        "bbox": [
+            174,
+            167,
+            823,
+            196
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[23] W. Bradley Knox and Peter Stone. Interactively shaping agents via human reinforcement: The TAMER framework. In Proceedings of the International Conference on Knowledge Capture, 2009. ",
+        "bbox": [
+            178,
+            207,
+            823,
+            248
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[24] Tjalling C. Koopmans. Stationary ordinal utility and impatience. Econometrica: Journal of the Econometric Society, pages 287–309, 1960. ",
+        "bbox": [
+            174,
+            258,
+            825,
+            287
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[25] David Kreps. Notes on the Theory of Choice. Westview Press, 1988. ",
+        "bbox": [
+            174,
+            296,
+            661,
+            313
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[26] Sai Krishna Gottipati, Yashaswi Pathak, Rohan Nuttall, Raviteja Chunduru, Ahmed Touati, Sriram Ganapathi Subramanian, Matthew E. Taylor, and Sarath Chandar. Maximum reward formulation in reinforcement learning. In NeurIPS Workshop on Deep Reinforcement Learning, 2020. ",
+        "bbox": [
+            176,
+            321,
+            825,
+            377
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[27] Ramana Kumar, Jonathan Uesato, Richard Ngo, Tom Everitt, Victoria Krakovna, and Shane Legg. REALab: An embedded perspective on tampering. arXiv preprint arXiv:2011.08820, 2020. ",
+        "bbox": [
+            173,
+            387,
+            823,
+            430
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[28] Xiao Li, Cristian-Ioan Vasile, and Calin Belta. Reinforcement learning with temporal logic rewards. In Proceedings of the International Conference on Intelligent Robots and Systems, 2017. ",
+        "bbox": [
+            174,
+            440,
+            823,
+            482
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[29] Michael L. Littman. The reward hypothesis, 2017. URL https:// www.coursera.org/lecture/fundamentals-of-reinforcement-learning/ michael-littman-the-reward-hypothesis-q6x0e. ",
+        "bbox": [
+            173,
+            492,
+            825,
+            535
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[30] Michael L. Littman, Ufuk Topcu, Jie Fu, Charles Isbell, Min Wen, and James MacGlashan. Environment-independent task specifications via GLTL. arXiv preprint arXiv:1704.04341, 2017. ",
+        "bbox": [
+            171,
+            545,
+            826,
+            587
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[31] James MacGlashan, Monica Babes-Vroman, Marie desJardins, Michael L. Littman, Smaranda Muresan, Shawn Squire, Stefanie Tellex, Dilip Arumugam, and Lei Yang. Grounding English commands to reward functions. In Proceedings of Robotics: Science and Systems, 2015. ",
+        "bbox": [
+            173,
+            597,
+            823,
+            640
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[32] James MacGlashan, Michael L. Littman, David L. Roberts, Robert Loftin, Bei Peng, and Matthew E. Taylor. Convergent actor critic by humans. In Proceedings of the International Conference on Intelligent Robots and Systems, 2016. ",
+        "bbox": [
+            173,
+            648,
+            823,
+            691
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[33] James MacGlashan, Mark K. Ho, Robert Loftin, Bei Peng, Guan Wang, David L. Roberts, Matthew E. Taylor, and Michael L. Littman. Interactive learning from policy-dependent human feedback. In Proceedings of the International Conference on Machine Learning. PMLR, 2017. ",
+        "bbox": [
+            173,
+            700,
+            825,
+            744
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[34] Maja J. Mataric. Reward functions for accelerated learning. In Proceedings of the International Conference on Machine Learning, 1994. ",
+        "bbox": [
+            171,
+            753,
+            825,
+            784
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[35] L. G. Mitten. Preference order dynamic programming. Management Science, 21(1):43–46, 1974. ",
+        "bbox": [
+            171,
+            791,
+            826,
+            821
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[36] Andrew Y. Ng, Daishi Harada, and Stuart Russell. Policy invariance under reward transformations: Theory and application to reward shaping. In Proceedings of the International Conference on Machine Learning, 1999. ",
+        "bbox": [
+            173,
+            830,
+            823,
+            873
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[37] Andrew Y. Ng, Stuart J. Russell, et al. Algorithms for inverse reinforcement learning. In Proceedings of the International Conference on Machine Learning, 2000. ",
+        "bbox": [
+            173,
+            882,
+            820,
+            912
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[38] Ellen Novoseller, Yibing Wei, Yanan Sui, Yisong Yue, and Joel Burdick. Dueling posterior sampling for preference-based reinforcement learning. In Proceedings of the Conference on Uncertainty in Artificial Intelligence, 2020.   \n[39] Pedro A. Ortega, Vishal Maini, and the DeepMind Safety Team. Building safe artificial intelligence: specification, robustness, and assurance, 2018. URL https://medium.com/@deepmindsafetyresearch/ building-safe-artificial-intelligence-52f5f75058f1.   \n[40] Silviu Pitis. Rethinking the discount factor in reinforcement learning: A decision theoretic approach. In Proceedings of the AAAI Conference on Artificial Intelligence, 2019.   \n[41] Martin L. Puterman. Markov Decision Processes: Discrete Stochastic Dynamic Programming. John Wiley & Sons, 2014.   \n[42] Stuart J. Russell and Peter Norvig. Artificial Intelligence: A Modern Approach. Prentice-Hall, Englewood Cliffs, NJ, 1994. ISBN 0-13-103805-2.   \n[43] Rohin Shah, Pedro Freire, Neel Alex, Rachel Freedman, Dmitrii Krasheninnikov, Lawrence Chan, Michael D. Dennis, Pieter Abbeel, Anca Dragan, and Stuart Russell. Benefits of assistance over reward learning, 2021. URL https://openreview.net/forum?id $\\ c =$ DFIoGDZejIB.   \n[44] David Silver, Satinder Singh, Doina Precup, and Richard S. Sutton. Reward is enough. Artificial Intelligence, page 103535, 2021.   \n[45] Satinder Singh, Andrew G. Barto, and Nuttapong Chentanez. Intrinsically motivated reinforcement learning. Technical report, University of Massachusetts at Amherst Department of Computer Science, 2005.   \n[46] Satinder Singh, Richard L Lewis, and Andrew G Barto. Where do rewards come from? In Proceedings of the Annual Conference of the Cognitive Science Society, 2009.   \n[47] Satinder Singh, Richard L. Lewis, Jonathan Sorg, Andrew G. Barto, and Akram Helou. On separating agent designer goals from agent goals: Breaking the preferences–parameters confound, 2010.   \n[48] Matthew J. Sobel. Ordinal dynamic programming. Management science, 21(9):967–975, 1975.   \n[49] Matthew J. Sobel. Discounting axioms imply risk neutrality. Annals of Operations Research, 208(1):417–432, 2013.   \n[50] Jonathan Sorg. The Optimal Reward Problem: Designing Effective Reward for Bounded Agents. PhD thesis, University of Michigan, 2011.   \n[51] Jonathan Sorg, Richard L. Lewis, and Satinder Singh. Reward design via online gradient ascent. Advances in Neural Information Processing Systems, 2010.   \n[52] Peter Sunehag and Marcus Hutter. Axioms for rational reinforcement learning. In Proceedings of the International Conference on Algorithmic Learning Theory, 2011.   \n[53] Richard S. Sutton. The reward hypothesis, 2004. URL http://incompleteideas.net/ rlai.cs.ualberta.ca/RLAI/rewardhypothesis.html.   \n[54] Richard S. Sutton and Andrew G. Barto. Reinforcement Learning: An Introduction. MIT Press, 2018.   \n[55] Umar Syed, Michael Bowling, and Robert E. Schapire. Apprenticeship learning using linear programming. In Proceedings of the International Conference on Machine Learning, 2008.   \n[56] Csaba Szepesvári. Constrained MDPs and the reward hypothesis, 2020. URL http:// readingsml.blogspot.com/2020/03/constrained-mdps-and-reward-hypothesis. html.   \n[57] Geraud Nangue Tasse, Steven James, and Benjamin Rosman. A Boolean task algebra for reinforcement learning. In Advances in Neural Information Processing Systems, 2020.   \n[58] Rodrigo Toro Icarte, Toryn Q. Klassen, Richard Valenzano, and Sheila A. McIlraith. Teaching multiple tasks to an RL agent using LTL. In Proceedings of the International Conference on Autonomous Agents and Multiagent Systems, 2018.   \n[59] John von Neumann and Oskar Morgenstern. Theory of Games and Economic Behavior. Princeton University Press, 1953.   \n[60] Paul Weng. Markov decision processes with ordinal rewards: Reference point-based preferences. In Proceedings of the International Conference on Automated Planning and Scheduling, 2011.   \n[61] Martha White. Unifying task specification in reinforcement learning. In Proceedings of the International Conference on Machine Learning, 2017.   \n[62] Edward C. Williams, Nakul Gopalan, Mine Rhee, and Stefanie Tellex. Learning to parse natural language to grounded reward functions with weak supervision. In Proceedings of the International Conference on Robotics and Automation, 2018.   \n[63] Aaron Wilson, Alan Fern, and Prasad Tadepalli. A Bayesian approach for policy learning from trajectory preference queries. In Advances in Neural Information Processing Systems, 2012.   \n[64] Christian Wirth, Riad Akrour, Gerhard Neumann, and Johannes Fürnkranz. A survey of preference-based reinforcement learning methods. The Journal of Machine Learning Research, 18(1):4945–4990, 2017.   \n[65] Yichong Xu, Ruosong Wang, Lin Yang, Aarti Singh, and Artur Dubrawski. Preference-based reinforcement learning with finite-time guarantees. Advances in Neural Information Processing Systems, 33, 2020.   \n[66] Zeyu Zheng, Junhyuk Oh, Matteo Hessel, Zhongwen Xu, Manuel Kroiss, Hado van Hasselt, David Silver, and Satinder Singh. What can learned intrinsic rewards capture? In Proceedings of the International Conference on Machine Learning, 2020. ",
+        "bbox": [
+            171,
+            47,
+            830,
+            921
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            89,
+            828,
+            494
+        ],
+        "page_idx": 13
+    }
+]

parse/train/H11lAfbCW/H11lAfbCW.md

@@ -0,0 +1,275 @@
+# ON CHARACTERIZING THE CAPACITY OF NEURAL NETWORKS USING ALGEBRAIC TOPOLOGY
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+The learnability of different neural architectures can be characterized directly by computable measures of data complexity. In this paper, we reframe the problem of architecture selection as understanding how data determines the most expressive and generalizable architectures suited to that data, beyond inductive bias. After suggesting algebraic topology as a measure for data complexity, we show that the power of a network to express the topological complexity of a dataset in its decision boundary is a strictly limiting factor in its ability to generalize. We then provide the first empirical characterization of the topological capacity of neural networks. Our empirical analysis shows that at every level of dataset complexity, neural networks exhibit topological phase transitions and stratification. This observation allowed us to connect existing theory to empirically driven conjectures on the choice of architectures for a single hidden layer neural networks.
+
+# 1 INTRODUCTION
+
+Deep learning has rapidly become one of the most pervasively applied techniques in machine learning. From computer vision (Krizhevsky et al. (2012)) and reinforcement learning (Mnih et al. (2013)) to natural language processing (Wu et al. (2016)) and speech recognition (Hinton et al. (2012)), the core principles of hierarchical representation and optimization central to deep learning have revolutionized the state of the art; see Goodfellow et al. (2016). In each domain, a major difficulty lies in selecting the architectures of models that most optimally take advantage of structure in the data. In computer vision, for example, a large body of work (Simonyan & Zisserman (2014), Szegedy et al. (2014), He et al. (2015), etc.) focuses on improving the initial architectural choices of Krizhevsky et al. (2012) by developing novel network topologies and optimization schemes specific to vision tasks. Despite the success of this approach, there are still not general principles for choosing architectures in arbitrary settings, and in order for deep learning to scale efficiently to new problems and domains without expert architecture designers, the problem of architecture selection must be better understood.
+
+Theoretically, substantial analysis has explored how various properties of neural networks, (eg. the depth, width, and connectivity) relate to their expressivity and generalization capability (Raghu et al. (2016), Daniely et al. (2016), Guss (2016)). However, the foregoing theory can only be used to determine an architecture in practice if it is understood how expressive a model need be in order to solve a problem. On the other hand, neural architecture search (NAS) views architecture selection as a compositional hyperparameter search (Saxena & Verbeek (2016), Fernando et al. (2017), Zoph & Le (2017)). As a result NAS ideally yields expressive and powerful architectures, but it is often difficult to interperate the resulting architectures beyond justifying their use from their emperical optimality.
+
+We propose a third alternative to the foregoing: data-first architecture selection. In practice, experts design architectures with some inductive bias about the data, and more generally, like any hyperparameter selection problem, the most expressive neural architectures for learning on a particular dataset are solely determined by the nature of the true data distribution. Therefore, architecture selection can be rephrased as follows: given a learning problem (some dataset), which architectures are suitably regularized and expressive enough to learn and generalize on that problem?
+
+A natural approach to this question is to develop some objective measure of data complexity, and then characterize neural architectures by their ability to learn subject to that complexity. Then given some new dataset, the problem of architecture selection is distilled to computing the data complexity and chosing the appropriate architecture.
+
+![](images/8aae215ebe2d7d9a8b91538c0c83f5fdacb92abfe99dfca7d96ab030eab0ed2a.jpg)  
+Figure 1: The positive label outptus of single hidden layer neural networks, $h _ { 1 2 }$ and $h _ { 2 6 }$ , of 2 inputs with 12 and 26 hidden units respectively after training on datasets $\mathcal { D } _ { 1 }$ and $\mathcal { D } _ { 2 }$ with positive examples in red. Highlighted regions of the output constitute the positive decision region.
+
+For example, take the two datasets $\mathcal { D } _ { 1 }$ and $\mathcal { D } _ { 2 }$ given in Figure 1(ab) and Figure 1(cd) respectively. The first dataset, $\mathcal { D } _ { 1 }$ , consists of positive examples sampled from two disks and negative examples from their compliment. On the right, dataset $\mathcal { D } _ { 2 }$ consists of positive points sampled from two disks and two rings with hollow centers. Under some geometric measure of complexity $\mathcal { D } _ { 2 }$ appears more ’complicated’ than $\mathcal { D } _ { 1 }$ because it contains more holes and clusters. As one trains single layer neural networks of increasing hidden dimension on both datasets, the minimum number of hidden units required to achieve zero testing error is ordered according to this geometric complexity. Visually in Figure 1, regardless of initialization no single hidden layer neural network with $\leq 1 2$ units, denoted $h _ { \leq 1 2 }$ , can express the two holes and clusters in $\mathcal { D } _ { 2 }$ . Whereas on the simpler $\mathcal { D } _ { 1 }$ , both $h _ { 1 2 }$ and $h _ { 2 6 }$ can express the decision boundary perfectly. Returning to architecture selection, one wonders if this characterization can be extrapolated; that is, is it true that for datasets with ’similar’ geometric complexity to $\mathcal { D } _ { 1 }$ , any architecture with $\geq 1 2$ hidden learns perfectly, and likewise for those datasets similar in complexity to $\mathcal { D } _ { 2 }$ , architectures with $\leq 1 2$ hidden units can never learn to completion?
+
+# 1.1 OUR CONTRIBUTION
+
+In this paper, we formalize the above of geometric complexity in the language of algebraic topology. We show that questions of architecture selection can be answered by understanding the ’topological capacity’ of different neural networks. In particular, a geometric complexity measure, called persistent homology, characterizes the capacity of neural architectures in direct relation to their ability to generalize on data. Using persistent homology, we develop a method which gives the first empirical insight into the learnability of different architectures as data complexity increases. In addition, our method allows us to generate conjectures which tighten known theoretical bounds on the expressivity of neural networks. Finally, we show that topological characterizations of architectures are possible and useful for architecture selection in practice by computing the persistent homology of CIFAR-10 and several UCI datasets.
+
+# 2 BACKGROUND
+
+# 2.1 GENERAL TOPOLOGY
+
+In order to more formally describe notions of geometric complexity in datasets, we will turn to the language of topology. Broadly speaking, topology is a branch of mathematics that deals with characterizing shapes, spaces, and sets by their connectivity. In the context of characterizing neural networks, we will work towards defining the topological complexity of a dataset in terms of how that dataset is ’connected’, and then group neural networks by their capacity to produce decision regions of the same connectivity.
+
+In topology, one understands the relationships between two different spaces of points by the continuous maps between them. Informally, we say that two topological spaces $A$ and $B$ are equivalent $A \cong B$ ) if there is a continuous function $f : A  B$ that has an inverse $f ^ { - 1 }$ that is also continuous. When $f$ exists, we say that $A$ and $B$ are homeomorphic and $f$ is their homeomorphism; for a more detailed treatment of general topology see Bredon (2013). Take for example, the classic example of the coffee cup and the donut in
+
+![](images/4d2f84897c4384afb308d50a4222dad3c9430d02d76ee479d364fa289dec173f.jpg)  
+Figure 2: A continuous deformation of a coffee cup into a donut, showing that both are topologically equivalent (Kato et al. (2014)).
+
+Figure 2. They are homeomorphic because one can define a continuous deformation of one into the other which shrinks, twists, and morphs without tearing or gluing, as in Figure 2. Note that if the donut had two holes, it would no longer be equivalent to the mug. Likewise, in an informal way, $\mathcal { D } _ { 1 } \not \cong \mathcal { D } _ { 2 }$ in Figure 1 since if there were a homeomorphism $f : \mathcal { D } _ { 1 }  \mathcal { D } _ { 2 }$ at least one of the clusters in $\mathcal { D } _ { 1 }$ would need to be split in order to produce the four different regions in $\mathcal { D } _ { 2 }$ .
+
+The power of topology lies in its capacity to differentiate sets (topological spaces) in a meaningful geometric way that discards certain irrelevant properties such as rotation, translation, curvature, etc. For the purposes of defining geometric complexity, non-topological properties1 like curvature would further fine-tune architecture selection–say if $\mathcal { D } _ { 2 }$ had the same regions but with squigly (differentially complex) boundaries, certain architectures might not converge–but as we will show, grouping neural networks by ’topological capacity’ provides a powerful minimality condition. That is, we will show that if a certain architecture is incapable of expressing a decision region that is equivalent in topology to training data, then there is no hope of it ever generalizing to the true data.
+
+# 2.2 ALGEBRAIC TOPOLOGY
+
+Algebraic topology provides the tools necessary to not only build the foregoing notion of topological equivalence into a measure of geometric complexity, but also to compute that measure on real data (Betti (1872), Dey et al. (1998), Bredon (2013)). At its core, algebraic topology takes topological spaces (shapes and sets with certain properties) and assigns them algebraic objects such as groups, chains, and other more exotic constructs. In doing so, two spaces can be shown to be topologically equivalent (or distinct) if the algebraic objects to which they are assigned are isomorphic (or not). Thus algebraic topology will allow us to compare the complexity of decision boundaries and datasets by the objects to which they are assigned.
+
+Although there are many flavors of algebraic topology, a powerful and computationally realizable tool is homology.
+
+Definition 2.1 (Informal, Bredon (2013)). If $X$ is a topological space, then $H _ { n } ( X ) = \mathbb { Z } ^ { \beta _ { n } }$ is called the nth homology group of $X$ if the power $\beta _ { n }$ is the number of ’holes’ of dimension $n$ in $X$ . Note that $\beta _ { 0 }$ is the number of separate connected components. We call $\beta _ { n } ( X )$ the nth Betti number of $X$ . Finally, the homology2 of $X$ is defined as $H ( X ) = \{ H _ { n } ( X ) \} _ { n = 0 } ^ { \infty }$ .
+
+Immediately homology brings us closer to defining the complexity of $\mathcal { D } _ { 1 }$ and $\mathcal { D } _ { 2 }$ . If we assume that $\mathcal { D } _ { 1 }$ is not actually a collection of $N$ datapoints, but really the union of 2 solid balls, and likewise that $\mathcal { D } _ { 2 }$ is the union of 2 solid balls and 2 rings, then we can compute the homology directly. In this case $H _ { 0 } ( \mathcal { D } _ { 1 } ) = \mathbb { Z } ^ { 2 }$ since there are two connected components3; $H _ { 1 } ( \mathcal { D } _ { 1 } ) = \{ 0 \}$ since there are no circles (one-dimensional holes); and clearly, $H _ { n } ( \mathcal { D } _ { 1 } ) = { \overline { { \{ 0 \} } } }$ for $n \geq 2$ . Performing the same computation in the second case, we get $H _ { 0 } ( \mathcal { D } _ { 2 } ) = \mathbb { Z } ^ { 4 }$ and $H _ { 1 } ( \dot { \mathcal { D } } _ { 2 } ) = \mathbb { Z } ^ { 2 }$ as there are 4 seperate clusters and 2 rings/holes. With respect to any reasonable ordering on homology, $\mathcal { D } _ { 2 }$ is more complex than $\mathcal { D } _ { 1 }$ . The measure yields non-trivial differentiation of spaces in higher dimension. For example, the homology of a hollow donut is $\{ \mathbb { Z } ^ { 1 } , \mathbb { Z } ^ { 2 } , \mathbb { Z } ^ { 1 } , 0 , \dots \}$ .
+
+Surprisingly, the homology of a space contains a great deal of information about its topological complexity1. The following theorem suggests the absolute power of homology to group topologically similar spaces, and therefore neural networks with topologically similar decision regions.
+
+Theorem 2.2 (Informal). Let $X$ and $Y$ be topological spaces. If $X \cong Y$ then $H ( X ) = H ( Y )$ . 4
+
+Intuitively, Theorem 2.2 states that number of ’holes’ (and in the case of $H _ { 0 } ( X )$ , connected components) are topologically invariant, and can be used to show that two shapes (or decision regions) are different.
+
+# 2.3 COMPUTATIONAL METHODS FOR HOMOLOGICAL COMPLEXITY
+
+In order to compute the homology of both $\mathcal { D } _ { 1 }$ and $\mathcal { D } _ { 2 }$ we needed to assume that they were actually the geometric shapes from which they were sampled. Without such assumptions, for any dataset $\mathcal { D }$ a $\mathbf { \bar { \theta } } _ { H ( \mathcal { D } ) } = \{ \mathbb { Z } ^ { N } , 0 , \dots \}$ where $N$ is the number of data points. This is because, at small enough scales each data point can be isolated as its own connected component; that is, as sets each pair of different positive points $d _ { 1 } , d _ { 2 } \in \mathcal { D }$ are disjoint. To properly utilize homological complexity in better understanding architecture selection, we need to be able to compute the homology of the data directly and still capture meaningful topological information.
+
+![](images/ce901e1ad962a6e99edd3134c0007ad15c149dea7da34314eecf1cd53b1f3396.jpg)  
+Figure 3: Left: The local disconnectedness of datasets prevents direct computation of their homology. Right: An illustration of computing persistent homology on a collection of points (Topaz et al. (2015))
+
+Persistent homology, introduced in Zomorodian & Carlsson (2005), avoids the trivialization of computation of dataset homology by providing an algorithm to calculate the homology of a filtration of a space. Specifically, a filtration is a topological space $X$ equipped with a sequence of subspaces $X _ { 0 } \subset X _ { 1 } \subset \cdots \subset X$ . In Figure 3 one such particular filtration is given by growing balls of size $\epsilon$ centered at each point, and then letting $X _ { \epsilon }$ be the resulting subspace in the filtration. Define $\beta _ { n } ( X )$ to be the nth Betti number of the homology $H ( X _ { \epsilon } )$ of $X _ { \epsilon }$ . Then for example at $\epsilon = 1 . 5$ , $\beta _ { 0 } ( X _ { \epsilon } ) = 1 9$ and $\beta _ { 1 } ( X _ { \epsilon } ) = 0$ as every ball is disjoint. At $\epsilon = 5 . 0$ some connected components merge and $\beta _ { 0 } ( X _ { \epsilon } ) = 1 2$ and $\beta _ { 1 } ( X _ { \epsilon } ) = 0$ . Finally at $\epsilon = 7$ , the union of the balls forms a hole towards the center of the dataset and $\beta _ { 1 } ( X _ { \epsilon } ) > 0$ with $\beta _ { 0 } ( X _ { \epsilon } ) = 4$ .
+
+All together the change in homology and therefore Betti numbers for $X _ { \epsilon }$ as $\epsilon$ changes can be summarized succinctly in the persistence barcode diagram given in Figure 3. Each bar in the section $\beta _ { n } ( X )$ denotes a ’hole’ of dimension $n$ . The left endpoint of the bar is the point at which homology detects that particular component, and the right endpoint is when that component becomes indistinguishable in the filtration. When calculating the persistent homology of datasets we will frequently use these diagrams.
+
+With the foregoing algorithms established, we are now equipped with the tools to study the capacity of neural networks in the language of algebraic topology.
+
+# 3 HOMOLOGICAL CHARACTERIZATION OF NEURAL ARCHITECTURES
+
+In the forthcoming section, we will apply persistent homology to emperically characterize the power of certain neural architectures. To understand why homological complexity is a powerful measure for differentiating architectures, we present the following principle.
+
+Suppose that $\mathcal { D }$ is some dataset drawn from a joint distribution $F$ with continuous CDF on some topological space $X \times \{ 0 , 1 \}$ . Let $X ^ { + }$ denote the support of the distribution of points with positive labels, and $X ^ { - }$ denote that of the points with negative labels. Then let $H _ { S } ( f ) \mathrel { \mathop : } = H [ f ^ { - 1 } ( \dot { ( 0 , \infty ) } ) ]$ denote the support homology of some function $f : X \to \{ 0 , 1 \}$ . Essentially $H _ { S } ( f )$ is homology of the set of $x$ such that $f ( x ) > 0$ . For a binary classifier, $f$ , $H _ { S } ( f )$ is roughly a characterization of how many ’holes’ are in the positive decision region of $f$ . We will sometimes use $\beta _ { n } ( f )$ to denote the $n$ th Betti number of this support homology. Finally let ${ \mathcal { F } } = \{ f : X \to \{ 0 , 1 \} \}$ be some family of binary classifiers on $X$ .
+
+Theorem 3.1 (The Homological Principle of Generalization). If $X = X ^ { - } \sqcup X ^ { + }$ and for all $f \in { \mathcal { F } }$ with $H _ { S } ( f ) \neq H ( X ^ { + } )$ , then for all $f \in { \mathcal { F } }$ there exists $A \subset X ^ { + }$ so $f$ misclassifies every $x \in A$ .
+
+Essential Theorem 3.1 says that if an architecture (a family of models $\mathcal { F }$ ) is incapable of producing a certain homological complexity, then for any model using that architecture there will always be a set $A$ of true data points on which the model will fail. Note that the above principle holds regardless of how $f \in { \mathcal { F } }$ is attained, learned or otherwise. However, the principle does imply that no matter how well some $\mathcal { F }$ learns to correctly classify $\mathcal { D }$ there will always be a counter examples in the true data.
+
+In the context of architecture selection, the foregoing minimality condition significantly reduces the size of the search space by eliminating smaller architectures which cannot even express the ’holes’ (persistent homology) of the data $H ( \mathcal D )$ . This allows us to return to our original question of finding suitably expressive and generalizeable architectures but in the very computable language of homological complexity: Let ${ \mathcal { F } } _ { A }$ the set of all neural networks with ’architecture’ $A$ , then
+
+Given a dataset $\mathcal { D }$ , for which architectures $A$ does there exist a neural network $f \in { \mathcal { F } } _ { A }$ such that $H _ { S } ( f ) = H ( \mathcal { D } )$ ?
+
+We will resurface a contemporary theoretical view on this question, and thereafter make the first steps towards an emperical characterization of the capacity of neural architectures in the view of topology.
+
+# 3.1 THEORETICAL BASIS FOR NEURAL HOMOLOGY
+
+Theoretically, the homological complexity of neural network can be framed in terms of the sum of the number of holes expressible by certain architectures. In particular, Bianchini et al. (2014) gives an analysis of how the maximum sum of Betti numbers grows as ${ \mathcal { F } } _ { A }$ changes. The results, summarized in Table 1, show that the width, depth, and activation of a fully connected architecture effect its topological expressivity to varying polynomial and exponential degrees. What is unclear from this analysis is how these bounds describe expressivity in terms of individual Betti numbers. For example, with a tanh activation function, $n$ inputs, $\ell$ layers, and $h$ hidden units, there is no description of what the number of connected components $\operatorname* { m a x } _ { f \in { \mathcal { F } } _ { A } } \beta _ { 0 } ( f )$ or 1-dimensional holes $\operatorname* { m a x } _ { f \in { \mathcal { F } } _ { A } } { \beta _ { 1 } ( f ) }$ actually is. With regards to tighter bounds Bianchini et al. (2014) stipulate that improvements to their results are deeply tied to several unsolved problems in algebraic topology.
+
+Table 1: Upper bounds on homological expressivity of neural architectures (Bianchini et al. (2014).)   
+
+<table><tr><td colspan="4">Architecture A</td><td>maxfeFA∑=1 βk（f）</td></tr><tr><td></td><td>Inputs Layers Units</td><td></td><td>Activation</td><td></td></tr><tr><td>n</td><td>3</td><td>h</td><td>threshold</td><td>O(hn)</td></tr><tr><td>n</td><td>3</td><td>h</td><td>arctan</td><td>O((n + h)n+2)</td></tr><tr><td>n</td><td>3</td><td>h</td><td>polynomial, deg. r</td><td>1(2+r)(1+r)n-1</td></tr><tr><td>1</td><td>3</td><td>h</td><td>arctan</td><td>h</td></tr><tr><td>n</td><td>l</td><td>h</td><td>arctan</td><td>2h(2h-1)O(nl + n)n+2h)</td></tr><tr><td>n</td><td>l</td><td>h</td><td>tanh</td><td>2h(h-1)/20(nl + n)n+h)</td></tr><tr><td>n</td><td>l</td><td>h</td><td>polynomial, deg. r</td><td>1(2+r)(1+r)n-1)</td></tr></table>
+
+![](images/c46bee0ab369538b1d7704c20d9dd3698824ca588addc9699d3cef8b27d074a4.jpg)  
+Figure 4: Topological phase transitions in low dimensional neural networks as the homological complexity of the data increases. The upper right corner of each plot is a dataset on which the neural networks of increasing hidden dimension are trained.
+
+# 3.2 EMPIRICAL RESULTS
+
+To understand how the homology of data determines expressive architectures we turn to an empirical characterization of neural networks. In this setting, we can tighten the bounds given in Table 1 by training different architectures on datasets with known homologies and then recording the decision regions observed over the course of training.
+
+# 3.2.1 HOMOLOGICAL CAPACITY OF HIDDEN UNITS.
+
+In the most basic case, one is interested in studying how the number of hidden units in a single hidden layer neural network affect its homological capacity. The results of Bianchini et al. (2014) say for certain activation functions we should expect a polynomial dependence on the sum of Betti numbers $\sum \beta _ { n }$ , but is this true of individual numbers? Having an individual characterization would allow for architecture selection by computing the homology of the dataset, and then finding which architectures meet the minimal criterion for each Betti number $\beta _ { n }$ .
+
+Restricting5 our analysis to the case of two inputs, $n = 2$ , we characterize the capacities of architectures with an increasing number of hidden units to learn on datasets with homological complexities ranging from $\{ \mathbb { Z } ^ { 1 } , 0 \}$ to $\{ \mathbb { Z } ^ { 2 0 } , \mathbb { Z } ^ { 2 0 } \}$ . In our experiment, we generate datasets of each particular homological complexity by sampling different combinations of balls, rings, and scaling, twisting, and gluing them at random. After generating the foregoing datasets with $N \approx 9 0 0 0 0$ samples we train 100 randomly (truncated normal) initialized single hidden layer architectures with hidden units $h \in \{ 1 , \ldots , 2 5 5 \}$ and tanh activation functions for $\mathrm { \bar { 1 0 ^ { 6 } } }$ minibatches of size 128. During training, every 2500 batches we sample the decision boundary of each neural network over a grid of $5 0 0 \times 5 0 0$ samples, producing $1 . 0 2 \times 1 \bar { 0 } ^ { 6 }$ recorded decision boundaries. Using the resulting data, we not only characterize different architectures but observed interesting topological phenomena during learning.
+
+![](images/df13f063452a7b093c38f4d767e507e5d0d5e3997ffa5161525ec22388e7d060.jpg)  
+Figure 5: Several different views of the probability of converging to zero-error for single hidden layer neural networks on datasets with different homological complexities.
+
+![](images/6b67d6c291699926908cc5543af035d5f293fcf22c21ea6c21611262e372bc58.jpg)  
+Figure 6: An example of topological stratification for single hidden layer networks. (a) The number of connected components in the decision regions during training. (b) Correlation of Betti numbers.
+
+First, neural networks exhibit a statistically significant topological phase transition in their convergence which depends directly on the homological complexity of the data. For any dataset in the experiment and any random homeomorphism applied thereto, the best test error of architectures with $h$ hidden units is strictly ordered in magnitude and convergence time for $h < h _ { p h a s e }$ where $h _ { p h a s e }$ is a number of hidden units required to express the homology of the data. In Figure 4 we plot the best performing test error of architectures $h \in \{ 1 , \ldots , 1 5 \}$ on some example datasets $\mathcal { D } _ { 0 } , \mathcal { D } _ { 1 }$ , and $\mathcal { D } _ { 2 }$ with $H ( \tilde { \mathcal { D } _ { 0 } } ) \approx \{ \mathbb { Z } ^ { 2 } , 0 \}$ , $H ( \mathcal { D } _ { 1 } ) \approx \{ \mathbb { Z } ^ { 3 } , 0 \}$ , $H ( \mathcal { D } _ { 2 } ) \overset { \cdot } { \approx } \{ \mathbb Z ^ { 3 } , \mathbb Z ^ { 2 } \}$ . In this example $h _ { p h a s e } ( \mathcal { D } _ { 0 } ) = 4 , h _ { p h a s e } ( \mathcal { D } _ { 1 } ) = 6$ , and $h _ { p h a s e } ( \mathcal { D } _ { 2 } ) = 1 0$ . Surprisingly, leading up to the phase transition point, each different architecture falls into its own band of optimal convergence. This suggests that additional hidden units do in fact add to the topological capacity of an architecture in a consistent way.
+
+Using topological phase transitions we now return to the original question of existence of expressive architectures. In Figure 5, we accumulate the probabilities that neural networks of varying hidden dimension train to zero-error on datasets of different homological complexities. The table gives different views into how expressive an architecture need be in order to converge, and therefore we are able to conjecture tighter bounds on the capacity of hidden units. Extrapolating from the first view, if $H _ { 0 } ( \mathcal { D } ) = \mathbb { Z } ^ { m }$ then there exists a single hidden layer neural network with $h = m + 2$ that converges to zero error on $\mathcal { D }$ . Likewise we claim that if $H _ { 0 } ( \mathcal { D } ) = \mathbb { Z } ^ { m }$ and $H _ { 1 } ( \mathcal { D } ) = 1$ then the same holds with $h \geq 3 m - 1$ . Further empirical analysis of convergence probabilities yields additional conjectures. However, claiming converse conjectures about a failure to generalize in the view of Theorem 3.1 requires exhaustive computation of decision boundary homologies.
+
+By applying persistent homology to the decision boundaries of certain networks during training, we observe that given sufficient data, neural networks exhibit topological stratification. For example, consider the homologies of different architecture decision regions as training progresses in Figure 6(a). At the beginning of training every model captures the global topological information of the dataset and is homologically correlated with one another. However as training continues, the architectures stratify into two groups with homological complexities ordered by the capacities of the models. In this example, $h _ { 3 } , h _ { 4 }$ , and $h _ { 5 }$ are unable to express as many holes as the other architectures and so never specialize to more complex and local topological properties of the data. Figure 6(b) depicts topological stratification in terms of the correlation between Betti numbers. Topologically speaking, networks with less than 6 hidden units are distinct from those with more for most of training. Furthermore, this correlative view shows that stratification is consistent with topological phase transition; that is, across all decision boundary homologies recorded during the experiment stratification occurs just when the number of hidden units is slightly less than $h _ { p h a s e }$ .
+
+# 4 THE TOPOLOGY OF REAL DATA
+
+We have thus far demonstrated the discriminatory power of homological complexity in determining the expressivity of architectures. However, for homological complexity to have any practical use in architecture selection, it must be computable on real data, and more generally real data must have non-trivial homology; if all data were topologically simple our characterization would have no predictive power. In the following section we will compute the persistent homologies up to dimension 2 of different real world datasets.
+
+![](images/f6d31e598d183daf15b5a69fa794ca5d0b0151956341748e6c2824d4c467ca63.jpg)  
+Figure 7: The persistent homology barcodes of classes in the CIFAR-10 and UCI Protein Localization Datasets. Left: The bardcode for dimension 0 and 1 of the ’CYT’ class along side its local linear embedding into $\mathbb { R } ^ { 2 }$ . Right: The barcode for the dimensions 0 and 1 for the ’cars’ class along side different samples thereof in CIFAR-10. Note how different orientations are shown.
+
+CIFAR-10. We compute the persistent homology of several classes of CIFAR-10 using the Python library Dionysus. Currently algorithms for persistent homology do not deal well with high dimensional data, so we embed the entire dataset in $\mathbb { R } ^ { 3 }$ using local linear embedding (LLE; Saul & Roweis (2000)) with $K = 1 2 0$ neighbors. After embedding the dataset, we take a sample of 1000 points from example class ’car’ and build a persistent filtration by constructing a Vietoris-Rips complex on the data. The resulting complex has 20833750 simplices and took $4 . 3 \mathrm { { m i n } }$ . to generate. Finally, computation of the persistence diagram shown in Figure 7 took $8 . 4 \mathrm { { m i n } }$ . locked to a single thread on a Intel Core i7 processor. The one-time cost of computing persistent homology could easily augment any neural architecture search.
+
+Although we only give an analysis of dimension 2 topological features–and there is certainly higher dimensional homological information in CIFAR-10–the persistence barcode diagram is rich with different components in both $H _ { 0 } ( \mathcal { D } )$ and $H _ { 1 } ( \mathcal { D } )$ . Intuitively, CIFAR contains pictures of cars rotated accross a range of different orientations and this is exhibited in the homology. In particular, several holes are born and die in the range $\epsilon \in [ 0 . 1 5 , 0 . 3 7 5 ]$ and one large loop from $\epsilon \in [ 0 . 6 2 5 , 0 . 8 2 ]$ .
+
+UCI Datasets. We further compute the homology of three low dimensional UCI datasets and attempt to assert the of non-trivial , $h _ { p h a s e }$ . Specifically, we compute the persistent homology of the majority classes in the Yeast Protein Localization Sites, UCI Ecoli Protein Localization Sites, and HTRU2 datasets. For these datasets no dimensionality reduction was used. In Figure 7(left), the persistence barcode exhibits two seperate significant loops (holes) at $\epsilon \in [ 0 . 1 9 , 0 . 3 1 ]$ and $\epsilon \in [ 0 . 7 6 , 0 . 8 5 ]$ , as well as two major connected components in $\beta _ { 0 } ( \mathcal { D } )$ . The Other persistence diagrams are relegated to the appendix.
+
+Existing Data. Outside of the primary machine learning literature, topological data analysis yields non-trivial computations in wide variety of fields and datasets. Of particular interest is the work of Carlsson et al. (2008), which computes the homological complexity of collections of $n \times n$ patches of natural images. Even in these simple collections of images, the authors found topologies of Klein Bottles $( \mathbf { \bar { \cal H } } ( \cdot ) = \{ \mathbb { Z } , \mathbb { Z } ^ { 2 } / 2 \mathbb { Z } , 0 \ldots \} )$ and other exotic topological objects. Other authors have calculated non-trivial dataset homologies in biological (Topaz et al. (2015)), natural language (Michel et al. (2017)), and other domains (Wu et al. (2017), Xia & Wei (2014)).
+
+# 5 RELATED WORK
+
+We will place this work in the context of deep learning theory as it relates to expressivity. Since the seminal work of Cybenko (1989) which established standard universal approximation results for neural networks, many theorists have endeavored to understand the expressivity of certain neural architectures. Pascanu et al. (2013) and MacKay (2003) provided the first analysis relating the depth and width of architectures to the complexitity of the sublevel sets they can express. Motivated therefrom, Bianchini et al. (2014) expressed this theme in the language of Pfefferian functions, thereby bounding the sum of Betti numbers expressed by sublevel sets. Finally Guss (2016) gave an account of how topological assumptions on the input data lead to optimally expressive architectures. In parallel, Eldan & Shamir (2016) presented the first analytical minimality result in expressivity theory; that is, the authors show that there are simple functions that cannot be expressed by two layer neural networks with out exponential dependence on input dimension. This work spurred the work ofPoole et al. (2016), Raghu et al. (2016) which reframed expressivity in a differential geometric lense.
+
+Our work presents the first method to derive expressivity results empirically. Our topological viewpoint sits dually with its differential geometric counterpart, and in conjunction with the work of Poole et al. (2016) and Bianchini et al. (2014), this duallity implies that when topological expression is not possible, exponential differential expressivity allows networks to bypass homological constaints at the cost of adversarial sets. Furthermore, our work opens a practical connectio nbetween the foregoing theory on neural expressivity and architecture selection, with the potential to drastically improve neural architecture search (Zoph & Le (2017)) by directly computing the capacities of different architectures.
+
+# 6 CONCLUSION
+
+Architectural power is deeply related to the algebraic topology of decision boundaries. In this work we distilled neural network expressivity into an empirical question of the generalization capabilities of architectures with respect to the homological complexity of learning problems. This view allowed us to provide an empirical method for developing tighter characterizations on the the capacity of different architectures in addition to a principled approach to guiding architecture selection by computation of persistent homology on real data.
+
+There are several potential avenues of future research in using homological complexity to better understand neural architectures. First, a full characterization of neural networks with many layers or convolutional linearities is a crucial next step. Our empirical results suggest that the their are exact formulas describing the of power of neural networks to express decision boundaries with certain properties. Future theoretical work in determining these forms would significantly increase the efficiency and power of neural architecture search, constraining the search space by the persistent homology of the data. Additionally, we intend on studying how the topological complexity of data changes as it is propagated through deeper architectures.
+
+# REFERENCES
+
+E Betti. Il nuovo cimento. Series, 2:7, 1872.
+
+Monica Bianchini et al. On the complexity of shallow and deep neural network classifiers. In ESANN, 2014.
+
+Glen E Bredon. Topology and geometry, volume 139. Springer Science & Business Media, 2013.
+
+Gunnar Carlsson, Tigran Ishkhanov, Vin De Silva, and Afra Zomorodian. On the local behavior of spaces of natural images. International journal of computer vision, 76(1):1–12, 2008.
+
+Frédéric Chazal, Brittany Fasy, Fabrizio Lecci, Bertrand Michel, Alessandro Rinaldo, and Larry Wasserman. Subsampling methods for persistent homology. In Proceedings of the 32nd International Conference on Machine Learning (ICML-15), pp. 2143–2151, 2015.
+
+George Cybenko. Approximation by superpositions of a sigmoidal function. Mathematics of Control, Signals, and Systems (MCSS), 2(4):303–314, 1989.
+
+Amit Daniely, Roy Frostig, and Yoram Singer. Toward deeper understanding of neural networks: The power of initialization and a dual view on expressivity. In Advances In Neural Information Processing Systems, pp. 2253–2261, 2016.
+
+TK Dey, H Edelsbrunner, and S Guha. Computational topology, invited paper in advances in discrete and computational geometry, eds. b. chazelle, je goodmann and r. pollack. Contemporary Mathematics, AMS, 1998.
+
+Ronen Eldan and Ohad Shamir. The power of depth for feedforward neural networks. In Conference on Learning Theory, pp. 907–940, 2016.
+
+Chrisantha Fernando, Dylan Banarse, Charles Blundell, Yori Zwols, David Ha, Andrei A. Rusu, Alexander Pritzel, and Daan Wierstra. Pathnet: Evolution channels gradient descent in super neural networks. CoRR, abs/1701.08734, 2017. URL http://arxiv.org/abs/1701.08734.
+
+Ian Goodfellow, Yoshua Bengio, and Aaron Courville. Deep Learning. MIT Press, 2016. http: //www.deeplearningbook.org.
+
+William H Guss. Deep function machines: Generalized neural networks for topological layer expression. arXiv preprint arXiv:1612.04799, 2016.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. CoRR, abs/1512.03385, 2015. URL http://arxiv.org/abs/1512.03385.
+
+Geoffrey Hinton, Li Deng, Dong Yu, George E Dahl, Abdel-rahman Mohamed, Navdeep Jaitly, Andrew Senior, Vincent Vanhoucke, Patrick Nguyen, Tara N Sainath, et al. Deep neural networks for acoustic modeling in speech recognition: The shared views of four research groups. IEEE Signal Processing Magazine, 29(6):82–97, 2012.
+
+Yasuyuki Kato, Daisuke Yamamoto, and Ippei Danshita. Quantum tricriticality at the superfluidinsulator transition of binary bose mixtures. Phys. Rev. Lett., 112:055301, Feb 2014. doi: 10.1103/PhysRevLett.112.055301. URL https://link.aps.org/doi/10.1103/ PhysRevLett.112.055301.
+
+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.
+
+David JC MacKay. Information theory, inference and learning algorithms. Cambridge university press, 2003.
+
+Paul Michel, Abhilasha Ravichander, and Shruti Rijhwani. Does the geometry of word embeddings help document classification? a case study on persistent homology based representations. arXiv preprint arXiv:1705.10900, 2017.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Alex Graves, Ioannis Antonoglou, Daan Wierstra, and Martin Riedmiller. Playing atari with deep reinforcement learning. arXiv preprint arXiv:1312.5602, 2013.
+
+Razvan Pascanu, Guido Montufar, and Yoshua Bengio. On the number of response regions of deep feed forward networks with piece-wise linear activations. arXiv preprint arXiv:1312.6098, 2013.
+
+Ben Poole, Subhaneil Lahiri, Maithreyi Raghu, Jascha Sohl-Dickstein, and Surya Ganguli. Exponential expressivity in deep neural networks through transient chaos. In Advances In Neural Information Processing Systems, pp. 3360–3368, 2016.
+
+Maithra Raghu, Ben Poole, Jon Kleinberg, Surya Ganguli, and Jascha Sohl-Dickstein. On the expressive power of deep neural networks. arXiv preprint arXiv:1606.05336, 2016.
+
+Lawrence K Saul and Sam T Roweis. An introduction to locally linear embedding. unpublished. Available at: http://www. cs. toronto. edu/˜ roweis/lle/publications. html, 2000.
+
+Shreyas Saxena and Jakob Verbeek. Convolutional neural fabrics. CoRR, abs/1606.02492, 2016. URL http://arxiv.org/abs/1606.02492.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. CoRR, abs/1409.1556, 2014. URL http://arxiv.org/abs/1409.1556.
+
+Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott E. Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. CoRR, abs/1409.4842, 2014. URL http://arxiv.org/abs/1409.4842.
+
+Chad M Topaz, Lori Ziegelmeier, and Tom Halverson. Topological data analysis of biological aggregation models. PloS one, 10(5):e0126383, 2015.
+
+Yonghui Wu, Mike Schuster, Zhifeng Chen, Quoc V Le, Mohammad Norouzi, Wolfgang Macherey, Maxim Krikun, Yuan Cao, Qin Gao, Klaus Macherey, et al. Google’s neural machine translation system: Bridging the gap between human and machine translation. arXiv preprint arXiv:1609.08144, 2016.
+
+Yu Wu, Gabriel Shindnes, Vaibhav Karve, Derrek Yager, Daniel B Work, Arnab Chakraborty, and Richard B Sowers. Congestion barcodes: Exploring the topology of urban congestion using persistent homology. arXiv preprint arXiv:1707.08557, 2017.
+
+Kelin Xia and Guo-Wei Wei. Persistent homology analysis of protein structure, flexibility, and folding. International journal for numerical methods in biomedical engineering, 30(8):814–844, 2014.
+
+Afra Zomorodian and Gunnar Carlsson. Computing persistent homology. Discrete & Computational Geometry, 33(2):249–274, 2005.
+
+Barret Zoph and Quoc V. Le. Neural architecture search with reinforcement learning. 2017. URL https://arxiv.org/abs/1611.01578.
+
+# A PROOFS, CONJECTURES, AND FORMAL DEFINITIONS
+
+# A.1 HOMOLOGY
+
+Homology is naturally described using the language of category theory. Let $T o p ^ { 2 }$ denote the category of topological spaces and $A b$ the category of abelian groups.
+
+Definition A.1 (Homology Theory, Bredon (2013)). A homology theory on the on $T o p ^ { 2 }$ is a function $H : T o p ^ { 2 }  A b$ assigning to each pair $( X , A )$ of spaces a graded (abelian) group $\{ H _ { p } ( X , A ) \}$ , and to each map $f : ( X , A ) \to ( Y , B )$ , homomorphisms $f _ { * } : H _ { p } ( X , A ) \to H _ { p } ( Y , B )$ , together with a natural transformation of functors $\partial _ { * } : H _ { p } ( X , A ) \to H _ { p - 1 } ( X , A )$ , called the connecting homomorphism (where we use $H _ { * } ( A )$ to denote $H _ { * } ( A , \varnothing )$ ) such that the following five axioms are satisfied.
+
+1. If $f \simeq g : ( X , A )  ( Y , B )$ then $f _ { * } = g _ { * } : H _ { * } ( X , A ) \to H _ { * } ( Y , B ) .$
+
+2. For the inclusions $i : A \to X$ and $j : X \to ( X , A )$ the sequence sequence of inclusions and connecting homomorphisms are exact.
+
+3. Given the pair $( X , A )$ and an open set $U \subset X$ such that $c l ( U ) \subset i n t ( A )$ then the inclusion $k : ( X - U , A - U ) \to ( X , A )$ induces an isomorphism $k _ { * } : H _ { * } ( X - U , A - U ) \to$ $H _ { * } ( X , A )$
+
+4. For a one point space $P , H _ { i } ( P ) = 0$ for all $i \neq 0$ .
+
+5. For a topological sum $X = + _ { \alpha } X _ { \alpha }$ the homomorphism
+
+$$
+\bigoplus ( i _ { \alpha } ) _ { * } : \bigoplus H _ { n } ( X _ { \alpha } ) \to H _ { n } ( X )
+$$
+
+is an isomorphism, where $i _ { \alpha } : X _ { \alpha } \to X$ is the inclusion.
+
+For related definitions and requisite notions we refer the reader to Bredon (2013).
+
+# A.2 PROOF OF THEOREM 3.1
+
+Theorem A.2. Let $X$ be a topological space and $X ^ { + }$ be some open subspace. If ${ \mathcal { F } } \subset 2 ^ { X }$ such that $f \in { \mathcal { F } }$ implies $H _ { S } ( f ) \neq H ( \bar { X } ^ { + } )$ , then for all $f \in { \mathcal { F } }$ there exists $A \subset X$ so that $f ( A \cap X ^ { + } ) = \{ 0 \}$ and $f ( A \cap ( X \setminus X ^ { + } ) ) = \{ 1 \}$ .
+
+Proof. Suppose the for the sake of contraiction that for all $f \in { \mathcal { F } }$ , $H _ { S } ( f ) \ne H ( X ^ { + } )$ and yet there exists an $f$ such that for all $A \subset X$ , there exists an $x \in A$ such that $f ( x ) = 1$ . Then take $\mathcal { A } = \{ x \} _ { x \in X }$ , and note that $f$ maps each singleton into its proper partition on $X$ . We have that for any open subset of $V \subset X ^ { + }$ , $f ( \bar { V } ) = \{ 1 \}$ , and for any closed subset $W \subset X \setminus X ^ { + }$ , $f ( W ) = \{ 0 \}$ . Therefore X+ = SA∈τX+∩X $X ^ { + } = \textstyle \bigcup _ { A \in \tau _ { X ^ { + } \cap X } } A \subset s u p p ( f )$ as the subspace topology $\tau _ { X ^ { + } \cap X } = \tau _ { X ^ { + } } \cap \tau _ { X }$ where $\tau _ { X ^ { + } } = \{ A \in \tau _ { X } | A \subset { \dot { X } } ^ { + } \}$ and $\tau _ { X }$ denotes the topology of $X$ . Likewise, $i n t ( X ^ { - } ) \subset X \backslash s u p p ( F )$ under the same logic. Therefore $s u p p ( f )$ has the exact same topology as $X ^ { + }$ and so by Theorem 2.2 $H ( X ^ { + } ) = H ( s u \bar { p } p ( f ) )$ but this is a contradiction. This completes the proof. □
+
+# A.3 THE NEURAL HOMOLOGY PRINCIPLE
+
+Conjecture A.3. If $N$ is some neural network with $\ell$ layers and $h$ hidden units, and $H _ { S } ( N ) \neq$ $H ( X ^ { + } )$ then $\mathbb { E } [ L ( \mathrm { \bar { N } } , \mathcal { D } ) ] > c$ for some fixed $c ( \ell , h ) > 0$ .
+
+![](images/77273b4d16c2680ef1cc2134a32082dcba78d3d14d189be37b108b3e092f2d46.jpg)  
+Figure 8: Topological phase transitions for datasets with $\beta ( \mathcal { D } ) \in \{ ( 2 , 0 ) , ( 2 , 1 ) , ( 3 , 0 ) , ( 3 , 1 ) \}$
+
+![](images/e27383b283d68b6c0607704c6df459226986a6e81af9c11222a9210c8e749b94.jpg)  
+Figure 9: Topological phase transitions for datasets with $\beta ( \mathcal { D } ) \in \{ ( 3 , 2 ) , ( 4 , 0 ) , ( 4 , 1 ) , ( 4 , 2 ) \}$
+
+![](images/7ea7091547b0d613980c98d1bc1a7e62068f7eb5fbe42da2343373e874b7ac9d.jpg)  
+Figure 10: Topological phase transitions for datasets with $\beta ( \mathcal { D } ) \in \{ ( 4 , 3 ) , ( 5 , 0 ) \}$
+
+# C EXAMPLE TOPOLOGICAL STRATIFICATIONS
+
+![](images/8a2ae195ba397629afe30da13627f735fddf56b3439dbaa5fca35732f4717701.jpg)  
+Figure 11: Topological stratification for $\{ h _ { 3 } , . . . , h _ { 1 5 } \}$ on a random dataset $\mathcal { D }$ with $\beta _ { 0 } ( \mathcal { D } ) = 2 5$ , $\beta _ { 1 } ( \mathcal { D } ) = 1 6$ .
+
+![](images/75ed16e4c46d1ef4418f9175de2547afc1090f8f9612b1bc15e53dbf6e7aa384.jpg)  
+Figure 12: Topological stratification for $\{ h _ { 1 } , \ldots , h _ { 5 } \}$ on a random dataset $\mathcal { D }$ with $\beta _ { 0 } ( \mathcal { D } ) = 3$ , $\beta _ { 1 } \mathsf { \bar { ( } } D ) = 0$ .
+
+![](images/4ff6976e387af4a2dd76433cd7b86100763aeac8828b4749dbf98cef8c31501f.jpg)  
+Figure 13: Topological stratification for $\{ h _ { 3 } , \ldots , h _ { 7 } \}$ on a random dataset $\mathcal { D }$ with $\beta _ { 0 } ( \mathcal { D } ) = 3$ , $\beta _ { 1 } ( \mathcal { D } ) = 0$ .
+
+D ADDITIONAL TOPOLOGY OF REAL DATA
+
+![](images/1ecf1eca77077c1a6148f2224eda13a3d65cf665230e2c3dde6515a73b7b7e6b.jpg)  
+Figure 14: The persistence diagrams of other data.
+
+![](images/81b346f8954e4988c73cd34fff398e0ddeef9837b79107fd94f7fba420f7ed86.jpg)

parse/train/H11lAfbCW/H11lAfbCW_content_list.json

@@ -0,0 +1,1540 @@
+[
+    {
+        "type": "text",
+        "text": "ON CHARACTERIZING THE CAPACITY OF NEURAL NETWORKS USING ALGEBRAIC TOPOLOGY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            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": "The learnability of different neural architectures can be characterized directly by computable measures of data complexity. In this paper, we reframe the problem of architecture selection as understanding how data determines the most expressive and generalizable architectures suited to that data, beyond inductive bias. After suggesting algebraic topology as a measure for data complexity, we show that the power of a network to express the topological complexity of a dataset in its decision boundary is a strictly limiting factor in its ability to generalize. We then provide the first empirical characterization of the topological capacity of neural networks. Our empirical analysis shows that at every level of dataset complexity, neural networks exhibit topological phase transitions and stratification. This observation allowed us to connect existing theory to empirically driven conjectures on the choice of architectures for a single hidden layer neural networks. ",
+        "bbox": [
+            233,
+            268,
+            766,
+            434
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            465,
+            336,
+            482
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep learning has rapidly become one of the most pervasively applied techniques in machine learning. From computer vision (Krizhevsky et al. (2012)) and reinforcement learning (Mnih et al. (2013)) to natural language processing (Wu et al. (2016)) and speech recognition (Hinton et al. (2012)), the core principles of hierarchical representation and optimization central to deep learning have revolutionized the state of the art; see Goodfellow et al. (2016). In each domain, a major difficulty lies in selecting the architectures of models that most optimally take advantage of structure in the data. In computer vision, for example, a large body of work (Simonyan & Zisserman (2014), Szegedy et al. (2014), He et al. (2015), etc.) focuses on improving the initial architectural choices of Krizhevsky et al. (2012) by developing novel network topologies and optimization schemes specific to vision tasks. Despite the success of this approach, there are still not general principles for choosing architectures in arbitrary settings, and in order for deep learning to scale efficiently to new problems and domains without expert architecture designers, the problem of architecture selection must be better understood. ",
+        "bbox": [
+            174,
+            498,
+            825,
+            665
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Theoretically, substantial analysis has explored how various properties of neural networks, (eg. the depth, width, and connectivity) relate to their expressivity and generalization capability (Raghu et al. (2016), Daniely et al. (2016), Guss (2016)). However, the foregoing theory can only be used to determine an architecture in practice if it is understood how expressive a model need be in order to solve a problem. On the other hand, neural architecture search (NAS) views architecture selection as a compositional hyperparameter search (Saxena & Verbeek (2016), Fernando et al. (2017), Zoph & Le (2017)). As a result NAS ideally yields expressive and powerful architectures, but it is often difficult to interperate the resulting architectures beyond justifying their use from their emperical optimality. ",
+        "bbox": [
+            173,
+            672,
+            825,
+            797
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We propose a third alternative to the foregoing: data-first architecture selection. In practice, experts design architectures with some inductive bias about the data, and more generally, like any hyperparameter selection problem, the most expressive neural architectures for learning on a particular dataset are solely determined by the nature of the true data distribution. Therefore, architecture selection can be rephrased as follows: given a learning problem (some dataset), which architectures are suitably regularized and expressive enough to learn and generalize on that problem? ",
+        "bbox": [
+            174,
+            805,
+            825,
+            888
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A natural approach to this question is to develop some objective measure of data complexity, and then characterize neural architectures by their ability to learn subject to that complexity. Then given some new dataset, the problem of architecture selection is distilled to computing the data complexity and chosing the appropriate architecture. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/8aae215ebe2d7d9a8b91538c0c83f5fdacb92abfe99dfca7d96ab030eab0ed2a.jpg",
+        "image_caption": [
+            "Figure 1: The positive label outptus of single hidden layer neural networks, $h _ { 1 2 }$ and $h _ { 2 6 }$ , of 2 inputs with 12 and 26 hidden units respectively after training on datasets $\\mathcal { D } _ { 1 }$ and $\\mathcal { D } _ { 2 }$ with positive examples in red. Highlighted regions of the output constitute the positive decision region. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            101,
+            805,
+            272
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            353,
+            823,
+            381
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "For example, take the two datasets $\\mathcal { D } _ { 1 }$ and $\\mathcal { D } _ { 2 }$ given in Figure 1(ab) and Figure 1(cd) respectively. The first dataset, $\\mathcal { D } _ { 1 }$ , consists of positive examples sampled from two disks and negative examples from their compliment. On the right, dataset $\\mathcal { D } _ { 2 }$ consists of positive points sampled from two disks and two rings with hollow centers. Under some geometric measure of complexity $\\mathcal { D } _ { 2 }$ appears more ’complicated’ than $\\mathcal { D } _ { 1 }$ because it contains more holes and clusters. As one trains single layer neural networks of increasing hidden dimension on both datasets, the minimum number of hidden units required to achieve zero testing error is ordered according to this geometric complexity. Visually in Figure 1, regardless of initialization no single hidden layer neural network with $\\leq 1 2$ units, denoted $h _ { \\leq 1 2 }$ , can express the two holes and clusters in $\\mathcal { D } _ { 2 }$ . Whereas on the simpler $\\mathcal { D } _ { 1 }$ , both $h _ { 1 2 }$ and $h _ { 2 6 }$ can express the decision boundary perfectly. Returning to architecture selection, one wonders if this characterization can be extrapolated; that is, is it true that for datasets with ’similar’ geometric complexity to $\\mathcal { D } _ { 1 }$ , any architecture with $\\geq 1 2$ hidden learns perfectly, and likewise for those datasets similar in complexity to $\\mathcal { D } _ { 2 }$ , architectures with $\\leq 1 2$ hidden units can never learn to completion? ",
+        "bbox": [
+            173,
+            388,
+            825,
+            569
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1.1 OUR CONTRIBUTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            588,
+            361,
+            602
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we formalize the above of geometric complexity in the language of algebraic topology. We show that questions of architecture selection can be answered by understanding the ’topological capacity’ of different neural networks. In particular, a geometric complexity measure, called persistent homology, characterizes the capacity of neural architectures in direct relation to their ability to generalize on data. Using persistent homology, we develop a method which gives the first empirical insight into the learnability of different architectures as data complexity increases. In addition, our method allows us to generate conjectures which tighten known theoretical bounds on the expressivity of neural networks. Finally, we show that topological characterizations of architectures are possible and useful for architecture selection in practice by computing the persistent homology of CIFAR-10 and several UCI datasets. ",
+        "bbox": [
+            174,
+            614,
+            825,
+            753
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 BACKGROUND ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            776,
+            326,
+            794
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 GENERAL TOPOLOGY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            810,
+            366,
+            824
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In order to more formally describe notions of geometric complexity in datasets, we will turn to the language of topology. Broadly speaking, topology is a branch of mathematics that deals with characterizing shapes, spaces, and sets by their connectivity. In the context of characterizing neural networks, we will work towards defining the topological complexity of a dataset in terms of how that dataset is ’connected’, and then group neural networks by their capacity to produce decision regions of the same connectivity. ",
+        "bbox": [
+            174,
+            837,
+            825,
+            921
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In topology, one understands the relationships between two different spaces of points by the continuous maps between them. Informally, we say that two topological spaces $A$ and $B$ are equivalent $A \\cong B$ ) if there is a continuous function $f : A  B$ that has an inverse $f ^ { - 1 }$ that is also continuous. When $f$ exists, we say that $A$ and $B$ are homeomorphic and $f$ is their homeomorphism; for a more detailed treatment of general topology see Bredon (2013). Take for example, the classic example of the coffee cup and the donut in ",
+        "bbox": [
+            174,
+            106,
+            522,
+            243
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/4d2f84897c4384afb308d50a4222dad3c9430d02d76ee479d364fa289dec173f.jpg",
+        "image_caption": [
+            "Figure 2: A continuous deformation of a coffee cup into a donut, showing that both are topologically equivalent (Kato et al. (2014)). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            560,
+            98,
+            800,
+            176
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Figure 2. They are homeomorphic because one can define a continuous deformation of one into the other which shrinks, twists, and morphs without tearing or gluing, as in Figure 2. Note that if the donut had two holes, it would no longer be equivalent to the mug. Likewise, in an informal way, $\\mathcal { D } _ { 1 } \\not \\cong \\mathcal { D } _ { 2 }$ in Figure 1 since if there were a homeomorphism $f : \\mathcal { D } _ { 1 }  \\mathcal { D } _ { 2 }$ at least one of the clusters in $\\mathcal { D } _ { 1 }$ would need to be split in order to produce the four different regions in $\\mathcal { D } _ { 2 }$ . ",
+        "bbox": [
+            174,
+            244,
+            825,
+            313
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The power of topology lies in its capacity to differentiate sets (topological spaces) in a meaningful geometric way that discards certain irrelevant properties such as rotation, translation, curvature, etc. For the purposes of defining geometric complexity, non-topological properties1 like curvature would further fine-tune architecture selection–say if $\\mathcal { D } _ { 2 }$ had the same regions but with squigly (differentially complex) boundaries, certain architectures might not converge–but as we will show, grouping neural networks by ’topological capacity’ provides a powerful minimality condition. That is, we will show that if a certain architecture is incapable of expressing a decision region that is equivalent in topology to training data, then there is no hope of it ever generalizing to the true data. ",
+        "bbox": [
+            174,
+            320,
+            825,
+            431
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 ALGEBRAIC TOPOLOGY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            455,
+            380,
+            469
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Algebraic topology provides the tools necessary to not only build the foregoing notion of topological equivalence into a measure of geometric complexity, but also to compute that measure on real data (Betti (1872), Dey et al. (1998), Bredon (2013)). At its core, algebraic topology takes topological spaces (shapes and sets with certain properties) and assigns them algebraic objects such as groups, chains, and other more exotic constructs. In doing so, two spaces can be shown to be topologically equivalent (or distinct) if the algebraic objects to which they are assigned are isomorphic (or not). Thus algebraic topology will allow us to compare the complexity of decision boundaries and datasets by the objects to which they are assigned. ",
+        "bbox": [
+            174,
+            483,
+            825,
+            595
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Although there are many flavors of algebraic topology, a powerful and computationally realizable tool is homology. ",
+        "bbox": [
+            174,
+            602,
+            823,
+            631
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Definition 2.1 (Informal, Bredon (2013)). If $X$ is a topological space, then $H _ { n } ( X ) = \\mathbb { Z } ^ { \\beta _ { n } }$ is called the nth homology group of $X$ if the power $\\beta _ { n }$ is the number of ’holes’ of dimension $n$ in $X$ . Note that $\\beta _ { 0 }$ is the number of separate connected components. We call $\\beta _ { n } ( X )$ the nth Betti number of $X$ . Finally, the homology2 of $X$ is defined as $H ( X ) = \\{ H _ { n } ( X ) \\} _ { n = 0 } ^ { \\infty }$ . ",
+        "bbox": [
+            174,
+            637,
+            825,
+            695
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Immediately homology brings us closer to defining the complexity of $\\mathcal { D } _ { 1 }$ and $\\mathcal { D } _ { 2 }$ . If we assume that $\\mathcal { D } _ { 1 }$ is not actually a collection of $N$ datapoints, but really the union of 2 solid balls, and likewise that $\\mathcal { D } _ { 2 }$ is the union of 2 solid balls and 2 rings, then we can compute the homology directly. In this case $H _ { 0 } ( \\mathcal { D } _ { 1 } ) = \\mathbb { Z } ^ { 2 }$ since there are two connected components3; $H _ { 1 } ( \\mathcal { D } _ { 1 } ) = \\{ 0 \\}$ since there are no circles (one-dimensional holes); and clearly, $H _ { n } ( \\mathcal { D } _ { 1 } ) = { \\overline { { \\{ 0 \\} } } }$ for $n \\geq 2$ . Performing the same computation in the second case, we get $H _ { 0 } ( \\mathcal { D } _ { 2 } ) = \\mathbb { Z } ^ { 4 }$ and $H _ { 1 } ( \\dot { \\mathcal { D } } _ { 2 } ) = \\mathbb { Z } ^ { 2 }$ as there are 4 seperate clusters and 2 rings/holes. With respect to any reasonable ordering on homology, $\\mathcal { D } _ { 2 }$ is more complex than $\\mathcal { D } _ { 1 }$ . The measure yields non-trivial differentiation of spaces in higher dimension. For example, the homology of a hollow donut is $\\{ \\mathbb { Z } ^ { 1 } , \\mathbb { Z } ^ { 2 } , \\mathbb { Z } ^ { 1 } , 0 , \\dots \\}$ . ",
+        "bbox": [
+            174,
+            708,
+            825,
+            835
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Surprisingly, the homology of a space contains a great deal of information about its topological complexity1. The following theorem suggests the absolute power of homology to group topologically similar spaces, and therefore neural networks with topologically similar decision regions. ",
+        "bbox": [
+            174,
+            104,
+            821,
+            147
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Theorem 2.2 (Informal). Let $X$ and $Y$ be topological spaces. If $X \\cong Y$ then $H ( X ) = H ( Y )$ . 4 ",
+        "bbox": [
+            171,
+            155,
+            802,
+            170
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Intuitively, Theorem 2.2 states that number of ’holes’ (and in the case of $H _ { 0 } ( X )$ , connected components) are topologically invariant, and can be used to show that two shapes (or decision regions) are different. ",
+        "bbox": [
+            174,
+            185,
+            825,
+            227
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.3 COMPUTATIONAL METHODS FOR HOMOLOGICAL COMPLEXITY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            253,
+            655,
+            268
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In order to compute the homology of both $\\mathcal { D } _ { 1 }$ and $\\mathcal { D } _ { 2 }$ we needed to assume that they were actually the geometric shapes from which they were sampled. Without such assumptions, for any dataset $\\mathcal { D }$ a $\\mathbf { \\bar { \\theta } } _ { H ( \\mathcal { D } ) } = \\{ \\mathbb { Z } ^ { N } , 0 , \\dots \\}$ where $N$ is the number of data points. This is because, at small enough scales each data point can be isolated as its own connected component; that is, as sets each pair of different positive points $d _ { 1 } , d _ { 2 } \\in \\mathcal { D }$ are disjoint. To properly utilize homological complexity in better understanding architecture selection, we need to be able to compute the homology of the data directly and still capture meaningful topological information. ",
+        "bbox": [
+            173,
+            284,
+            825,
+            381
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/ce901e1ad962a6e99edd3134c0007ad15c149dea7da34314eecf1cd53b1f3396.jpg",
+        "image_caption": [
+            "Figure 3: Left: The local disconnectedness of datasets prevents direct computation of their homology. Right: An illustration of computing persistent homology on a collection of points (Topaz et al. (2015)) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            404,
+            821,
+            560
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Persistent homology, introduced in Zomorodian & Carlsson (2005), avoids the trivialization of computation of dataset homology by providing an algorithm to calculate the homology of a filtration of a space. Specifically, a filtration is a topological space $X$ equipped with a sequence of subspaces $X _ { 0 } \\subset X _ { 1 } \\subset \\cdots \\subset X$ . In Figure 3 one such particular filtration is given by growing balls of size $\\epsilon$ centered at each point, and then letting $X _ { \\epsilon }$ be the resulting subspace in the filtration. Define $\\beta _ { n } ( X )$ to be the nth Betti number of the homology $H ( X _ { \\epsilon } )$ of $X _ { \\epsilon }$ . Then for example at $\\epsilon = 1 . 5$ , $\\beta _ { 0 } ( X _ { \\epsilon } ) = 1 9$ and $\\beta _ { 1 } ( X _ { \\epsilon } ) = 0$ as every ball is disjoint. At $\\epsilon = 5 . 0$ some connected components merge and $\\beta _ { 0 } ( X _ { \\epsilon } ) = 1 2$ and $\\beta _ { 1 } ( X _ { \\epsilon } ) = 0$ . Finally at $\\epsilon = 7$ , the union of the balls forms a hole towards the center of the dataset and $\\beta _ { 1 } ( X _ { \\epsilon } ) > 0$ with $\\beta _ { 0 } ( X _ { \\epsilon } ) = 4$ . ",
+        "bbox": [
+            173,
+            619,
+            825,
+            746
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "All together the change in homology and therefore Betti numbers for $X _ { \\epsilon }$ as $\\epsilon$ changes can be summarized succinctly in the persistence barcode diagram given in Figure 3. Each bar in the section $\\beta _ { n } ( X )$ denotes a ’hole’ of dimension $n$ . The left endpoint of the bar is the point at which homology detects that particular component, and the right endpoint is when that component becomes indistinguishable in the filtration. When calculating the persistent homology of datasets we will frequently use these diagrams. ",
+        "bbox": [
+            174,
+            752,
+            825,
+            837
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "With the foregoing algorithms established, we are now equipped with the tools to study the capacity of neural networks in the language of algebraic topology. ",
+        "bbox": [
+            174,
+            842,
+            823,
+            872
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 HOMOLOGICAL CHARACTERIZATION OF NEURAL ARCHITECTURES ",
+        "text_level": 1,
+        "bbox": [
+            169,
+            103,
+            767,
+            119
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In the forthcoming section, we will apply persistent homology to emperically characterize the power of certain neural architectures. To understand why homological complexity is a powerful measure for differentiating architectures, we present the following principle. ",
+        "bbox": [
+            174,
+            133,
+            823,
+            176
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Suppose that $\\mathcal { D }$ is some dataset drawn from a joint distribution $F$ with continuous CDF on some topological space $X \\times \\{ 0 , 1 \\}$ . Let $X ^ { + }$ denote the support of the distribution of points with positive labels, and $X ^ { - }$ denote that of the points with negative labels. Then let $H _ { S } ( f ) \\mathrel { \\mathop : } = H [ f ^ { - 1 } ( \\dot { ( 0 , \\infty ) } ) ]$ denote the support homology of some function $f : X \\to \\{ 0 , 1 \\}$ . Essentially $H _ { S } ( f )$ is homology of the set of $x$ such that $f ( x ) > 0$ . For a binary classifier, $f$ , $H _ { S } ( f )$ is roughly a characterization of how many ’holes’ are in the positive decision region of $f$ . We will sometimes use $\\beta _ { n } ( f )$ to denote the $n$ th Betti number of this support homology. Finally let ${ \\mathcal { F } } = \\{ f : X \\to \\{ 0 , 1 \\} \\}$ be some family of binary classifiers on $X$ . ",
+        "bbox": [
+            174,
+            181,
+            825,
+            294
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Theorem 3.1 (The Homological Principle of Generalization). If $X = X ^ { - } \\sqcup X ^ { + }$ and for all $f \\in { \\mathcal { F } }$ with $H _ { S } ( f ) \\neq H ( X ^ { + } )$ , then for all $f \\in { \\mathcal { F } }$ there exists $A \\subset X ^ { + }$ so $f$ misclassifies every $x \\in A$ . ",
+        "bbox": [
+            174,
+            296,
+            823,
+            325
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Essential Theorem 3.1 says that if an architecture (a family of models $\\mathcal { F }$ ) is incapable of producing a certain homological complexity, then for any model using that architecture there will always be a set $A$ of true data points on which the model will fail. Note that the above principle holds regardless of how $f \\in { \\mathcal { F } }$ is attained, learned or otherwise. However, the principle does imply that no matter how well some $\\mathcal { F }$ learns to correctly classify $\\mathcal { D }$ there will always be a counter examples in the true data. ",
+        "bbox": [
+            174,
+            334,
+            825,
+            404
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In the context of architecture selection, the foregoing minimality condition significantly reduces the size of the search space by eliminating smaller architectures which cannot even express the ’holes’ (persistent homology) of the data $H ( \\mathcal D )$ . This allows us to return to our original question of finding suitably expressive and generalizeable architectures but in the very computable language of homological complexity: Let ${ \\mathcal { F } } _ { A }$ the set of all neural networks with ’architecture’ $A$ , then ",
+        "bbox": [
+            174,
+            411,
+            825,
+            481
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Given a dataset $\\mathcal { D }$ , for which architectures $A$ does there exist a neural network $f \\in { \\mathcal { F } } _ { A }$ such that $H _ { S } ( f ) = H ( \\mathcal { D } )$ ? ",
+        "bbox": [
+            297,
+            484,
+            700,
+            513
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We will resurface a contemporary theoretical view on this question, and thereafter make the first steps towards an emperical characterization of the capacity of neural architectures in the view of topology. ",
+        "bbox": [
+            176,
+            517,
+            823,
+            546
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1 THEORETICAL BASIS FOR NEURAL HOMOLOGY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            561,
+            547,
+            575
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Theoretically, the homological complexity of neural network can be framed in terms of the sum of the number of holes expressible by certain architectures. In particular, Bianchini et al. (2014) gives an analysis of how the maximum sum of Betti numbers grows as ${ \\mathcal { F } } _ { A }$ changes. The results, summarized in Table 1, show that the width, depth, and activation of a fully connected architecture effect its topological expressivity to varying polynomial and exponential degrees. What is unclear from this analysis is how these bounds describe expressivity in terms of individual Betti numbers. For example, with a tanh activation function, $n$ inputs, $\\ell$ layers, and $h$ hidden units, there is no description of what the number of connected components $\\operatorname* { m a x } _ { f \\in { \\mathcal { F } } _ { A } } \\beta _ { 0 } ( f )$ or 1-dimensional holes $\\operatorname* { m a x } _ { f \\in { \\mathcal { F } } _ { A } } { \\beta _ { 1 } ( f ) }$ actually is. With regards to tighter bounds Bianchini et al. (2014) stipulate that improvements to their results are deeply tied to several unsolved problems in algebraic topology. ",
+        "bbox": [
+            173,
+            587,
+            825,
+            727
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/087685a812597e3fdcf0d216a5cee81e8bdad9c8485d11e218e22532461952e4.jpg",
+        "table_caption": [
+            "Table 1: Upper bounds on homological expressivity of neural architectures (Bianchini et al. (2014).) "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"4\">Architecture A</td><td>maxfeFA∑=1 βk（f）</td></tr><tr><td></td><td>Inputs Layers Units</td><td></td><td>Activation</td><td></td></tr><tr><td>n</td><td>3</td><td>h</td><td>threshold</td><td>O(hn)</td></tr><tr><td>n</td><td>3</td><td>h</td><td>arctan</td><td>O((n + h)n+2)</td></tr><tr><td>n</td><td>3</td><td>h</td><td>polynomial, deg. r</td><td>1(2+r)(1+r)n-1</td></tr><tr><td>1</td><td>3</td><td>h</td><td>arctan</td><td>h</td></tr><tr><td>n</td><td>l</td><td>h</td><td>arctan</td><td>2h(2h-1)O(nl + n)n+2h)</td></tr><tr><td>n</td><td>l</td><td>h</td><td>tanh</td><td>2h(h-1)/20(nl + n)n+h)</td></tr><tr><td>n</td><td>l</td><td>h</td><td>polynomial, deg. r</td><td>1(2+r)(1+r)n-1)</td></tr></table>",
+        "bbox": [
+            253,
+            765,
+            745,
+            915
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/c46bee0ab369538b1d7704c20d9dd3698824ca588addc9699d3cef8b27d074a4.jpg",
+        "image_caption": [
+            "Figure 4: Topological phase transitions in low dimensional neural networks as the homological complexity of the data increases. The upper right corner of each plot is a dataset on which the neural networks of increasing hidden dimension are trained. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            102,
+            816,
+            281
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.2 EMPIRICAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            354,
+            361,
+            367
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To understand how the homology of data determines expressive architectures we turn to an empirical characterization of neural networks. In this setting, we can tighten the bounds given in Table 1 by training different architectures on datasets with known homologies and then recording the decision regions observed over the course of training. ",
+        "bbox": [
+            174,
+            382,
+            825,
+            438
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.2.1 HOMOLOGICAL CAPACITY OF HIDDEN UNITS. ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            458,
+            549,
+            472
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In the most basic case, one is interested in studying how the number of hidden units in a single hidden layer neural network affect its homological capacity. The results of Bianchini et al. (2014) say for certain activation functions we should expect a polynomial dependence on the sum of Betti numbers $\\sum \\beta _ { n }$ , but is this true of individual numbers? Having an individual characterization would allow for architecture selection by computing the homology of the dataset, and then finding which architectures meet the minimal criterion for each Betti number $\\beta _ { n }$ . ",
+        "bbox": [
+            173,
+            483,
+            825,
+            568
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Restricting5 our analysis to the case of two inputs, $n = 2$ , we characterize the capacities of architectures with an increasing number of hidden units to learn on datasets with homological complexities ranging from $\\{ \\mathbb { Z } ^ { 1 } , 0 \\}$ to $\\{ \\mathbb { Z } ^ { 2 0 } , \\mathbb { Z } ^ { 2 0 } \\}$ . In our experiment, we generate datasets of each particular homological complexity by sampling different combinations of balls, rings, and scaling, twisting, and gluing them at random. After generating the foregoing datasets with $N \\approx 9 0 0 0 0$ samples we train 100 randomly (truncated normal) initialized single hidden layer architectures with hidden units $h \\in \\{ 1 , \\ldots , 2 5 5 \\}$ and tanh activation functions for $\\mathrm { \\bar { 1 0 ^ { 6 } } }$ minibatches of size 128. During training, every 2500 batches we sample the decision boundary of each neural network over a grid of $5 0 0 \\times 5 0 0$ samples, producing $1 . 0 2 \\times 1 \\bar { 0 } ^ { 6 }$ recorded decision boundaries. Using the resulting data, we not only characterize different architectures but observed interesting topological phenomena during learning. ",
+        "bbox": [
+            174,
+            574,
+            486,
+            866
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/df13f063452a7b093c38f4d767e507e5d0d5e3997ffa5161525ec22388e7d060.jpg",
+        "image_caption": [
+            "Figure 5: Several different views of the probability of converging to zero-error for single hidden layer neural networks on datasets with different homological complexities. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            496,
+            584,
+            825,
+            792
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/6b67d6c291699926908cc5543af035d5f293fcf22c21ea6c21611262e372bc58.jpg",
+        "image_caption": [
+            "Figure 6: An example of topological stratification for single hidden layer networks. (a) The number of connected components in the decision regions during training. (b) Correlation of Betti numbers. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            210,
+            79,
+            787,
+            258
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "First, neural networks exhibit a statistically significant topological phase transition in their convergence which depends directly on the homological complexity of the data. For any dataset in the experiment and any random homeomorphism applied thereto, the best test error of architectures with $h$ hidden units is strictly ordered in magnitude and convergence time for $h < h _ { p h a s e }$ where $h _ { p h a s e }$ is a number of hidden units required to express the homology of the data. In Figure 4 we plot the best performing test error of architectures $h \\in \\{ 1 , \\ldots , 1 5 \\}$ on some example datasets $\\mathcal { D } _ { 0 } , \\mathcal { D } _ { 1 }$ , and $\\mathcal { D } _ { 2 }$ with $H ( \\tilde { \\mathcal { D } _ { 0 } } ) \\approx \\{ \\mathbb { Z } ^ { 2 } , 0 \\}$ , $H ( \\mathcal { D } _ { 1 } ) \\approx \\{ \\mathbb { Z } ^ { 3 } , 0 \\}$ , $H ( \\mathcal { D } _ { 2 } ) \\overset { \\cdot } { \\approx } \\{ \\mathbb Z ^ { 3 } , \\mathbb Z ^ { 2 } \\}$ . In this example $h _ { p h a s e } ( \\mathcal { D } _ { 0 } ) = 4 , h _ { p h a s e } ( \\mathcal { D } _ { 1 } ) = 6$ , and $h _ { p h a s e } ( \\mathcal { D } _ { 2 } ) = 1 0$ . Surprisingly, leading up to the phase transition point, each different architecture falls into its own band of optimal convergence. This suggests that additional hidden units do in fact add to the topological capacity of an architecture in a consistent way. ",
+        "bbox": [
+            174,
+            315,
+            825,
+            469
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Using topological phase transitions we now return to the original question of existence of expressive architectures. In Figure 5, we accumulate the probabilities that neural networks of varying hidden dimension train to zero-error on datasets of different homological complexities. The table gives different views into how expressive an architecture need be in order to converge, and therefore we are able to conjecture tighter bounds on the capacity of hidden units. Extrapolating from the first view, if $H _ { 0 } ( \\mathcal { D } ) = \\mathbb { Z } ^ { m }$ then there exists a single hidden layer neural network with $h = m + 2$ that converges to zero error on $\\mathcal { D }$ . Likewise we claim that if $H _ { 0 } ( \\mathcal { D } ) = \\mathbb { Z } ^ { m }$ and $H _ { 1 } ( \\mathcal { D } ) = 1$ then the same holds with $h \\geq 3 m - 1$ . Further empirical analysis of convergence probabilities yields additional conjectures. However, claiming converse conjectures about a failure to generalize in the view of Theorem 3.1 requires exhaustive computation of decision boundary homologies. ",
+        "bbox": [
+            174,
+            477,
+            825,
+            616
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "By applying persistent homology to the decision boundaries of certain networks during training, we observe that given sufficient data, neural networks exhibit topological stratification. For example, consider the homologies of different architecture decision regions as training progresses in Figure 6(a). At the beginning of training every model captures the global topological information of the dataset and is homologically correlated with one another. However as training continues, the architectures stratify into two groups with homological complexities ordered by the capacities of the models. In this example, $h _ { 3 } , h _ { 4 }$ , and $h _ { 5 }$ are unable to express as many holes as the other architectures and so never specialize to more complex and local topological properties of the data. Figure 6(b) depicts topological stratification in terms of the correlation between Betti numbers. Topologically speaking, networks with less than 6 hidden units are distinct from those with more for most of training. Furthermore, this correlative view shows that stratification is consistent with topological phase transition; that is, across all decision boundary homologies recorded during the experiment stratification occurs just when the number of hidden units is slightly less than $h _ { p h a s e }$ . ",
+        "bbox": [
+            174,
+            622,
+            826,
+            803
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 THE TOPOLOGY OF REAL DATA ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            830,
+            468,
+            847
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We have thus far demonstrated the discriminatory power of homological complexity in determining the expressivity of architectures. However, for homological complexity to have any practical use in architecture selection, it must be computable on real data, and more generally real data must have non-trivial homology; if all data were topologically simple our characterization would have no predictive power. In the following section we will compute the persistent homologies up to dimension 2 of different real world datasets. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/f6d31e598d183daf15b5a69fa794ca5d0b0151956341748e6c2824d4c467ca63.jpg",
+        "image_caption": [
+            "Figure 7: The persistent homology barcodes of classes in the CIFAR-10 and UCI Protein Localization Datasets. Left: The bardcode for dimension 0 and 1 of the ’CYT’ class along side its local linear embedding into $\\mathbb { R } ^ { 2 }$ . Right: The barcode for the dimensions 0 and 1 for the ’cars’ class along side different samples thereof in CIFAR-10. Note how different orientations are shown. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            92,
+            818,
+            199
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            281,
+            821,
+            309
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "CIFAR-10. We compute the persistent homology of several classes of CIFAR-10 using the Python library Dionysus. Currently algorithms for persistent homology do not deal well with high dimensional data, so we embed the entire dataset in $\\mathbb { R } ^ { 3 }$ using local linear embedding (LLE; Saul & Roweis (2000)) with $K = 1 2 0$ neighbors. After embedding the dataset, we take a sample of 1000 points from example class ’car’ and build a persistent filtration by constructing a Vietoris-Rips complex on the data. The resulting complex has 20833750 simplices and took $4 . 3 \\mathrm { { m i n } }$ . to generate. Finally, computation of the persistence diagram shown in Figure 7 took $8 . 4 \\mathrm { { m i n } }$ . locked to a single thread on a Intel Core i7 processor. The one-time cost of computing persistent homology could easily augment any neural architecture search. ",
+        "bbox": [
+            174,
+            316,
+            825,
+            441
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Although we only give an analysis of dimension 2 topological features–and there is certainly higher dimensional homological information in CIFAR-10–the persistence barcode diagram is rich with different components in both $H _ { 0 } ( \\mathcal { D } )$ and $H _ { 1 } ( \\mathcal { D } )$ . Intuitively, CIFAR contains pictures of cars rotated accross a range of different orientations and this is exhibited in the homology. In particular, several holes are born and die in the range $\\epsilon \\in [ 0 . 1 5 , 0 . 3 7 5 ]$ and one large loop from $\\epsilon \\in [ 0 . 6 2 5 , 0 . 8 2 ]$ . ",
+        "bbox": [
+            174,
+            449,
+            825,
+            518
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "UCI Datasets. We further compute the homology of three low dimensional UCI datasets and attempt to assert the of non-trivial , $h _ { p h a s e }$ . Specifically, we compute the persistent homology of the majority classes in the Yeast Protein Localization Sites, UCI Ecoli Protein Localization Sites, and HTRU2 datasets. For these datasets no dimensionality reduction was used. In Figure 7(left), the persistence barcode exhibits two seperate significant loops (holes) at $\\epsilon \\in [ 0 . 1 9 , 0 . 3 1 ]$ and $\\epsilon \\in [ 0 . 7 6 , 0 . 8 5 ]$ , as well as two major connected components in $\\beta _ { 0 } ( \\mathcal { D } )$ . The Other persistence diagrams are relegated to the appendix. ",
+        "bbox": [
+            173,
+            525,
+            825,
+            622
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Existing Data. Outside of the primary machine learning literature, topological data analysis yields non-trivial computations in wide variety of fields and datasets. Of particular interest is the work of Carlsson et al. (2008), which computes the homological complexity of collections of $n \\times n$ patches of natural images. Even in these simple collections of images, the authors found topologies of Klein Bottles $( \\mathbf { \\bar { \\cal H } } ( \\cdot ) = \\{ \\mathbb { Z } , \\mathbb { Z } ^ { 2 } / 2 \\mathbb { Z } , 0 \\ldots \\} )$ and other exotic topological objects. Other authors have calculated non-trivial dataset homologies in biological (Topaz et al. (2015)), natural language (Michel et al. (2017)), and other domains (Wu et al. (2017), Xia & Wei (2014)). ",
+        "bbox": [
+            174,
+            630,
+            825,
+            727
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            751,
+            343,
+            767
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We will place this work in the context of deep learning theory as it relates to expressivity. Since the seminal work of Cybenko (1989) which established standard universal approximation results for neural networks, many theorists have endeavored to understand the expressivity of certain neural architectures. Pascanu et al. (2013) and MacKay (2003) provided the first analysis relating the depth and width of architectures to the complexitity of the sublevel sets they can express. Motivated therefrom, Bianchini et al. (2014) expressed this theme in the language of Pfefferian functions, thereby bounding the sum of Betti numbers expressed by sublevel sets. Finally Guss (2016) gave an account of how topological assumptions on the input data lead to optimally expressive architectures. In parallel, Eldan & Shamir (2016) presented the first analytical minimality result in expressivity theory; that is, the authors show that there are simple functions that cannot be expressed by two layer neural networks with out exponential dependence on input dimension. This work spurred the work ofPoole et al. (2016), Raghu et al. (2016) which reframed expressivity in a differential geometric lense. ",
+        "bbox": [
+            174,
+            784,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            104,
+            821,
+            147
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Our work presents the first method to derive expressivity results empirically. Our topological viewpoint sits dually with its differential geometric counterpart, and in conjunction with the work of Poole et al. (2016) and Bianchini et al. (2014), this duallity implies that when topological expression is not possible, exponential differential expressivity allows networks to bypass homological constaints at the cost of adversarial sets. Furthermore, our work opens a practical connectio nbetween the foregoing theory on neural expressivity and architecture selection, with the potential to drastically improve neural architecture search (Zoph & Le (2017)) by directly computing the capacities of different architectures. ",
+        "bbox": [
+            174,
+            154,
+            825,
+            265
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            286,
+            318,
+            301
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Architectural power is deeply related to the algebraic topology of decision boundaries. In this work we distilled neural network expressivity into an empirical question of the generalization capabilities of architectures with respect to the homological complexity of learning problems. This view allowed us to provide an empirical method for developing tighter characterizations on the the capacity of different architectures in addition to a principled approach to guiding architecture selection by computation of persistent homology on real data. ",
+        "bbox": [
+            174,
+            318,
+            825,
+            401
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "There are several potential avenues of future research in using homological complexity to better understand neural architectures. First, a full characterization of neural networks with many layers or convolutional linearities is a crucial next step. Our empirical results suggest that the their are exact formulas describing the of power of neural networks to express decision boundaries with certain properties. Future theoretical work in determining these forms would significantly increase the efficiency and power of neural architecture search, constraining the search space by the persistent homology of the data. Additionally, we intend on studying how the topological complexity of data changes as it is propagated through deeper architectures. ",
+        "bbox": [
+            174,
+            409,
+            825,
+            520
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            541,
+            285,
+            556
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "E Betti. Il nuovo cimento. Series, 2:7, 1872. ",
+        "bbox": [
+            176,
+            564,
+            465,
+            579
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Monica Bianchini et al. On the complexity of shallow and deep neural network classifiers. In ESANN, 2014. ",
+        "bbox": [
+            169,
+            590,
+            825,
+            618
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Glen E Bredon. Topology and geometry, volume 139. Springer Science & Business Media, 2013. ",
+        "bbox": [
+            171,
+            630,
+            810,
+            645
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Gunnar Carlsson, Tigran Ishkhanov, Vin De Silva, and Afra Zomorodian. On the local behavior of spaces of natural images. International journal of computer vision, 76(1):1–12, 2008. ",
+        "bbox": [
+            171,
+            655,
+            825,
+            684
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Frédéric Chazal, Brittany Fasy, Fabrizio Lecci, Bertrand Michel, Alessandro Rinaldo, and Larry Wasserman. Subsampling methods for persistent homology. In Proceedings of the 32nd International Conference on Machine Learning (ICML-15), pp. 2143–2151, 2015. ",
+        "bbox": [
+            173,
+            694,
+            826,
+            738
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "George Cybenko. Approximation by superpositions of a sigmoidal function. Mathematics of Control, Signals, and Systems (MCSS), 2(4):303–314, 1989. ",
+        "bbox": [
+            173,
+            748,
+            825,
+            777
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Amit Daniely, Roy Frostig, and Yoram Singer. Toward deeper understanding of neural networks: The power of initialization and a dual view on expressivity. In Advances In Neural Information Processing Systems, pp. 2253–2261, 2016. ",
+        "bbox": [
+            174,
+            787,
+            823,
+            830
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "TK Dey, H Edelsbrunner, and S Guha. Computational topology, invited paper in advances in discrete and computational geometry, eds. b. chazelle, je goodmann and r. pollack. Contemporary Mathematics, AMS, 1998. ",
+        "bbox": [
+            174,
+            842,
+            823,
+            883
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ronen Eldan and Ohad Shamir. The power of depth for feedforward neural networks. In Conference on Learning Theory, pp. 907–940, 2016. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Chrisantha Fernando, Dylan Banarse, Charles Blundell, Yori Zwols, David Ha, Andrei A. Rusu, Alexander Pritzel, and Daan Wierstra. Pathnet: Evolution channels gradient descent in super neural networks. CoRR, abs/1701.08734, 2017. URL http://arxiv.org/abs/1701.08734. ",
+        "bbox": [
+            176,
+            104,
+            823,
+            147
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ian Goodfellow, Yoshua Bengio, and Aaron Courville. Deep Learning. MIT Press, 2016. http: //www.deeplearningbook.org. ",
+        "bbox": [
+            176,
+            156,
+            821,
+            186
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "William H Guss. Deep function machines: Generalized neural networks for topological layer expression. arXiv preprint arXiv:1612.04799, 2016. ",
+        "bbox": [
+            174,
+            195,
+            821,
+            224
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. CoRR, abs/1512.03385, 2015. URL http://arxiv.org/abs/1512.03385. ",
+        "bbox": [
+            173,
+            233,
+            821,
+            263
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey Hinton, Li Deng, Dong Yu, George E Dahl, Abdel-rahman Mohamed, Navdeep Jaitly, Andrew Senior, Vincent Vanhoucke, Patrick Nguyen, Tara N Sainath, et al. Deep neural networks for acoustic modeling in speech recognition: The shared views of four research groups. IEEE Signal Processing Magazine, 29(6):82–97, 2012. ",
+        "bbox": [
+            173,
+            272,
+            826,
+            329
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yasuyuki Kato, Daisuke Yamamoto, and Ippei Danshita. Quantum tricriticality at the superfluidinsulator transition of binary bose mixtures. Phys. Rev. Lett., 112:055301, Feb 2014. doi: 10.1103/PhysRevLett.112.055301. URL https://link.aps.org/doi/10.1103/ PhysRevLett.112.055301. ",
+        "bbox": [
+            174,
+            338,
+            826,
+            393
+        ],
+        "page_idx": 9
+    },
+    {
+        "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": [
+            174,
+            404,
+            825,
+            446
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David JC MacKay. Information theory, inference and learning algorithms. Cambridge university press, 2003. ",
+        "bbox": [
+            174,
+            455,
+            823,
+            486
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Paul Michel, Abhilasha Ravichander, and Shruti Rijhwani. Does the geometry of word embeddings help document classification? a case study on persistent homology based representations. arXiv preprint arXiv:1705.10900, 2017. ",
+        "bbox": [
+            174,
+            494,
+            825,
+            537
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Alex Graves, Ioannis Antonoglou, Daan Wierstra, and Martin Riedmiller. Playing atari with deep reinforcement learning. arXiv preprint arXiv:1312.5602, 2013. ",
+        "bbox": [
+            174,
+            546,
+            825,
+            589
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Razvan Pascanu, Guido Montufar, and Yoshua Bengio. On the number of response regions of deep feed forward networks with piece-wise linear activations. arXiv preprint arXiv:1312.6098, 2013. ",
+        "bbox": [
+            171,
+            598,
+            825,
+            628
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ben Poole, Subhaneil Lahiri, Maithreyi Raghu, Jascha Sohl-Dickstein, and Surya Ganguli. Exponential expressivity in deep neural networks through transient chaos. In Advances In Neural Information Processing Systems, pp. 3360–3368, 2016. ",
+        "bbox": [
+            173,
+            637,
+            825,
+            681
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Maithra Raghu, Ben Poole, Jon Kleinberg, Surya Ganguli, and Jascha Sohl-Dickstein. On the expressive power of deep neural networks. arXiv preprint arXiv:1606.05336, 2016. ",
+        "bbox": [
+            169,
+            689,
+            823,
+            719
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Lawrence K Saul and Sam T Roweis. An introduction to locally linear embedding. unpublished. Available at: http://www. cs. toronto. edu/˜ roweis/lle/publications. html, 2000. ",
+        "bbox": [
+            171,
+            728,
+            823,
+            757
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Shreyas Saxena and Jakob Verbeek. Convolutional neural fabrics. CoRR, abs/1606.02492, 2016. URL http://arxiv.org/abs/1606.02492. ",
+        "bbox": [
+            171,
+            766,
+            825,
+            795
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. CoRR, abs/1409.1556, 2014. URL http://arxiv.org/abs/1409.1556. ",
+        "bbox": [
+            171,
+            804,
+            823,
+            834
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott E. Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. CoRR, abs/1409.4842, 2014. URL http://arxiv.org/abs/1409.4842. ",
+        "bbox": [
+            176,
+            843,
+            823,
+            886
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chad M Topaz, Lori Ziegelmeier, and Tom Halverson. Topological data analysis of biological aggregation models. PloS one, 10(5):e0126383, 2015. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yonghui Wu, Mike Schuster, Zhifeng Chen, Quoc V Le, Mohammad Norouzi, Wolfgang Macherey, Maxim Krikun, Yuan Cao, Qin Gao, Klaus Macherey, et al. Google’s neural machine translation system: Bridging the gap between human and machine translation. arXiv preprint arXiv:1609.08144, 2016. ",
+        "bbox": [
+            174,
+            104,
+            826,
+            161
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yu Wu, Gabriel Shindnes, Vaibhav Karve, Derrek Yager, Daniel B Work, Arnab Chakraborty, and Richard B Sowers. Congestion barcodes: Exploring the topology of urban congestion using persistent homology. arXiv preprint arXiv:1707.08557, 2017. ",
+        "bbox": [
+            176,
+            171,
+            823,
+            213
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kelin Xia and Guo-Wei Wei. Persistent homology analysis of protein structure, flexibility, and folding. International journal for numerical methods in biomedical engineering, 30(8):814–844, 2014. ",
+        "bbox": [
+            174,
+            224,
+            823,
+            253
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Afra Zomorodian and Gunnar Carlsson. Computing persistent homology. Discrete & Computational Geometry, 33(2):249–274, 2005. ",
+        "bbox": [
+            173,
+            263,
+            825,
+            291
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Barret Zoph and Quoc V. Le. Neural architecture search with reinforcement learning. 2017. URL https://arxiv.org/abs/1611.01578. ",
+        "bbox": [
+            173,
+            301,
+            825,
+            330
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A PROOFS, CONJECTURES, AND FORMAL DEFINITIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            650,
+            121
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.1 HOMOLOGY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            140,
+            303,
+            155
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Homology is naturally described using the language of category theory. Let $T o p ^ { 2 }$ denote the category of topological spaces and $A b$ the category of abelian groups. ",
+        "bbox": [
+            174,
+            170,
+            823,
+            199
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Definition A.1 (Homology Theory, Bredon (2013)). A homology theory on the on $T o p ^ { 2 }$ is a function $H : T o p ^ { 2 }  A b$ assigning to each pair $( X , A )$ of spaces a graded (abelian) group $\\{ H _ { p } ( X , A ) \\}$ , and to each map $f : ( X , A ) \\to ( Y , B )$ , homomorphisms $f _ { * } : H _ { p } ( X , A ) \\to H _ { p } ( Y , B )$ , together with a natural transformation of functors $\\partial _ { * } : H _ { p } ( X , A ) \\to H _ { p - 1 } ( X , A )$ , called the connecting homomorphism (where we use $H _ { * } ( A )$ to denote $H _ { * } ( A , \\varnothing )$ ) such that the following five axioms are satisfied. ",
+        "bbox": [
+            173,
+            207,
+            826,
+            291
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "1. If $f \\simeq g : ( X , A )  ( Y , B )$ then $f _ { * } = g _ { * } : H _ { * } ( X , A ) \\to H _ { * } ( Y , B ) .$ ",
+        "bbox": [
+            210,
+            306,
+            679,
+            325
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "2. For the inclusions $i : A \\to X$ and $j : X \\to ( X , A )$ the sequence sequence of inclusions and connecting homomorphisms are exact. ",
+        "bbox": [
+            210,
+            335,
+            825,
+            366
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "3. Given the pair $( X , A )$ and an open set $U \\subset X$ such that $c l ( U ) \\subset i n t ( A )$ then the inclusion $k : ( X - U , A - U ) \\to ( X , A )$ induces an isomorphism $k _ { * } : H _ { * } ( X - U , A - U ) \\to$ $H _ { * } ( X , A )$ ",
+        "bbox": [
+            212,
+            377,
+            825,
+            422
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "4. For a one point space $P , H _ { i } ( P ) = 0$ for all $i \\neq 0$ . ",
+        "bbox": [
+            210,
+            434,
+            560,
+            450
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "5. For a topological sum $X = + _ { \\alpha } X _ { \\alpha }$ the homomorphism ",
+        "bbox": [
+            210,
+            462,
+            594,
+            478
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d664804d511749c5e49b13f5d8eb1f80187d02b6ea58fd095b33ad6e50241d00.jpg",
+        "text": "$$\n\\bigoplus ( i _ { \\alpha } ) _ { * } : \\bigoplus H _ { n } ( X _ { \\alpha } ) \\to H _ { n } ( X )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            408,
+            493,
+            647,
+            517
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "is an isomorphism, where $i _ { \\alpha } : X _ { \\alpha } \\to X$ is the inclusion. ",
+        "bbox": [
+            230,
+            532,
+            604,
+            547
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "For related definitions and requisite notions we refer the reader to Bredon (2013). ",
+        "bbox": [
+            173,
+            563,
+            705,
+            578
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.2 PROOF OF THEOREM 3.1 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            604,
+            388,
+            619
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Theorem A.2. Let $X$ be a topological space and $X ^ { + }$ be some open subspace. If ${ \\mathcal { F } } \\subset 2 ^ { X }$ such that $f \\in { \\mathcal { F } }$ implies $H _ { S } ( f ) \\neq H ( \\bar { X } ^ { + } )$ , then for all $f \\in { \\mathcal { F } }$ there exists $A \\subset X$ so that $f ( A \\cap X ^ { + } ) = \\{ 0 \\}$ and $f ( A \\cap ( X \\setminus X ^ { + } ) ) = \\{ 1 \\}$ . ",
+        "bbox": [
+            173,
+            635,
+            825,
+            679
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Proof. Suppose the for the sake of contraiction that for all $f \\in { \\mathcal { F } }$ , $H _ { S } ( f ) \\ne H ( X ^ { + } )$ and yet there exists an $f$ such that for all $A \\subset X$ , there exists an $x \\in A$ such that $f ( x ) = 1$ . Then take $\\mathcal { A } = \\{ x \\} _ { x \\in X }$ , and note that $f$ maps each singleton into its proper partition on $X$ . We have that for any open subset of $V \\subset X ^ { + }$ , $f ( \\bar { V } ) = \\{ 1 \\}$ , and for any closed subset $W \\subset X \\setminus X ^ { + }$ , $f ( W ) = \\{ 0 \\}$ . Therefore X+ = SA∈τX+∩X $X ^ { + } = \\textstyle \\bigcup _ { A \\in \\tau _ { X ^ { + } \\cap X } } A \\subset s u p p ( f )$ as the subspace topology $\\tau _ { X ^ { + } \\cap X } = \\tau _ { X ^ { + } } \\cap \\tau _ { X }$ where $\\tau _ { X ^ { + } } = \\{ A \\in \\tau _ { X } | A \\subset { \\dot { X } } ^ { + } \\}$ and $\\tau _ { X }$ denotes the topology of $X$ . Likewise, $i n t ( X ^ { - } ) \\subset X \\backslash s u p p ( F )$ under the same logic. Therefore $s u p p ( f )$ has the exact same topology as $X ^ { + }$ and so by Theorem 2.2 $H ( X ^ { + } ) = H ( s u \\bar { p } p ( f ) )$ but this is a contradiction. This completes the proof. □ ",
+        "bbox": [
+            173,
+            722,
+            826,
+            839
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.3 THE NEURAL HOMOLOGY PRINCIPLE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            864,
+            480,
+            880
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Conjecture A.3. If $N$ is some neural network with $\\ell$ layers and $h$ hidden units, and $H _ { S } ( N ) \\neq$ $H ( X ^ { + } )$ then $\\mathbb { E } [ L ( \\mathrm { \\bar { N } } , \\mathcal { D } ) ] > c$ for some fixed $c ( \\ell , h ) > 0$ . ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/77273b4d16c2680ef1cc2134a32082dcba78d3d14d189be37b108b3e092f2d46.jpg",
+        "image_caption": [
+            "Figure 8: Topological phase transitions for datasets with $\\beta ( \\mathcal { D } ) \\in \\{ ( 2 , 0 ) , ( 2 , 1 ) , ( 3 , 0 ) , ( 3 , 1 ) \\}$ "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            156,
+            818,
+            502
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/e27383b283d68b6c0607704c6df459226986a6e81af9c11222a9210c8e749b94.jpg",
+        "image_caption": [
+            "Figure 9: Topological phase transitions for datasets with $\\beta ( \\mathcal { D } ) \\in \\{ ( 3 , 2 ) , ( 4 , 0 ) , ( 4 , 1 ) , ( 4 , 2 ) \\}$ "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            563,
+            816,
+            909
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/7ea7091547b0d613980c98d1bc1a7e62068f7eb5fbe42da2343373e874b7ac9d.jpg",
+        "image_caption": [
+            "Figure 10: Topological phase transitions for datasets with $\\beta ( \\mathcal { D } ) \\in \\{ ( 4 , 3 ) , ( 5 , 0 ) \\}$ "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            111,
+            816,
+            366
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "C EXAMPLE TOPOLOGICAL STRATIFICATIONS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            429,
+            573,
+            445
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/8a2ae195ba397629afe30da13627f735fddf56b3439dbaa5fca35732f4717701.jpg",
+        "image_caption": [
+            "Figure 11: Topological stratification for $\\{ h _ { 3 } , . . . , h _ { 1 5 } \\}$ on a random dataset $\\mathcal { D }$ with $\\beta _ { 0 } ( \\mathcal { D } ) = 2 5$ , $\\beta _ { 1 } ( \\mathcal { D } ) = 1 6$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            227,
+            473,
+            772,
+            628
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/75ed16e4c46d1ef4418f9175de2547afc1090f8f9612b1bc15e53dbf6e7aa384.jpg",
+        "image_caption": [
+            "Figure 12: Topological stratification for $\\{ h _ { 1 } , \\ldots , h _ { 5 } \\}$ on a random dataset $\\mathcal { D }$ with $\\beta _ { 0 } ( \\mathcal { D } ) = 3$ , $\\beta _ { 1 } \\mathsf { \\bar { ( } } D ) = 0$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            225,
+            714,
+            774,
+            872
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/4ff6976e387af4a2dd76433cd7b86100763aeac8828b4749dbf98cef8c31501f.jpg",
+        "image_caption": [
+            "Figure 13: Topological stratification for $\\{ h _ { 3 } , \\ldots , h _ { 7 } \\}$ on a random dataset $\\mathcal { D }$ with $\\beta _ { 0 } ( \\mathcal { D } ) = 3$ , $\\beta _ { 1 } ( \\mathcal { D } ) = 0$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            225,
+            102,
+            774,
+            258
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "D ADDITIONAL TOPOLOGY OF REAL DATA ",
+        "bbox": [
+            173,
+            310,
+            549,
+            327
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/1ecf1eca77077c1a6148f2224eda13a3d65cf665230e2c3dde6515a73b7b7e6b.jpg",
+        "image_caption": [
+            "Figure 14: The persistence diagrams of other data. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            347,
+            820,
+            568
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/81b346f8954e4988c73cd34fff398e0ddeef9837b79107fd94f7fba420f7ed86.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            202,
+            604,
+            794,
+            915
+        ],
+        "page_idx": 14
+    }
+]

parse/train/HkgTkhRcKQ/HkgTkhRcKQ.md

@@ -0,0 +1,742 @@
+# ADASHIFT: DECORRELATION AND CONVERGENCE OF ADAPTIVE LEARNING RATE METHODS
+
+Zhiming Zhou∗†, Qingru Zhang∗‡, Guansong Lu, Hongwei Wang, Weinan Zhang, Yong Yu   
+Shanghai Jiao Tong University   
+†heyohai@apex.sjtu.edu.cn,‡neverquit@sjtu.edu.cn
+
+# ABSTRACT
+
+Adam is shown not being able to converge to the optimal solution in certain cases. Researchers recently propose several algorithms to avoid the issue of nonconvergence of Adam, but their efficiency turns out to be unsatisfactory in practice. In this paper, we provide a new insight into the non-convergence issue of Adam as well as other adaptive learning rate methods. We argue that there exists an inappropriate correlation between gradient $g _ { t }$ and the second moment term $v _ { t }$ in Adam $t$ is the timestep), which results in that a large gradient is likely to have small step size while a small gradient may have a large step size. We demonstrate that such unbalanced step sizes are the fundamental cause of non-convergence of Adam, and we further prove that decorrelating $v _ { t }$ and $g _ { t }$ will lead to unbiased step size for each gradient, thus solving the non-convergence problem of Adam. Finally, we propose AdaShift, a novel adaptive learning rate method that decorrelates $v _ { t }$ and $g _ { t }$ by temporal shifting, i.e., using temporally shifted gradient $g _ { t - n }$ to calculate $v _ { t }$ . The experiment results demonstrate that AdaShift is able to address the non-convergence issue of Adam, while still maintaining a competitive performance with Adam in terms of both training speed and generalization.
+
+# 1 INTRODUCTION
+
+First-order optimization algorithms with adaptive learning rate play an important role in deep learning due to their efficiency in solving large-scale optimization problems. Denote $g _ { t } \in \mathbb { R } ^ { n }$ as the gradient of loss function $f$ with respect to its parameters $\boldsymbol \theta \in \mathbb { R } ^ { n }$ at timestep $t$ , then the general updating rule of these algorithms can be written as follows (Reddi et al., 2018):
+
+$$
+\theta _ { t + 1 } = \theta _ { t } - { \frac { \alpha _ { t } } { \sqrt { v _ { t } } } } m _ { t } .
+$$
+
+In the above equation, $m _ { t } \triangleq \phi ( g _ { 1 } , \ldots , g _ { t } ) \in \mathbb { R } ^ { n }$ is a function of the historical gradients; $v _ { t } \ { \stackrel { \triangle } { = } }$ $\psi ( g _ { 1 } , \ldots , g _ { t } ) \in \mathbb { R } _ { + } ^ { n }$ is an $n$ -dimension vector with non-negative elements, which adapts the learning rate for the $n$ elements in $g _ { t }$ respectively; $\alpha _ { t }$ is the base learning rate; and √αtv is the adaptive step size for $m _ { t }$ .
+
+One common choice of $\phi ( g _ { 1 } , \ldots , g _ { t } )$ is the exponential moving average of the gradients used in Momentum (Qian, 1999) and Adam (Kingma & Ba, 2014), which helps alleviate gradient oscillations. The commonly-used $\psi ( g _ { 1 } , \dots , g _ { t } )$ in deep learning community is the exponential moving average of squared gradients, such as Adadelta (Zeiler, 2012), RMSProp (Tieleman & Hinton, 2012), Adam (Kingma & Ba, 2014) and Nadam (Dozat, 2016).
+
+Adam (Kingma & Ba, 2014) is a typical adaptive learning rate method, which assembles the idea of using exponential moving average of first and second moments and bias correction. In general, Adam is robust and efficient in both dense and sparse gradient cases, and is popular in deep learning research. However, Adam is shown not being able to converge to optimal solution in certain cases. Reddi et al. (2018) point out that the key issue in the convergence proof of Adam lies in the quantity
+
+$$
+\Gamma _ { t } \triangleq \bigg ( \frac { \sqrt { v _ { t } } } { \alpha _ { t } } - \frac { \sqrt { v _ { t - 1 } } } { \alpha _ { t - 1 } } \bigg ) ,
+$$
+
+which is assumed to be positive, but unfortunately, such an assumption does not always hold in Adam. They provide a set of counterexamples and demonstrate that the violation of positiveness of $\Gamma _ { t }$ will lead to undesirable convergence behavior in Adam.
+
+Reddi et al. (2018) then propose two variants, AMSGrad and AdamNC, to address the issue by keeping $\Gamma _ { t }$ positive. Specifically, AMSGrad defines $\hat { v _ { t } }$ as the historical maximum of $v _ { t }$ , i.e., $\hat { v _ { t } } =$ max $\{ v _ { i } \} _ { i = 1 } ^ { t }$ , and replaces $v _ { t }$ with $\hat { v _ { t } }$ to keep $v _ { t }$ non-decreasing and therefore forces $\Gamma _ { t }$ to be positive; while AdamNC forces $v _ { t }$ to have “long-term memory” of past gradients and calculates $v _ { t }$ as their average to make it stable. Though these two algorithms solve the non-convergence problem of Adam to a certain extent, they turn out to be inefficient in practice: they have to maintain a very large $v _ { t }$ once a large gradient appears, and a large $v _ { t }$ decreases the adaptive learning rate $\frac { \alpha _ { t } } { \sqrt { v _ { t } } }$ and slows down the training process.
+
+In this paper, we provide a new insight into adaptive learning rate methods, which brings a new perspective on solving the non-convergence issue of Adam. Specifically, in Section 3, we study the counterexamples provided by Reddi et al. (2018) via analyzing the accumulated step size of each gradient $g _ { t }$ . We observe that in the common adaptive learning rate methods, a large gradient tends to have a relatively small step size, while a small gradient is likely to have a relatively large step size. We show that the unbalanced step sizes stem from the inappropriate positive correlation between $v _ { t }$ and $g _ { t }$ , and we argue that this is the fundamental cause of the non-convergence issue of Adam.
+
+In Section 4, we further prove that decorrelating $v _ { t }$ and $g _ { t }$ leads to equal and unbiased expected step size for each gradient, thus solving the non-convergence issue of Adam. We subsequently propose AdaShift, a decorrelated variant of adaptive learning rate methods, which achieves decorrelation between $v _ { t }$ and $g _ { t }$ by calculating $v _ { t }$ using temporally shifted gradients. Finally, in Section 5, we study the performance of our proposed AdaShift, and demonstrate that it solves the non-convergence issue of Adam, while still maintaining a decent performance compared with Adam in terms of both training speed and generalization.
+
+# 2 PRELIMINARIES
+
+Adam. In Adam, $m _ { t }$ and $v _ { t }$ are defined as the exponential moving average of $g _ { t }$ and $g _ { t } ^ { 2 }$
+
+$$
+m _ { t } = \beta _ { 1 } m _ { t - 1 } + ( 1 - \beta _ { 1 } ) g _ { t } { \mathrm { a n d } } v _ { t } = \beta _ { 2 } v _ { t - 1 } + ( 1 - \beta _ { 2 } ) g _ { t } ^ { 2 } ,
+$$
+
+where $\beta _ { 1 } \in [ 0 , 1 )$ and $\beta _ { 2 } \in [ 0 , 1 )$ are the exponential decay rates for $m _ { t }$ and $v _ { t }$ , respectively, with $m _ { 0 } = 0$ and $v _ { 0 } = 0$ . They can also be written as:
+
+$$
+m _ { t } = ( 1 - \beta _ { 1 } ) \sum _ { i = 1 } ^ { t } \beta _ { 1 } ^ { t - i } g _ { i } \mathrm { a n d } v _ { t } = ( 1 - \beta _ { 2 } ) \sum _ { i = 1 } ^ { t } \beta _ { 2 } ^ { t - i } g _ { i } ^ { 2 } .
+$$
+
+To avoid the bias in the estimation of the expected value at the initial timesteps, Kingma & Ba (2014) propose to apply bias correction to $m _ { t }$ and $v _ { t }$ . Using $m _ { t }$ as instance, it works as follows:
+
+$$
+m _ { t } = \frac { ( 1 - \beta _ { 1 } ) \sum _ { i = 1 } ^ { t } \beta _ { 1 } ^ { t - i } g _ { i } } { ( 1 - \beta _ { 1 } ) \sum _ { i = 1 } ^ { t } \beta _ { 1 } ^ { t - i } } = \frac { \sum _ { i = 1 } ^ { t } \beta _ { 1 } ^ { t - i } g _ { i } } { \sum _ { i = 1 } ^ { t } \beta _ { 1 } ^ { t - i } } = \frac { ( 1 - \beta _ { 1 } ) \sum _ { i = 1 } ^ { t } \beta _ { 1 } ^ { t - i } g _ { i } } { 1 - \beta _ { 1 } ^ { t } } .
+$$
+
+Online optimization problem. An online optimization problem consists of a sequence of cost functions ${ \bf \bar { \phi } } _ { f _ { 1 } ( \theta ) , \dots , f _ { t } ( \theta ) , . . . , f _ { T } ( \theta ) }$ , where the optimizer predicts the parameter $\theta _ { t }$ at each timestep $t$ and evaluate it on an unknown cost function $f _ { t } ( \theta )$ . The performance of the optimizer is usually evaluated by regreonline prediction $\begin{array} { r } { R ( T ) \stackrel { \Delta } { = } \sum _ { t = 1 } ^ { T } [ f _ { t } ( \theta _ { t } ) - f _ { t } ( \theta ^ { * } ) ] } \end{array}$ , which is the sum oarameter prediction fference between thefor all the previous $f _ { t } ( \theta _ { t } )$ $f _ { t } ( \theta ^ { * } )$ steps, where $\begin{array} { r } { \theta ^ { * } = \arg \operatorname* { m i n } _ { \theta \in \vartheta } \sum _ { t = 1 } ^ { T } f _ { t } ( \theta ) } \end{array}$ is the best fixed-point parameter from a feasible set $\vartheta$ .
+
+Counterexamples. Reddi et al. (2018) highlight that for any fixed $\beta _ { 1 }$ and $\beta _ { 2 }$ , there exists an online optimization problem where Adam has non-zero average regret, i.e., Adam does not converge to optimal solution . The counterexamples in the sequential version are given as follows:
+
+$$
+f _ { t } ( \theta ) = { \left\{ \begin{array} { l l } { C \theta , } & { { \mathrm { i f ~ t ~ m o d ~ } } d = 1 ; } \\ { - \theta , } & { { \mathrm { o t h e r w i s e } } , } \end{array} \right. }
+$$
+
+where $C$ is a relatively large constant and $d$ is the length of an epoch. In Equation 6, most gradients of $f _ { t } ( \theta )$ with respect to $\theta$ are $- 1$ , but the large positive gradient $C$ at the beginning of each epoch makes the overall gradient of each epoch positive, which means that one should decrease $\theta _ { t }$ to minimize the loss. However, according to (Reddi et al., 2018), the accumulated update of $\theta$ in Adam under some circumstance is opposite (i.e., $\theta _ { t }$ is increased), thus Adam cannot converge in such case. Reddi et al. (2018) argue that the reason of the non-convergence of Adam lies in that the positive assumption of $\Gamma _ { t } \triangleq ( \sqrt { v _ { t } } / \alpha _ { t } - \sqrt { v _ { t - 1 } } / \alpha _ { t - 1 } )$ does not always hold in Adam.
+
+The counterexamples are also extended to stochastic cases in (Reddi et al., 2018), where a finite set of cost functions appear in a stochastic order. Compared with sequential online optimization counterexample, the stochastic version is more general and closer to the practical situation. For the simplest one dimensional case, at each timestep $t$ , the function $f _ { t } ( \theta )$ is chosen as i.i.d.:
+
+$$
+\begin{array} { r } { f _ { t } ( \theta ) = \left\{ \begin{array} { l l } { C \theta , } & { \mathrm { w i t h } \mathrm { p r o b a b i l i t y } p = \frac { 1 + \delta } { C + 1 } ; } \\ { - \theta , } & { \mathrm { w i t h } \mathrm { p r o b a b i l i t y } 1 - p = \frac { C - \delta } { C + 1 } , } \end{array} \right. } \end{array}
+$$
+
+where $\delta$ is a small positive constant that is smaller than $C$ . The expected cost function of the above problem is $\begin{array} { r } { F ( \theta ) \stackrel { \bullet } { = } \frac { 1 + \delta } { C + 1 } C \theta - \frac { C - \delta } { C + 1 } \theta = \delta \theta } \end{array}$ C−δC+1 θ = δθ, therefore, one should decrease θ to minimize the loss. Reddi et al. (2018) prove that when $C$ is large enough, the expectation of accumulated parameter update in Adam is positive and results in increasing $\theta$ .
+
+Basic Solutions Reddi et al. (2018) propose maintaining the strict positiveness of $\Gamma _ { t }$ as solution, for example, keeping $v _ { t }$ non-decreasing or using increasing $\beta _ { 2 }$ . In fact, keeping $\Gamma _ { t }$ positive is not the only way to guarantee the convergence of Adam. Another important observation is that for any fixed sequential online optimization problem with infinitely repeating epochs (e.g., Equation 6), Adam will converge as long as $\beta _ { 1 }$ is large enough. Formally, we have the following theorem:
+
+Theorem 1 (The influence of $\beta _ { 1 }$ ). For any fixed sequential online convex optimization problem with infinitely repeating of finite length epochs ( $d$ is the length of an epoch), if $\exists G \in \mathbb { R }$ such that $\| \nabla f _ { t } ( \theta ) \| _ { \infty } \leq G$ and $\exists T \in \mathbb { N } , \exists \epsilon _ { 2 } > \epsilon _ { 1 } > 0$ such that $\begin{array} { r } { \epsilon _ { 1 } < \bar { \phi } _ { t } \bar { G } ^ { 2 } < \bar { \epsilon } _ { 2 } } \end{array}$ holds for all $t > T$ , then, for any fixed $\beta _ { 2 } \in [ 0 , 1 )$ , there exists a $\beta _ { 1 } \in [ 0 , 1 )$ such that Adam has average regret $\leq \epsilon _ { 2 }$ ;
+
+The intuition behind Theorem 1 is that, if $\beta _ { 1 }  1$ , then $\begin{array} { r } { m _ { t }  \sum _ { i = 1 } ^ { d } g _ { i } / d } \end{array}$ , i.e., $m _ { t }$ approaches the average gradient of an epoch, according to Equation 5. Therefore, no matter what the adaptive learning rate $\alpha _ { t } / \sqrt { v _ { t } }$ is, Adam will always converge along the correct direction.
+
+# 3 THE CAUSE OF NON-CONVERGENCE: UNBALANCED STEP SIZE
+
+In this section, we study the non-convergence issue by analyzing the counterexamples provided by Reddi et al. (2018). We show that the fundamental problem of common adaptive learning rate methods is that: √ $v _ { t }$ is positively correlated to the scale of gradient $g _ { t }$ , which results in a small step size $\alpha _ { t } / \sqrt { v _ { t } }$ for a large gradient, and a large step size for a small gradient. We argue that such an unbalanced step size is the cause of non-convergence.
+
+We will first define net update factor for the analysis of the accumulated influence of each gradient $g _ { t }$ , then apply the net update factor to study the behaviors of Adam using Equation 6 as an example. The argument will be extended to the stochastic online optimization problem and general cases.
+
+# 3.1 NET UPDATE FACTOR
+
+When $\beta _ { 1 } \neq 0$ , due to the exponential moving effect of $m _ { t }$ , the influence of $g _ { t }$ exists in all of its following timesteps. For timestep $i$ $( i \geq t )$ , the weight of $g _ { t }$ is $( 1 - \beta _ { 1 } ) \beta _ { 1 } ^ { i - t }$ . We accordingly define a new tool for our analysis: the net update $n e t ( g _ { t } )$ of each gradient $g _ { t }$ , which is its accumulated influence on the entire optimization process:
+
+$$
+n e t ( g _ { t } ) \triangleq \sum _ { i = t } ^ { \infty } \frac { \alpha _ { i } } { \sqrt { v _ { i } } } [ ( 1 - \beta _ { 1 } ) \beta _ { 1 } ^ { i - t } g _ { t } ] = k ( g _ { t } ) \cdot g _ { t } , \mathrm { ~ w h e r e ~ } k ( g _ { t } ) = \sum _ { i = t } ^ { \infty } \frac { \alpha _ { i } } { \sqrt { v _ { i } } } ( 1 - \beta _ { 1 } ) \beta _ { 1 } ^ { i - t } ,
+$$
+
+and we call $k ( g _ { t } )$ the net update factor of $g _ { t }$ , which is the equivalent accumulated step size for gradient $g _ { t }$ . Note that $k ( g _ { t } )$ depends on $\{ v _ { i } \} _ { i = t } ^ { \infty }$ , and in Adam, if $\beta _ { 1 } \neq 0$ , then all elements in $\bar { \{ } v _ { i } \} _ { i = t } ^ { \infty }$ are related to $g _ { t }$ . Therefore, $k ( g _ { t } )$ is a function of $g _ { t }$ .
+
+It is worth noticing that in Momentum method, $v _ { t }$ is equivalently set as 1. Therefore, we have $k ( g _ { t } ) = \alpha _ { t }$ and $n e t ( g _ { t } ) = \alpha _ { t } g _ { t }$ , which means that the accumulated influence of each gradient $g _ { t }$ in Momentum is the same as vanilla SGD (Stochastic Gradient Decent). Hence, the convergence of Momentum is similar to vanilla SGD. However, in adaptive learning rate methods, $v _ { t }$ is function over the past gradients, which makes its convergence nontrivial.
+
+# 3.2 ANALYSIS ON ONLINE OPTIMIZATION COUNTEREXAMPLES
+
+Note that $v _ { t }$ exists in the definition of net update factor (Equation 8). Before further analyzing the convergence of Adam using the net update factor, we first study the pattern of $v _ { t }$ in the sequential online optimization problem in Equation 6. Since Equation 6 is deterministic, we can derive the formula of $v _ { t }$ as follows:
+
+Lemma 2. In the sequential online optimization problem in Equation 6, denote $\beta _ { 1 } , \beta _ { 2 } \in [ 0 , 1 )$ as the decay rates, $d \in \mathbb { N }$ as the length of an epoch, $n \in \mathbb { N }$ as the index of epoch, and $i \in \{ 1 , 2 , . . . , d \}$ as the index of timestep in one epoch. Then the limit of $v _ { n d + i }$ when $n \to \infty$ is:
+
+$$
+\operatorname * { l i m } _ { n  \infty } v _ { n d + i } = \frac { 1 - \beta _ { 2 } } { 1 - \beta _ { 2 } ^ { d } } ( C ^ { 2 } - 1 ) \beta _ { 2 } ^ { i - 1 } + 1 .
+$$
+
+Given the formula of $v _ { t }$ in Equation 9, we now study the net update factor of each gradient. We start with a simple case where $\beta _ { 1 } = 0$ . In this case we have
+
+$$
+\operatorname* { l i m } _ { n \to \infty } k ( g _ { n d + i } ) = \operatorname* { l i m } _ { n \to \infty } \frac { \alpha _ { t } } { \sqrt { v _ { n d + i } } } .
+$$
+
+Since the limit of $v _ { n d + i }$ in each epoch monotonically decreases with the increase of index $i$ according to Equation 9, the limit of $k ( g _ { n d + i } )$ monotonically increases in each epoch. Specifically, the first gradient $g _ { n d + 1 } = C$ in epoch $n$ represents the correct updating direction, but its influence is the smallest in this epoch. In contrast, the net update factor of the subsequent gradients $- 1$ are relatively larger, though they indicate a wrong updating direction.
+
+We further consider the general case where $\beta _ { 1 } \neq 0$ . The result is presented in the following lemma:
+
+Lemma 3. In the sequential online optimization problem in Equation 6, when $n \to \infty$ , the limit of net update factor $k ( g _ { n d + i } )$ of epoch $n$ satisfies: $\exists 1 \leq j \leq d$ such that
+
+$$
+\operatorname* { l i m } _ { n \to \infty } k ( C ) = \operatorname* { l i m } _ { n \to \infty } k ( g _ { n d + 1 } ) < \operatorname* { l i m } _ { n \to \infty } k ( g _ { n d + 2 } ) < \cdots < \operatorname* { l i m } _ { n \to \infty } k ( g _ { n d + j } ) ,
+$$
+
+and
+
+$$
+\operatorname* { l i m } _ { n \to \infty } k ( g _ { n d + j } ) > \operatorname* { l i m } _ { n \to \infty } k ( g _ { n d + j + 1 } ) > \cdots > \operatorname* { l i m } _ { n \to \infty } k ( g _ { n d + d + 1 } ) = \operatorname* { l i m } _ { n \to \infty } k ( C ) ,
+$$
+
+where $k ( C )$ denotes the net update factor for gradient $g _ { i } = C$ .
+
+Lemma 3 tells us that, in sequential online optimization problem in Equation 6, the net update factors are unbalanced. Specifically, the net update factor for the large gradient $C$ is the smallest in the entire epoch, while all gradients $- 1$ have larger net update factors. Such unbalanced net update factors will possibly lead Adam to a wrong accumulated update direction.
+
+Similar conclusion also holds in the stochastic online optimization problem in Equation 7. We derive the expectation of the net update factor for each gradient in the following lemma:
+
+Lemma 4. In the stochastic online optimization problem in Equation 7, assuming $\alpha _ { t } = 1$ , it holds that $k ( C ) < k ( - 1 )$ , where $k ( C )$ denote the expectation net update factor for $g _ { i } = C$ and $k ( - 1 )$ denote the expectation net update factor for $g _ { i } = - 1$ .
+
+Though the formulas of net update factors in the stochastic case are more complicated than those in deterministic case, the analysis is actually more easier: the gradients with the same scale share the same expected net update factor, so we only need to analyze $k ( C )$ and $k ( - 1 )$ . From Lemma 4, we can see that in terms of the expectation net update factor, $k ( C )$ is smaller than $k ( - 1 )$ , which means the accumulated influence of gradient $C$ is smaller than gradient $- 1$ .
+
+# 3.3 ANALYSIS ON NON-CONVERGENCE OF ADAM
+
+As we have observed in the previous section, a common characteristic of these counterexamples is that the net update factor for the gradient with large magnitude is smaller than these with small magnitude. The above observation can also be interpreted as a direct consequence of inappropriate correlation between $v _ { t }$ and $g _ { t }$ . Recall that $v _ { t } = \beta _ { 2 } { v _ { t - 1 } } + ( 1 - \beta _ { 2 } ) g _ { t } ^ { 2 }$ . Assuming $v _ { t - 1 }$ is independent of $g _ { t }$ , then: when a new gradient $g _ { t }$ arrives, if $g _ { t }$ is large, $v _ { t }$ is likely to be larger; and if $g _ { t }$ is small, $v _ { t }$ is also likely to be smaller. If $\beta _ { 1 } = 0$ , then $k ( g _ { t } ) = \alpha _ { t } / \sqrt { v _ { t } }$ . As a result, a large gradient is likely to have a small net update factor, while a small gradient is likely to have a large net update factor in Adam.
+
+When it comes to the scenario where $\beta _ { 1 } > 0$ , the arguments are actually quite similar. Given $v _ { t } =$ $\beta _ { 2 } v _ { t - 1 } + ( 1 - \beta _ { 2 } ) g _ { t } ^ { 2 }$ . Assuming $v _ { t - 1 }$ and $\{ g _ { t + i } \} _ { i = 1 } ^ { \infty }$ are independent from $g _ { t }$ , then: not only does $v _ { t }$ positively correlate with the magnitude of , but also the entire infinite sequence $\{ v _ { i } \} _ { i = t } ^ { \infty }$ positively correlates with the magnitude of $g _ { t }$ . Since the net update factor $\begin{array} { r } { k ( g _ { t } ) = \sum _ { i = t } ^ { \infty } \ \alpha _ { i } / \sqrt { v _ { i } } ( 1 - \beta _ { 1 } ) \beta _ { 1 } ^ { i - t } } \end{array}$ negatively correlates with each $v _ { i }$ in $\{ v _ { i } \} _ { i = t } ^ { \infty }$ , it is thus negatively correlated with the magnitude of $g _ { t }$ . That is, $k ( g _ { t } )$ for a large gradient is likely to be smaller, while $k ( g _ { t } )$ for a small gradient is likely to be larger.
+
+The unbalanced net update factors cause the non-convergence problem of Adam as well as all other adaptive learning rate methods where $v _ { t }$ correlates with $g _ { t }$ . To construct a counterexample, the same pattern is that: the large gradient is along the “correct” direction, while the small gradient is along the opposite direction. Due to the fact that the accumulated influence of a large gradient is small while the accumulated influence of a small gradient is large, Adam may update parameters along the wrong direction.
+
+Finally, we would like to emphasize that even if Adam updates parameters along the right direction in general, the unbalanced net update factors are still unfavorable since they slow down the convergence.
+
+# 4 THE PROPOSED METHOD: DECORRELATION VIA TEMPORAL SHIFTING
+
+According to the previous discussion, we conclude that the main cause of the non-convergence of Adam is the inappropriate correlation between $v _ { t }$ and $g _ { t }$ . Currently we have two possible solutions: (1) making $v _ { t }$ act like a constant, which declines the correlation, e.g., using a large $\beta _ { 2 }$ or keep $v _ { t }$ nondecreasing (Reddi et al., 2018); (2) using a large $\beta _ { 1 }$ (Theorem 1), where the aggressive momentum term helps to mitigate the impact of unbalanced net update factors. However, neither of them solves the problem fundamentally.
+
+The dilemma caused by $v _ { t }$ enforces us to rethink its role. In adaptive learning rate methods, $v _ { t }$ plays the role of estimating the second moments of gradients, which reflects the scale of gradient on average. With the adaptive learning rate $\alpha _ { t } / \sqrt { v _ { t } }$ , the update step of $g _ { t }$ is scaled down by $\sqrt { v _ { t } }$ and achieves rescaling invariance with respect to the scale of $g _ { t }$ , which is practically useful to make the training process easy to control and the training system robust. However, the current scheme of $v _ { t }$ , i.e., $v _ { t } = \beta _ { 2 } v _ { t - 1 } + ( 1 - \beta _ { 2 } ) g _ { t } ^ { 2 }$ , brings a positive correlation between $v _ { t }$ and $g _ { t }$ , which results in reducing the effect of large gradients and increasing the effect of small gradients, and finally causes the non-convergence problem. Therefore, the key is to let $v _ { t }$ be a quantity that reflects the scale of the gradients, while at the same time, be decorrelated with current gradient $g _ { t }$ . Formally, we have the following theorem:
+
+Theorem 5 (Decorrelation leads to convergence). For any fixed online optimization problem with infinitely repeating of a finite set of cost functions $\{ f _ { 1 } ( { \boldsymbol { \theta } } ) , \dots , f _ { t } ( { \boldsymbol { \theta } } ) , \dots { \bar { f } } _ { n } ( { \boldsymbol { \theta } } ) \}$ , assuming $\beta _ { 1 } = 0$ and $\alpha _ { t }$ is fixed, we have, if $v _ { t }$ follows a fixed distribution and is independent of the current gradient $g _ { t }$ , then the expected net update factor for each gradient is identical.
+
+Let $P _ { v }$ denote the distribution of $v _ { t }$ . In the infinitely repeating online optimization scheme, the expectation of net update factor for each gradient $g _ { t }$ is
+
+$$
+\mathbb { E } [ k ( g _ { t } ) ] = \sum _ { i = t } ^ { \infty } \mathbb { E } _ { v _ { i } \sim P _ { v } } [ \frac { \alpha _ { i } } { \sqrt { v _ { i } } } ( 1 - \beta _ { 1 } ) \beta _ { 1 } ^ { i - t } ] .
+$$
+
+Given $P _ { v }$ is independent of $g _ { t }$ , the expectation of the net update factor $\mathbb { E } [ k ( g _ { t } ) ]$ is independent of $g _ { t }$ and remains the same for different gradients. With the expected net update factor being a fixed constant, the convergence of the adaptive learning rate method reduces to vanilla SGD.
+
+Momentum (Qian, 1999) can be viewed as setting $v _ { t }$ as a constant, which makes $v _ { t }$ and $g _ { t }$ independent. Furthermore, in our view, using an increasing $\beta _ { 2 }$ (AdamNC) or keeping $\hat { v _ { t } }$ as the largest $v _ { t }$ (AMSGrad) is also to make $v _ { t }$ almost fixed. However, fixing $v _ { t }$ is not a desirable solution, because it damages the adaptability of Adam with respect to the adapting of step size.
+
+We next introduce the proposed solution to make $v _ { t }$ independent of $g _ { t }$ , which is based on temporal independent assumption among gradients. We first introduce the idea of temporal decorrelation, then extend our solution to make use of the spatial information of gradients. Finally, we incorporate first moment estimation. The pseudo code of the proposed algorithm is presented as follows.
+
+# Algorithm 1 AdaShift: Temporal Shifting with Block-wise Spatial Operation
+
+Input: $n , \beta _ { 1 } , \beta _ { 2 } , \phi , \theta _ { 0 } , \{ f _ { t } ( \theta ) \} _ { t = 1 } ^ { T } , \{ \alpha _ { t } \} _ { t = 1 } ^ { T } , \{ g _ { - t } \} _ { t = 0 } ^ { n - 1 } ,$ ,   
+$v _ { 0 } = 0$   
+2: for $t = 1$ to $T$ do   
+3: $g _ { t } = \nabla f _ { t } ( \theta _ { t } )$   
+4: $\begin{array} { r } { m _ { t } = \sum _ { i = 0 } ^ { n - 1 } \beta _ { 1 } ^ { i } g _ { t - i } / \sum _ { i = 0 } ^ { n - 1 } \beta _ { 1 } ^ { i } } \end{array}$   
+5: for $i = 1$ to M do   
+6: $v _ { t } [ i ] = \beta _ { 2 } v _ { t - 1 } [ i ] + ( 1 - \beta _ { 2 } ) \phi ( g _ { t - n } ^ { 2 } [ i ] )$   
+7: $\theta _ { t } [ i ] = \theta _ { t - 1 } [ i ] - \alpha _ { t } / \sqrt { v _ { t } [ i ] } \cdot m _ { t } [ i$ ]   
+8: end for   
+9: end for   
+10: // We ignore the bias-correction, epsilon and other misc for the sake of clarity
+
+# 4.1 TEMPORAL DECORRELATION
+
+In practical setting, $f _ { t } ( \theta )$ usually involves different mini-batches $x _ { t }$ , i.e., $f _ { t } ( \theta ) = f ( \theta ; x _ { t } )$ . Given the randomness of mini-batch, we assume that the mini-batch $x _ { t }$ is independent of each other and further assume that $f ( \theta ; x )$ keeps unchanged over time, then the gradient $g _ { t } = \nabla f ( \theta ; x _ { t } )$ of each mini-batch is independent of each other.
+
+Therefore, we could change the update rule for $v _ { t }$ to involve $g _ { t - n }$ instead of $g _ { t }$ , which makes $v _ { t }$ and $g _ { t }$ temporally shifted and hence decorrelated:
+
+$$
+v _ { t } = \beta _ { 2 } v _ { t - 1 } + ( 1 - \beta _ { 2 } ) g _ { t - n } ^ { 2 } .
+$$
+
+Note that in the sequential online optimization problem, the assumption $^ { \bullet } g _ { t }$ is independent of each other” does not hold. However, in the stochastic online optimization problem and practical neural network settings, our assumption generally holds.
+
+# 4.2 MAKING USE OF THE SPATIAL ELEMENTS OF PREVIOUS TIMESTEPS
+
+Most optimization schemes involve a great many parameters. The dimension of $\theta$ is high, thus $g _ { t }$ and $v _ { t }$ are also of high dimension. However, $v _ { t }$ is element-wisely computed in Equation 14. Specifically, we only use the $i$ -th dimension of $g _ { t - n }$ to calculate the $i$ -th dimension of $v _ { t }$ . In other words, it only makes use of the independence between $g _ { t - n } [ i ]$ and $g _ { t } [ i ]$ , where $g _ { t } [ i ]$ denotes the $i$ -th element of $g _ { t }$ . Actually, in the case of high-dimensional $g _ { t }$ and $v _ { t }$ , we can further assume that all elements of gradient $g _ { t - n }$ at previous timesteps are independent with the $i$ -th dimension of $g _ { t }$ . Therefore, all elements in $g _ { t - n }$ can be used to compute $v _ { t }$ without introducing correlation. To this end, we propose introducing a function $\phi$ over all elements of $g _ { t - n } ^ { 2 }$ , i.e.,
+
+$$
+v _ { t } = \beta _ { 2 } v _ { t - 1 } + ( 1 - \beta _ { 2 } ) \phi ( g _ { t - n } ^ { 2 } ) .
+$$
+
+For easy reference, we name the elements of $g _ { t - n }$ other than $g _ { t - n } [ i ]$ as the spatial elements of $g _ { t - n }$ and name $\phi$ the spatial function or spatial operation. There is no restriction on the choice of $\phi$ , and we use $\phi ( x ) = \mathrm { m a x } _ { i } x [ i ]$ for most of our experiments, which is shown to be a good choice. The $\operatorname* { m a x } _ { i } x [ i ]$ operation has a side effect that turns the adaptive learning rate $v _ { t }$ into a shared scalar.
+
+An important thing here is that, we no longer interpret $v _ { t }$ as the second moment of $g _ { t }$ . It is merely a random variable that is independent of $g _ { t }$ , while at the same time, reflects the overall gradient scale. We leave further investigations on $\phi$ as future work.
+
+# 4.3 BLOCK-WISE ADAPTIVE LEARNING RATE SGD
+
+In practical setting, e.g., deep neural network, $\theta$ usually consists of many parameter blocks, e.g., the weight and bias for each layer. In deep neural network, the gradient scales (i.e., the variance) for different layers tend to be different (Glorot & Bengio, 2010; He et al., 2015). Different gradient scales make it hard to find a learning rate that is suitable for all layers, when using SGD and Momentum methods. In traditional adaptive learning rate methods, they apply element-wise rescaling for each gradient dimension, which achieves rescaling-invariance and somehow solves the above problem. However, Adam sometimes does not generalize better than SGD (Wilson et al., 2017; Keskar & Socher, 2017), which might relate to the excessive learning rate adaptation in Adam.
+
+In our temporal decorrelation with spatial operation scheme, we can solve the “different gradient scales” issue more naturally, by applying $\phi$ block-wisely and outputs a shared adaptive learning rate scalar $v _ { t } [ i ]$ for each block:
+
+$$
+v _ { t } [ i ] = \beta _ { 2 } v _ { t - 1 } [ i ] + ( 1 - \beta _ { 2 } ) \phi ( g _ { t - n } ^ { 2 } [ i ] ) .
+$$
+
+It makes the algorithm work like an adaptive learning rate SGD, where each block has an adaptive learning rate $\alpha _ { t } / \sqrt { v _ { t } [ i ] }$ while the relative gradient scale among in-block elements keep unchanged. As illustrated in Algorithm 1, the parameters $\theta _ { t }$ including the related $g _ { t }$ and $v _ { t }$ are divided into $M$ blocks. Every block contains the parameters of the same type or same layer in neural network.
+
+# 4.4 INCORPORATING FIRST MOMENT ESTIMATION: MOVING AVERAGING WINDOWS
+
+First moment estimation, i.e., defining $m _ { t }$ as a moving average of $g _ { t }$ , is an important technique of modern first order optimization algorithms, which alleviates mini-batch oscillations. In this section, we extend our algorithm to incorporate first moment estimation.
+
+We have argued that $v _ { t }$ needs to be decorrelated with $g _ { t }$ . Analogously, when introducing the first moment estimation, we need to make $v _ { t }$ and $m _ { t }$ independent to make the expected net update factor unbiased. Based on our assumption of temporal independence, we further keep out the latest $n$ gradients $\{ g _ { t - i } \} _ { i = 0 } ^ { n - 1 }$ , and update $v _ { t }$ and $m _ { t }$ via
+
+$$
+v _ { t } = \beta _ { 2 } v _ { t - 1 } + ( 1 - \beta _ { 2 } ) \phi ( g _ { t - n } ^ { 2 } ) \mathrm { a n d } m _ { t } = \frac { \sum _ { i = 0 } ^ { n - 1 } \beta _ { 1 } ^ { i } g _ { t - i } } { \sum _ { i = 0 } ^ { n - 1 } \beta _ { 1 } ^ { i } } .
+$$
+
+In Equation 17, $\beta _ { 1 } \in [ 0 , 1 ]$ plays the role of decay rate for temporal elements. It can be viewed as a truncated version of exponential moving average that only applied to the latest few elements. Since we use truncating, it is feasible to use large $\beta _ { 1 }$ without taking the risk of using too old gradients. In the extreme case where $\beta _ { 1 } = 1$ , it becomes vanilla averaging.
+
+The pseudo code of the algorithm that unifies all proposed techniques is presented in Algorithm 1 and a more detailed version can be found in the Appendix. It has the following parameters: spatial operation $\phi$ , $n \in \mathbb { N } ^ { + }$ , $\beta _ { 1 } \in [ 0 , 1 ]$ , $\beta _ { 2 } \in [ 0 , 1 )$ and $\alpha _ { t }$ .
+
+Summary The key difference between Adam and the proposed method is that the latter temporally shifts the gradient $g _ { t }$ for $n$ -step, i.e., using $g _ { t - n }$ for calculating $v _ { t }$ and using the kept-out $n$ gradients to evaluate $m _ { t }$ (Equation 17), which makes $v _ { t }$ and $m _ { t }$ decorrelated and consequently solves the nonconvergence issue. In addition, based on our new perspective on adaptive learning rate methods, $v _ { t }$ is not necessarily the second moment and it is valid to further involve the calculation of $v _ { t }$ with the spatial elements of previous gradients. We thus proposed to introduce the spatial operation $\phi$ that outputs a shared scalar for each block. The resulting algorithm turns out to be closely related to SGD, where each block has an overall adaptive learning rate and the relative gradient scale in each block is maintained. We name the proposed method that makes use of temporal-shifting to decorrelated $v _ { t }$ and $m _ { t }$ AdaShift, which means “ADAptive learning rate method with temporal SHIFTing”.
+
+# 5 EXPERIMENTS
+
+In this section, we empirically study the proposed method and compare them with Adam, AMSGrad and SGD, on various tasks in terms of training performance and generalization. Without additional declaration, the reported result for each algorithm is the best we have found via parameter grid search. The anonymous code is provided at http://bit.ly/2NDXX6x.
+
+# 5.1 ONLINE OPTIMIZATION COUNTEREXAMPLES
+
+Firstly, we verify our analysis on the stochastic online optimization problem in Equation 7, where we set $C = 1 0 1$ and $\delta = 0 . 0 2$ . We compare Adam, AMSGrad and AdaShift in this experiment. For fair comparison, we set $\alpha = 0 . 0 0 1$ , $\beta _ { 1 } = 0$ and $\beta _ { 2 } = 0 . 9 9 9$ for all these methods. The results are shown in Figure 1a. We can see that Adam tends to increase $\theta$ , that is, the accumulate update of $\theta$ in Adam is along the wrong direction, while AMSGrad and AdaShift update $\theta$ in the correct direction. Furthermore, given the same learning rate, AdaShift decreases $\theta$ faster than AMSGrad, which validates our argument that AMSGrad has a relatively higher $v _ { t }$ that slows down the training.
+
+In this experiment, we also verify Theorem 1. As shown in Figure 1b, Adam is also able to converge to the correct direction with a sufficiently large $\beta _ { 1 }$ and $\beta _ { 2 }$ . Note that (1) AdaShift still converges with the fastest speed; (2) a small $\beta _ { 1 }$ (e.g., $\beta _ { 1 } = 0 . 9$ , the light-blue line in Figure 1b) does not make Adam converge to the correct direction. We do not conduct the experiments on the sequential online optimization problem in Equation 6, because it does not fit our temporal independence assumption. To make it converge, one can use a large $\beta _ { 1 }$ or $\beta _ { 2 }$ , or set $v _ { t }$ as a constant.
+
+![](images/b67d5d57908700704c39f9f77b9ca18b3c4e531139cdd09843ed80f54b70e8b2.jpg)  
+Figure 1: Experiments on stochastic counterexample.
+
+5.2 LOGISTIC REGRESSION AND MULTILAYER PERCEPTRON ON MNIST
+
+We further compare the proposed method with Adam, AMSGrad and SGD by using Logistic Regression and Multilayer Perceptron on MNIST, where the Multilayer Perceptron has two hidden layers and each has 256 hidden units with no internal activation. The results are shown in Figure 2 and Figure 3, respectively. We find that in Logistic Regression, these learning algorithms achieve very similar final results in terms of both training speed and generalization. In Multilayer Perceptron, we compare Adam, AMSGrad and AdaShift with reduce-max spatial operation (max-AdaShift) and without spatial operation (non-AdaShift). We observe that max-AdaShift achieves the lowest training loss, while non-AdaShift has mild training loss oscillation and at the same time achieves better generalization. The worse generalization of max-AdaShift may be due to overfitting in this task, and the better generalization of non-AdaShift may stem from the regularization effect of its relatively unstable step size.
+
+# 5.3 DENSENET AND RESNET ON CIFAR-10
+
+ResNet (He et al., 2016) and DenseNet (Huang et al., 2017) are two typical modern neural networks, which are efficient and widely-used. We test our algorithm with ResNet and DenseNet on CIFAR10 datasets. We use a 18-layer ResNet and 100-layer DenseNet in our experiments. We plot the best results of Adam, AMSGrad and AdaShift in Figure 4 and Figure 5 for ResNet and DenseNet, respectively. We can see that AMSGrad is relatively worse in terms of both training speed and generalization. Adam and AdaShift share competitive results, while AdaShift is generally slightly better, especially the test accuracy of ResNet and the training loss of DenseNet.
+
+![](images/bd51369853f8aec60078c8659a93d415440cb9b18bfc71be48f83a7050035ea0.jpg)  
+Figure 2: Logistic Regression on MNIST.
+
+![](images/8e66fbbe4e0b50013bb35536a392346c0e1b9c4e541224ee110184b81109212a.jpg)  
+Figure 3: Multilayer Perceptron on MNIST.
+
+![](images/fbaa38bd707fe0382ac36d2d9e629a004ebf88e1ce77a74afb68adaee66797ed.jpg)  
+Figure 4: ResNet on Cifar-10.
+
+![](images/c04f60e04a7ca3c512459a0a3dee778074683efb1679b4d8ecc4b5fd55bb6470.jpg)  
+Figure 5: DenseNet on Cifar-10.
+
+# 5.4 DENSENET WITH TINY-IMAGENET
+
+We further increase the complexity of dataset, switching from CIFAR-10 to Tiny-ImageNet, and compare the performance of Adam, AMSGrad and AdaShift with DenseNet. The results are shown in Figure 6, from which we can see that the training curves of Adam and AdaShift are basically overlapped, but AdaShift achieves higher test accuracy than Adam. AMSGrad has relatively higher training loss, and its test accuracy is relatively lower at the initial stage.
+
+# 5.5 GENERATIVE MODEL AND RECURRENT MODEL
+
+We also test our algorithm on the training of generative model and recurrent model. We choose WGAN-GP (Gulrajani et al., 2017) that involves Lipschitz continuity condition (which is hard to optimize), and Neural Machine Translation (NMT) (Luong et al., 2017) that involves typical recurrent unit LSTM, respectively. In Figure 7a, we compare the performance of Adam, AMSGrad and AdaShift in the training of WGAN-GP discriminator, given a fixed generator. We notice that AdaShift is significantly better than Adam, while the performance of AMSGrad is relatively unsatisfactory. The test performance in terms of BLEU of NMT is shown in Figure 7b, where AdaShift achieves a higher BLEU than Adam and AMSGrad.
+
+![](images/20ec1a7deed75bd258b76d979f134c79b4c8916ef2e3b7b9b540f7bc15630ddc.jpg)  
+Figure 6: DenseNet on Tiny-ImageNet.
+
+![](images/a5e0903b8c3033d4c49375bc3b49d4d104ad2cb273564be3e66dd307ff9e10b6.jpg)  
+Figure 7: Generative and Recurrent model.
+
+# 6 CONCLUSION
+
+In this paper, we study the non-convergence issue of adaptive learning rate methods from the perspective of the equivalent accumulated step size of each gradient, i.e., the net update factor defined in this paper. We show that there exists an inappropriate correlation between $v _ { t }$ and $g _ { t }$ , which leads to unbalanced net update factor for each gradient. We demonstrate that such unbalanced step sizes are the fundamental cause of non-convergence of Adam, and we further prove that decorrelating $v _ { t }$ and $g _ { t }$ will lead to unbiased expected step size for each gradient, thus solving the non-convergence problem of Adam. Finally, we propose AdaShift, a novel adaptive learning rate method that decorrelates $v _ { t }$ and $g _ { t }$ via calculating $v _ { t }$ using temporally shifted gradient $g _ { t - n }$ .
+
+In addition, based on our new perspective on adaptive learning rate methods, $v _ { t }$ is no longer necessarily the second moment of $g _ { t }$ , but a random variable that is independent of $g _ { t }$ and reflects the overall gradient scale. Thus, it is valid to calculate $v _ { t }$ with the spatial elements of previous gradients. We further found that when the spatial operation $\phi$ outputs a shared scalar for each block, the resulting algorithm turns out to be closely related to SGD, where each block has an overall adaptive learning rate and the relative gradient scale in each block is maintained. The experiment results demonstrate that AdaShift is able to solve the non-convergence issue of Adam. In the meantime, AdaShift achieves competitive and even better training and testing performance when compared with Adam.
+
+# REFERENCES
+
+Timothy Dozat. Incorporating nesterov momentum into adam. International Conference on Learning Representations, Workshop track, 2016.
+
+Xavier Glorot and Yoshua Bengio. Understanding the difficulty of training deep feedforward neural networks. In Proceedings of the thirteenth international conference on artificial intelligence and statistics, pp. 249–256, 2010.
+
+Ishaan Gulrajani, Faruk Ahmed, Martin Arjovsky, Vincent Dumoulin, and Aaron C Courville. Improved training of wasserstein gans. In Advances in Neural Information Processing Systems, pp. 5767–5777, 2017.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. In Proceedings of the IEEE international conference on computer vision, pp. 1026–1034, 2015.
+
+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.
+
+Gao Huang, Zhuang Liu, Laurens Van Der Maaten, and Kilian Q Weinberger. Densely connected convolutional networks. 2017.
+
+Nitish Shirish Keskar and Richard Socher. Improving generalization performance by switching from adam to sgd. arXiv preprint arXiv:1712.07628, 2017.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Minh-Thang Luong, Eugene Brevdo, and Rui Zhao. Neural machine translation (seq2seq) tutorial. https://github.com/tensorflow/nmt, 2017.
+
+Ning Qian. On the momentum term in gradient descent learning algorithms. Neural networks, 12 (1):145–151, 1999.
+
+Ali Rahimi and Ben Recht. test of time talk at nips 2017. URL http://www.argmin.net/ 2017/12/11/alchemy-addendum/.
+
+Sashank J. Reddi, Satyen Kale, and Sanjiv Kumar. On the convergence of adam and beyond. In International Conference on Learning Representations, 2018. URL https://openreview. net/forum?id=ryQu7f-RZ.
+
+Tijmen Tieleman and Geoffrey Hinton. Lecture 6.5-rmsprop: Divide the gradient by a running average of its recent magnitude. COURSERA: Neural networks for machine learning, 4(2):26– 31, 2012.
+
+Ashia C Wilson, Rebecca Roelofs, Mitchell Stern, Nati Srebro, and Benjamin Recht. The marginal value of adaptive gradient methods in machine learning. In Advances in Neural Information Processing Systems, pp. 4148–4158, 2017.
+
+Matthew D Zeiler. Adadelta: an adaptive learning rate method. arXiv preprint arXiv:1212.5701, 2012.
+
+![](images/0f1428bf9a4b5ea3e7038a6fc053cf608aa64dd49c3d7f51c95a51345e47f0b9.jpg)
+
+![](images/0b88985c986fbd97c6e83f175daa5f7cc99b1b609e0bbe5044a8dd861b65f749.jpg)  
+(a) Final result of $\theta$ for sequential problem after 2000 updates, varied with $\beta _ { 1 }$ and $\beta _ { 2 }$ .
+
+(b) Critical value of $C$ with varying $\beta _ { 1 }$ and $\beta _ { 2 }$ under the sequential optimization setting.
+
+![](images/9e4358443f5c208023f7f61ce5f96916b5e7409efd53fbae328f6e7121cd711c.jpg)
+
+![](images/38e63ad53b224fa9722d6f5a883d1a05903150e6fec5456ac478dc85509086d6.jpg)  
+(d) Critical value of $C$ with varying $\beta _ { 1 }$ and $\beta _ { 2 }$ under the stochastic optimization setting.
+
+(c) Final result of $\theta$ for stochastic problem after 2000 updates, varied with $\beta _ { 1 }$ and $\beta _ { 2 }$ .
+
+Figure 8: Both $\beta _ { 1 }$ and $\beta _ { 2 }$ influence the direction and speed of optimization in Adam. Critical value of $C _ { t }$ , at which Adam gets into non-convergence, increases as $\beta _ { 1 }$ and $\beta _ { 2 }$ getting large. Leftmost two for the sequential online optimization problem and rightmost two for stochastic online problem.
+
+# A THE RELATION AMONG $\beta _ { 1 }$ , $\beta _ { 2 }$ AND $C$
+
+To provide an intuitive impression on the relation among $C , d , \beta _ { 1 } , \beta _ { 2 }$ and the convergence of Adam, we let $C = d = 6 $ , initialize $\theta _ { 1 } = 0$ , vary $\beta _ { 1 }$ and $\beta _ { 2 }$ among $[ 0 , 1 )$ and let Adam go through 2000 timesteps (iterations). The final result of $\theta$ is shown in Figure 8a. It suggests that for a fixed sequential online optimization problem, both of $\beta _ { 1 }$ and $\beta _ { 2 }$ determine the direction and speed of Adam optimization process. Furthermore, we also study the threshold point of $C$ and $d$ , under which Adam will change to the incorrect direction, for each fixed $\beta _ { 1 }$ and $\beta _ { 2 }$ that vary among $[ 0 , 1 )$ . To simplify the experiments, we keep $d = C$ such that the overall gradient of each epoch being $+ 1$ . The result is shown in Figure 8b, which suggests, at the condition of larger $\beta _ { 1 }$ or larger $\beta _ { 2 }$ , it needs a larger $C$ to make Adam stride on the opposite direction. In other words, large $\beta _ { 1 }$ and $\beta _ { 2 }$ will make the non-convergence rare to happen.
+
+We also conduct the experiment in the stochastic problem to analyze the relation among $C$ , $\beta _ { 1 }$ , $\beta _ { 2 }$ and the convergence behavior of Adam. Results are shown in the Figure 8c and Figure 8d and the observations are similar to the previous: larger $C$ will cause non-convergence more easily and a larger $\beta _ { 1 }$ or $\beta _ { 2 }$ somehow help to resolve non-convergence issue. In this experiment, we set $\delta = 1$ .
+
+Lemma 6 (Critical condition). In the sequential online optimization problem Equation 6, let $\alpha _ { t }$ being fixed, define $S ( \beta _ { 1 } , \beta _ { 2 } , C , d )$ to be the sum of the limits of step updates in a $d$ -step epoch:
+
+$$
+\begin{array} { l } { \displaystyle { S ( \beta _ { 1 } , \beta _ { 2 } , C ) \triangleq \sum _ { i = 1 } ^ { d } \operatorname* { l i m } _ { n d  \infty } \frac { m _ { n d + i } } { \sqrt { v _ { n d + i } } } . } } \end{array}
+$$
+
+Let $S ( \beta _ { 1 } , \beta _ { 2 } , C ) = 0$ , assuming $\beta _ { 2 }$ and $C$ are large enough such that $v _ { t } \gg 1$ , we get the equation:
+
+$$
+C + 1 = \frac { ( 1 - \beta _ { 1 } ^ { d } ) ( \sqrt { \beta _ { 2 } ^ { d } } - \beta _ { 1 } ^ { d } ) ( 1 - \sqrt { \beta _ { 2 } } ) } { ( 1 - \beta _ { 1 } ) ( \sqrt { \beta _ { 2 } } - \beta _ { 1 } ) ( 1 - \sqrt { \beta _ { 2 } ^ { d } } ) } .
+$$
+
+Equation 19, though being quite complex, tells that both $\beta _ { 1 }$ and $\beta _ { 2 }$ are closely related to the counterexamples, and there exists a critical condition among these parameters.
+
+# B THE ADASHIFT PSEUDO CODE
+
+Algorithm 2 AdaShift: We use a first-in-first-out queue $Q$ to denote the averaging window with the
+
+<table><tr><td>length of n. Push(Q,gt) denotes pushing vector gt to the tail of Q, while Pop(Q) pops and returns the head vector of Q.And W is the weight vector calculated via β1.</td></tr><tr><td>Input: n,β1,β2,,∈,00,{ft(0)}T=1,{at}T=1</td></tr><tr><td>1:set vo = O,po =1 2:W=[-1,Br-2,., 1,1/∑= 7</td></tr><tr><td>3:fort=i toTdo</td></tr><tr><td>4: gt=Vft(0t)</td></tr><tr><td>5: ift≤nthen</td></tr><tr><td>6: Push(Q,gt) 7: else</td></tr><tr><td>8: 9t-n = Pop(Q)</td></tr><tr><td>9: Push(Q,gt)</td></tr><tr><td>10: mt =W.Q</td></tr><tr><td>11: Pt =Pt-1β2</td></tr><tr><td>12: fori=1 to M do</td></tr><tr><td>13: Ut[i]=β2Ut-1[i]+(1-β2)(g²-n[i])</td></tr><tr><td>14: 0t[i]=0t-1[i]-αt/(√Ut[i]/(1-pt)+∈)·mt[i]</td></tr><tr><td>15: end for</td></tr><tr><td>16: end if 17: end for</td></tr></table>
+
+We provided the anonymous code where a Tensorflow implementation of this algorithm is available.
+
+# C CORRELATION BETWEEN $g _ { t }$ AND $v _ { t }$
+
+In order to verify the correlation between $g _ { t }$ and $v _ { t }$ in Adam and AdaShift, we conduct experiments to calculate the correlation coefficient between $g _ { t }$ and $v _ { t }$ . We train the Multilayer Perceptron on MNIST until converge and gather the gradient of the second hidden layer of each step. Based on these data, we calculate $v _ { t }$ and the correlation coefficient between $g _ { t } [ i ]$ and $g _ { t - n } [ i ]$ , between $g _ { t } [ i ]$ and $g _ { t - n } [ j ]$ and between $g _ { t } [ i ]$ and $v _ { t } [ i ]$ of the last 10 epochs using the Pearson correlation coefficient, which is formulated as follows:
+
+$$
+\rho = \frac { \sum _ { i = 1 } ^ { n } ( X _ { i } - \bar { X } ) ( Y _ { i } - \bar { Y } ) } { \sqrt { \sum _ { i = 1 } ^ { n } ( X _ { i } - \bar { X } ) ^ { 2 } } \sqrt { \sum _ { i = 1 } ^ { n } ( Y _ { i } - \bar { Y } ) ^ { 2 } } } .
+$$
+
+To verify the temporal correlation between $g _ { t } [ i ]$ and $g _ { t - n } [ i ]$ , we range $n$ from 1 to 10 and calculate the average temporal correlation coefficient of all variables $i$ . Results are shown in Table 1.
+
+Table 1: Temporal correlation coefficient between $g _ { t } [ i ]$ and $g _ { t - n } [ i ]$ .   
+
+<table><tr><td rowspan=1 colspan=1>n</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>5</td></tr><tr><td rowspan=1 colspan=1>p</td><td rowspan=1 colspan=1>-0.000368929</td><td rowspan=1 colspan=1>-0.000989286</td><td rowspan=1 colspan=1>-0.001540511</td><td rowspan=1 colspan=1>-0.00116966</td><td rowspan=1 colspan=1>-0.001613395</td></tr><tr><td rowspan=1 colspan=1>n</td><td rowspan=1 colspan=1>6</td><td rowspan=1 colspan=1>7</td><td rowspan=1 colspan=1>8</td><td rowspan=1 colspan=1>9</td><td rowspan=1 colspan=1>10</td></tr><tr><td rowspan=1 colspan=1>p</td><td rowspan=1 colspan=1>-0.001211721</td><td rowspan=1 colspan=1>0.000357474</td><td rowspan=1 colspan=1>-0.00082293</td><td rowspan=1 colspan=1>-0.001755237</td><td rowspan=1 colspan=1>-0.001267641</td></tr></table>
+
+To verify the spatial correlation between $g _ { t } [ i ]$ and $g _ { t - n } [ j ]$ , we again range $n$ from 1 to 10 and randomly sample some pairs of $i$ and $j$ and calculate the average spatial correlation coefficient of all the selected pairs. Results are shown in Table 2.
+
+To verify the correlation between $g _ { t } [ i ]$ and $v _ { t } [ i ]$ within Adam, we calculate $v _ { t }$ and the average correlation coefficient between $g _ { t } ^ { 2 }$ and $v _ { t }$ of all variables $i$ . The result is 0.435885276.
+
+To verify the correlation between $g _ { t - n } [ i ]$ and $v _ { t } [ i ]$ within non-AdaShift and between $g _ { t - n } [ i ]$ and $v _ { t }$ within max-AdaShift, we range the keep number $n$ from 1 to 10 to calculate $v _ { t }$ and the average correlation coefficient of all variables $i$ . The result is shown in Table 3 and Table 4.
+
+Table 2: Spatial correlation coefficient between $g _ { t } [ i ]$ and $g _ { t - n } [ j ]$ .   
+
+<table><tr><td rowspan=1 colspan=1>n</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>5</td></tr><tr><td rowspan=1 colspan=1>p</td><td rowspan=1 colspan=1>-0.000609471</td><td rowspan=1 colspan=1>-0.001948853</td><td rowspan=1 colspan=1>-0.001426661</td><td rowspan=1 colspan=1>0.000904615</td><td rowspan=1 colspan=1>0.000329359</td></tr><tr><td rowspan=1 colspan=1>n</td><td rowspan=1 colspan=1>6</td><td rowspan=1 colspan=1>7</td><td rowspan=1 colspan=1>8</td><td rowspan=1 colspan=1>9</td><td rowspan=1 colspan=1>10</td></tr><tr><td rowspan=1 colspan=1>p</td><td rowspan=1 colspan=1>0.000971337</td><td rowspan=1 colspan=1>-0.000644563</td><td rowspan=1 colspan=1>-0.00137805</td><td rowspan=1 colspan=1>-0.001147973</td><td rowspan=1 colspan=1>-0.000592037</td></tr></table>
+
+Table 3: Correlation coefficient between $g _ { t - n } ^ { 2 } [ i ]$ and $v _ { t } [ i ]$ in non-AdaShift.   
+
+<table><tr><td rowspan=1 colspan=1>n</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>5</td></tr><tr><td rowspan=1 colspan=1>p</td><td rowspan=1 colspan=1>-0.010897023</td><td rowspan=1 colspan=1>-0.010952548</td><td rowspan=1 colspan=1>-0.010890854</td><td rowspan=1 colspan=1>-0.010853069</td><td rowspan=1 colspan=1>-0.010810747</td></tr><tr><td rowspan=1 colspan=1>n</td><td rowspan=1 colspan=1>6</td><td rowspan=1 colspan=1>7</td><td rowspan=1 colspan=1>8</td><td rowspan=1 colspan=1>9</td><td rowspan=1 colspan=1>10</td></tr><tr><td rowspan=1 colspan=1>p</td><td rowspan=1 colspan=1>-0.010777789</td><td rowspan=1 colspan=1>-0.01075946</td><td rowspan=1 colspan=1>-0.010739279</td><td rowspan=1 colspan=1>-0.010728553</td><td rowspan=1 colspan=1>-0.010720019</td></tr></table>
+
+Table 4: Correlation coefficient between $g _ { t - n } ^ { 2 } [ i ]$ and $v _ { t }$ in max-AdaShift.   
+
+<table><tr><td rowspan=1 colspan=1>n</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>5</td></tr><tr><td rowspan=1 colspan=1>p</td><td rowspan=1 colspan=1>-0.000706289</td><td rowspan=1 colspan=1>-0.000794959</td><td rowspan=1 colspan=1>-0.00076306</td><td rowspan=1 colspan=1>-0.000712474</td><td rowspan=1 colspan=1>-0.000668459</td></tr><tr><td rowspan=1 colspan=1>n</td><td rowspan=1 colspan=1>6</td><td rowspan=1 colspan=1>7</td><td rowspan=1 colspan=1>8</td><td rowspan=1 colspan=1>9</td><td rowspan=1 colspan=1>10</td></tr><tr><td rowspan=1 colspan=1>p</td><td rowspan=1 colspan=1>-0.000623162</td><td rowspan=1 colspan=1>-0.000566573</td><td rowspan=1 colspan=1>-0.000542046</td><td rowspan=1 colspan=1>-0.000598015</td><td rowspan=1 colspan=1>-0.000592707</td></tr></table>
+
+# D PROOF OF THEOREM 1
+
+Proof.
+
+With bias correction, the formulation of $m _ { t }$ is written as follows
+
+$$
+m _ { t } = \frac { ( 1 - \beta _ { 1 } ) \sum _ { i = 1 } ^ { t } \beta _ { 1 } ^ { t - i } g _ { i } } { ( 1 - \beta _ { 1 } ) \sum _ { i = 1 } ^ { t } \beta _ { 1 } ^ { t - i } } = \frac { \sum _ { i = 1 } ^ { t } \beta _ { 1 } ^ { t - i } g _ { i } } { \sum _ { i = 1 } ^ { t } \beta _ { 1 } ^ { t - i } } .
+$$
+
+According to L’Hospitals rule, we can draw the following:
+
+$$
+\operatorname* { l i m } _ { \beta _ { 1 } \to 1 } \sum _ { i = 1 } ^ { t } \beta _ { 1 } ^ { t - i } = \operatorname* { l i m } _ { \beta _ { 1 } \to 1 } \frac { 1 - \beta _ { 1 } ^ { t } } { 1 - \beta _ { 1 } } = t .
+$$
+
+Thus,
+
+$$
+\operatorname* { l i m } _ { \beta _ { 1 } \to 1 } m _ { t } = \frac { \sum _ { i = 1 } ^ { t } g _ { i } } { t } .
+$$
+
+According to the definition of limitation, let $\begin{array} { r } { g ^ { * } = \frac { \sum _ { i = 1 } ^ { t } g _ { i } } { t } } \end{array}$ , we have, $\forall \epsilon > 0$ , $\exists \beta _ { 1 } \in ( 0 , 1 )$ , such that
+
+$$
+\| m _ { t } - g ^ { * } \| _ { \infty } < \epsilon .
+$$
+
+We set $\epsilon$ to be $\big | \frac { g ^ { * } } { 2 } \big |$ , then for each dimension of $m _ { t }$ , i.e. $m _ { t } [ i ]$ ,
+
+$$
+\frac { g ^ { * } [ i ] } { 2 } \leq m _ { t } [ i ] \leq \frac { 3 g ^ { * } [ i ] } { 2 }
+$$
+
+So, $m _ { t }$ shares the same sign with $g ^ { * }$ in every dimension.
+
+Given it is a convex optimization problem, let the optimal parameter be $\theta ^ { * }$ , and the maximum step size is $\frac { \alpha _ { t } } { \sqrt { v _ { t } } } G$ that holds $\begin{array} { r } { \epsilon _ { 1 } / G < \frac { \bar { \alpha } _ { t } } { \sqrt { v _ { t } } } G < \epsilon _ { 2 } / G } \end{array}$ , we have,
+
+$$
+\operatorname* { l i m } _ { t \to \infty } \| \theta _ { t } - \theta ^ { * } \| _ { \infty } < \epsilon _ { 2 } / G .
+$$
+
+Given $\| \nabla f _ { t } ( \theta ) \| _ { \infty } \leq G$ , we have $f _ { t } ( \theta ) - f _ { t } ( \theta ^ { * } ) < \epsilon _ { 2 }$ , which implies the average regret
+
+$$
+R ( T ) / T = \sum _ { t = 1 } ^ { T } [ f _ { t } ( \theta _ { t } ) - f _ { t } ( \theta ^ { * } ) ] / T < \epsilon _ { 2 } .
+$$
+
+# E PROOF OF LEMMA 2
+
+Proof. Let $\beta _ { 1 } , \beta _ { 2 } \in [ 0 , 1 )$ , $d \in \mathbb { N }$ , $1 \leq i \leq d$ and $i \in \mathbb N$ .
+
+$$
+\begin{array} { l } { { \displaystyle m _ { n d + i } = ( 1 - \beta _ { 1 } ) \sum _ { j = 1 } ^ { n d + i } \beta _ { 1 } ^ { n d + i - j } g _ { j } } } \\ { { \displaystyle \quad \quad = ( 1 - \beta _ { 1 } ) \left[ ( C + 1 ) \sum _ { j = 0 } ^ { n } \beta _ { 1 } ^ { j d + i - 1 } - \sum _ { j = 0 } ^ { n d + i - 1 } \beta _ { 1 } ^ { j } \right] } } \\ { { \displaystyle \quad \quad = ( 1 - \beta _ { 1 } ) \left[ \frac { 1 - \beta _ { 1 } ^ { ( n + 1 ) d } } { 1 - \beta _ { 1 } ^ { d } } \beta _ { 1 } ^ { i - 1 } ( C + 1 ) - \frac { 1 - \beta _ { 1 } ^ { n d + i } } { 1 - \beta _ { 1 } } \right] } } \\ { { \displaystyle \quad \quad = \frac { 1 - \beta _ { 1 } ^ { ( n + 1 ) d } } { 1 - \beta _ { 1 } ^ { d } } ( 1 - \beta _ { 1 } ) \beta _ { 1 } ^ { i - 1 } ( C + 1 ) - ( 1 - \beta _ { 1 } ^ { n d + i } ) } } \end{array}
+$$
+
+For a fixed $d$ , as $n$ approach infinity, we get the limit of $m _ { n d + i }$ as:
+
+$$
+\operatorname* { l i m } _ { n d  \infty } m _ { n d + i } = \frac { 1 - \beta _ { 1 } } { 1 - \beta _ { 1 } ^ { d } } ( C + 1 ) \beta _ { 1 } ^ { i - 1 } - 1
+$$
+
+Similarly, for $v _ { n d + i }$ :
+
+$$
+\begin{array} { l } { { \displaystyle v _ { n d + i } = \left( 1 - \beta _ { 2 } \right) \sum _ { j = 1 } ^ { n d + i } \beta _ { 2 } ^ { n d + i - j } g _ { j } ^ { 2 } } } \\ { { \displaystyle \qquad = \left( 1 - \beta _ { 2 } \right) \left[ ( C ^ { 2 } - 1 ) \sum _ { j = 0 } ^ { n } \beta _ { 2 } ^ { j d + i - 1 } + \sum _ { j = 0 } ^ { n d + i - 1 } \beta _ { 2 } ^ { j } \right] } } \\ { { \displaystyle \qquad = \left( 1 - \beta _ { 2 } \right) \left[ \frac { 1 - \beta _ { 2 } ^ { ( n + 1 ) d } } { 1 - \beta _ { 2 } ^ { d } } \beta _ { 2 } ^ { i - 1 } ( C ^ { 2 } - 1 ) + \frac { 1 - \beta _ { 2 } ^ { n d + i } } { 1 - \beta _ { 2 } } \right] } } \\ { { \displaystyle \qquad = \frac { 1 - \beta _ { 2 } ^ { ( n + 1 ) d } } { 1 - \beta _ { 2 } ^ { d } } \left( 1 - \beta _ { 2 } \right) \beta _ { 2 } ^ { i - 1 } ( C + 1 ) - \left( 1 - \beta _ { 2 } ^ { n d + i } \right) } } \end{array}
+$$
+
+For a fixed $d$ , as $n$ approach infinity, we get the limit of $v _ { n d + i }$ as:
+
+$$
+\operatorname * { l i m } _ { n d  \infty } v _ { n d + i } = \frac { 1 - \beta _ { 2 } } { 1 - \beta _ { 2 } ^ { d } } ( C ^ { 2 } - 1 ) \beta _ { 2 } ^ { i - 1 } + 1 .
+$$
+
+# F PROOF OF LEMMA 3
+
+Proof. First, we define $\widetilde { V } _ { i }$ as:
+
+$$
+\widetilde V _ { i } = \operatorname* { l i m } _ { n d  \infty } \frac { 1 } { \sqrt { v _ { n d + i } } } = \frac { 1 } { \sqrt { \frac { 1 - \beta _ { 2 } } { 1 - \beta _ { 2 } ^ { d } } ( C ^ { 2 } - 1 ) \beta _ { 2 } ^ { ( i - 1 ) } + 1 } }
+$$
+
+where $1 \leq i \leq d$ and $i \in \mathbb N$ . And $\widetilde { V } _ { i }$ has a period of $d$ . Let $t ^ { ' } = t - n d$ , then we can draw:
+
+$$
+\begin{array} { r l } { \underset { \mathrm { C } ^ { \prime } \times \mathrm { R } ^ { \prime } } { = } } & { V _ { \mathrm { { o } } } ( \lambda _ { 2 , 1 } ) = : - \underset { \mathrm { C } ^ { \prime } \times \mathrm { R } ^ { \prime } } { \overset { \cdot } { \sum } } \underset { \mathrm { C } ^ { \prime } \times \mathrm { R } ^ { \prime } } { = } \langle \frac { \mathrm { S } } { \mathrm { R } ^ { \prime } } , \frac { \mathrm { S } } { \mathrm { R } ^ { \prime } } \rangle _ { \mathrm { C } ^ { \prime } } ^ { 2 } \mathrm { { R } } \mathrm { { R } } ^ { - 1 } } \\ & { - \underset { \mathrm { C } ^ { \prime } \times \mathrm { R } ^ { \prime } } { = } \langle \frac { \mathrm { S } } { \mathrm { R } ^ { \prime } } , \frac { \mathrm { S } } { \mathrm { R } ^ { \prime } } , \frac { \mathrm { S } } { \mathrm { R } ^ { \prime } } \rangle _ { \mathrm { C } ^ { \prime } } ^ { 2 } \mathrm { { R } } \mathrm { { R } } ^ { - 1 } + 1 } \\ & { - \underset { \mathrm { C } ^ { \prime } \times \mathrm { R } ^ { \prime } } { = } \langle \frac { \mathrm { S } } { \mathrm { R } ^ { \prime } } , \frac { \mathrm { S } } { \mathrm { R } ^ { \prime } } , \frac { \mathrm { S } } { \mathrm { R } ^ { \prime } } \rangle _ { \mathrm { C } ^ { \prime } } ^ { 2 } \mathrm { { R } } \mathrm { { R } } ^ { - 1 } } \\ & { - \underset { \mathrm { C } ^ { \prime } \times \mathrm { R } ^ { \prime } } { = } \langle \frac { \mathrm { S } } { \mathrm { R } ^ { \prime } } , \frac { \mathrm { S } } { \mathrm { R } ^ { \prime } } , \frac { \mathrm { S } } { \mathrm { R } ^ { \prime } } \rangle _ { \mathrm { C } ^ { \prime } } ^ { 2 } \mathrm { { R } } \mathrm { { R } } ^ { - 1 } } \\ &  - \underset { \mathrm { C } ^ { \prime } \times \mathrm { R } ^ { \prime } } { = } \langle \frac { \mathrm { S } } { \mathrm { R } ^ { \prime } } , \frac { \mathrm { S } } { \mathrm { R } ^ { \prime } } , \frac { \mathrm { S } } { \mathrm { R } ^ { \prime } } \rangle _ { \mathrm { C } ^ { \prime } } \\ &  - \underset  \mathrm { C } ^ { \prime } \times \mathrm \end{array}
+$$
+
+Thus, we can get the forward difference of $k ( g _ { n d + i } )$ as:
+
+$$
+\begin{array} { l } { \underset { \displaystyle \mathcal { A } \to \infty } { \operatorname* { l i m } } k ( g _ { n d + i + 1 } ) - \underset { n d \to \infty } { \operatorname* { l i m } } k ( g _ { n d + i } ) = \displaystyle \sum _ { l = 1 } ^ { \infty } \beta _ { 1 } ^ { ( l - 1 ) d } \left[ ( 1 - \beta _ { 1 } ) ^ { 2 } \displaystyle \sum _ { j = 0 } ^ { \infty } \beta _ { 1 } ^ { j } \cdot \widetilde { V } _ { j + i + 1 } + ( 1 - \beta _ { 1 } ) ^ { 2 } \displaystyle \sum _ { j = 0 } ^ { \infty } \beta _ { 1 } ^ { j } \cdot \widetilde { V } _ { j + i + 1 } \right. + } \\ { \left. \left. = ( 1 - \beta _ { 1 } ) ^ { 2 } \displaystyle \sum _ { l = 1 } ^ { \infty } \beta _ { 1 } ^ { ( l - 1 ) d } \displaystyle \sum _ { j = 0 } ^ { d - 1 } \beta _ { 1 } ^ { j } \cdot \left[ \widetilde { V } _ { j + i + 1 } - \widetilde { V } _ { i } \right] \right. \right. } \end{array}
+$$
+
+$\widetilde { V } _ { n d + 1 i }$ monotonically increases within one period, when $1 \leq i \leq d$ and $i \in \mathbb N$ . And the weigh $\beta _ { 1 } ^ { j }$ for every difference term $\left[ \widetilde { V } _ { j + i + 1 } - \widetilde { V } _ { i } \right]$ is fixed when $i$ varies. Thus, the weighted summation Pd−1j=0 βj1 · h $\begin{array} { r } { \sum _ { j = 0 } ^ { d - 1 } \beta _ { 1 } ^ { j } \cdot \left[ \widetilde { V } _ { j + i + 1 } - \widetilde { V } _ { i } \right] } \\ { . } \end{array}$ is monotonically decreasing from positive to negative. In other words, the forward difference is monotonically decreasing, such that there exists $j$ , $1 \leq j \leq d$ and $\operatorname* { l i m } _ { n d \to \infty } k ( g _ { n d + 1 } )$ is the maximum among all net updates. Moreover, it is obvious that $\operatorname* { l i m } _ { n d \to \infty } k ( g _ { n d + 1 } )$ is the minimum.
+
+Hence, we can draw the conclusion: $\exists 1 \leq j \leq d$ , such that
+
+$$
+\operatorname* { l i m } _ { n d \to \infty } k ( C ) = \operatorname* { l i m } _ { n d \to \infty } k ( g _ { n d + 1 } ) < \operatorname* { l i m } _ { n d \to \infty } k ( g _ { n d + 2 } ) < \cdots < \operatorname* { l i m } _ { n d \to \infty } k ( g _ { n d + j } )
+$$
+
+and
+
+$$
+\operatorname* { l i m } _ { n d \to \infty } k ( g _ { n d + j } ) > \operatorname* { l i m } _ { n d \to \infty } k ( g _ { n d + j + 1 } ) > \cdots > \operatorname* { l i m } _ { n d \to \infty } k ( g _ { n d + d + 1 } ) = \operatorname* { l i m } _ { n d \to \infty } k ( C ) ,
+$$
+
+where $K ( C )$ is the net update factor for gradient $g _ { i } = C$ .
+
+# G PROOF OF LEMMA 4
+
+Lemma 7. 1 For a bounded random variable $X$ and a differentiable function $f ( x )$ , the expectation of $f ( X )$ is as follows:
+
+$$
+\mathbb { E } [ f ( X ) ] = f ( \mathbb { E } [ X ] ) + \frac { f ^ { \prime \prime } ( \mathbb { E } [ X ] ) } { 2 } D ( X ) + R _ { 3 }
+$$
+
+where $D ( X )$ is variance of $X$ , and $R _ { 3 }$ is as follows:
+
+$$
+\begin{array} { r l } & { R _ { 3 } = \displaystyle \frac { f ^ { [ 3 ] } ( \alpha ) } { 3 } \mathbb { E } ( X - \mathbb { E } [ X ] ) ^ { 3 } + } \\ & { \quad + \displaystyle \int _ { | x - \mathbb { E } [ X ] | > c } \left( f ( \mathbb { E } [ X ] ) + f ^ { ' } ( \mathbb { E } [ X ] ) ( x - \mathbb { E } [ X ] ) ^ { 2 } + f ( X ) \right) d F ( x ) } \end{array}
+$$
+
+$F ( x )$ is the distribution function of $X , R _ { 3 }$ is a small quantity under some condition. And $c$ is large enough, such that: for any $\epsilon > 0$ ,
+
+$$
+P ( X \in [ \mathbb { E } [ X ] - c , \mathbb { E } [ X ] + c ] ) = P ( | X - \mathbb { E } [ X ] | \leq c ) \leq 1 - \epsilon
+$$
+
+Proof. (Proof of Lemma 4 ) In the stochastic online optimization problem equation 7, the gradient subjects the distribution as:
+
+$$
+g _ { i } = \left\{ \begin{array} { l l } { { C , } } & { { \mathrm { w i t h ~ p r o b a b i l i t y } \ : p : = \frac { 1 + \delta } { C + 1 } ; } } \\ { { - 1 , } } & { { \mathrm { w i t h ~ p r o b a b i l i t y } \ : 1 - p : = \frac { C - \delta } { C + 1 } . } } \end{array} \right. ,
+$$
+
+Then we can get the expectation of $g _ { i }$ :
+
+$$
+\begin{array} { c } { { \cdot \qquad \mathbb { E } [ g _ { i } ] = \delta } } \\ { { \mathbb { E } [ g _ { i } ^ { 2 } ] = C ^ { 2 } \cdot \displaystyle \frac { 1 + \delta } { C + 1 } + \displaystyle \frac { C - \delta } { C + 1 } = C + \delta ( C + 1 ) } } \\ { { D [ g _ { i } ] = C + \delta ( C + 1 ) - \delta ^ { 2 } } } \\ { { \mathbb { E } [ g _ { i } ^ { 4 } ] = C ( C ^ { 2 } - C + 1 ) + \delta ( C - 1 ) ( C ^ { 2 } + 1 ) } } \\ { { D [ g _ { i } ^ { 2 } ] = C ^ { 3 } - 2 C ^ { 2 } + C + \delta ( C ^ { 3 } - 3 C ^ { 2 } - C - 1 ) - \delta ^ { 2 } ( C + 1 ) ^ { 2 } } } \end{array}
+$$
+
+Meanwhile, under the assumption that gradients are i.i.d., the expectation and variance of $v _ { i }$ are as following when $n d  \infty$ :
+
+$$
+\mathbb { E } [ v _ { i } ] = \operatorname* { l i m } _ { i \to \infty } ( 1 - \beta _ { 2 } ) \sum _ { j = 1 } ^ { i } \beta _ { 2 } ^ { i - j } \mathbb { E } [ g _ { j } ^ { 2 } ] = \operatorname* { l i m } _ { i \to \infty } ( 1 - \beta _ { 2 } ^ { i } ) \mathbb { E } [ g _ { j } ^ { 2 } ] = C + \delta ( C + 1 )
+$$
+
+$$
+D [ v _ { i } ] = \operatorname * { l i m } _ { i \to \infty } ( 1 - \beta _ { 2 } ) \sum _ { j = 1 } ^ { i } \beta _ { 2 } ^ { i - j } D [ g _ { j } ^ { 2 } ] = \operatorname * { l i m } _ { i \to \infty } ( 1 - \beta _ { 2 } ^ { i } ) D [ g _ { j } ^ { 2 } ] = D [ g _ { j } ^ { 2 } ]
+$$
+
+Then, for the gradient $g _ { i }$ , the net update factor is as follows:
+
+$$
+k ( g _ { i } ) = \sum _ { t = 0 } ^ { \infty } \frac { ( 1 - \beta _ { 1 } ) \beta _ { 1 } ^ { t } } { \sqrt { \beta _ { 2 } ^ { t + 1 } v _ { i - 1 } + ( 1 - \beta _ { 2 } ) \beta _ { 2 } ^ { t } \cdot g _ { i } ^ { 2 } + ( 1 - \beta _ { 2 } ) \sum _ { j = 1 } ^ { t } \beta _ { 2 } ^ { t - j } g _ { i + j } ^ { 2 } } }
+$$
+
+It should to be clarified that we define $\textstyle \sum _ { j = 1 } ^ { t } \beta _ { 2 } ^ { t - j } g _ { i + j } ^ { 2 }$ equal to zero when $t = 0$ . Then we define $X _ { t }$ as:
+
+$$
+\begin{array} { r l } & { \quad X _ { t } = \beta _ { 2 } ^ { t + 1 } v _ { t - 1 } + ( 1 - \beta _ { 2 } ) \beta _ { 2 } ^ { t } \cdot g _ { t } ^ { 2 } + ( 1 - \beta _ { 2 } ) \sum _ { j = 0 } ^ { \ell - 1 } g _ { t + j } ^ { 2 } } \\ & { \quad } \\ & { \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad } \\ & { \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad } \\ & { \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad } \\ & { \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad } \\ & { \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad } \\ & { \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad } \\ & { \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad } \\ & { \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad } \\ & { \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad } \\ &  \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \end{array}
+$$
+
+For the function $\textstyle f ( x ) = { \frac { 1 } { \sqrt { x } } }$ :
+
+$$
+f ^ { ^ { \prime \prime } } ( x ) = { \frac { 3 \cdot x ^ { - 5 / 2 } } { 8 } }
+$$
+
+According to lemma 7, we can the expectation of $f ( X _ { t } )$ as follows:
+
+$$
+\mathbb { E } [ f ( X _ { t } ) ] = \left( \mathbb { E } [ X _ { t } ] \right) ^ { - 1 / 2 } + { \frac { 3 } { 8 } } { \big ( } \mathbb { E } [ X _ { t } ] { \big ) } ^ { - 5 / 2 } \cdot D [ X _ { t } ]
+$$
+
+$\mathbb { E } [ X _ { t } ]$ and $D [ X _ { t } ]$ are expressed by equation 35 and equation 38. Then we can obtain the expectation expression of net update factor as follows:
+
+$$
+\begin{array} { r } { k ( g _ { i } ) = \sum _ { t = 0 } ^ { \infty } ( 1 - \beta _ { 1 } ) \beta _ { 1 } ^ { t } \left[ \frac { 1 } { \sqrt { ( 1 - \beta _ { 2 } ) \beta _ { 2 } ^ { t } g _ { i } ^ { 2 } + ( 1 + \beta _ { 2 } ^ { t + 1 } - \beta _ { 2 } ^ { k } ) \mathbb { E } [ g _ { i } ^ { 2 } ] } } + \frac { 3 D _ { t } } { 8 [ ( 1 - \beta _ { 2 } ) \beta _ { 2 } ^ { t } g _ { i } ^ { 2 } + ( 1 + \beta _ { 2 } ^ { t + 1 } - \beta _ { 2 } ^ { t } ) \mathbb { E } [ g _ { i } ^ { 2 } ] ] ^ { \frac { 5 } { 2 } } } \right] } \end{array}
+$$
+
+where $D _ { t } = D [ X _ { k } ]$ . Then for gradient $C$ and $- 1$ , the net update factor is as follows:
+
+$$
+\begin{array} { r } { k ( C ) = \sum _ { t = 0 } ^ { \infty } ( 1 - \beta _ { 1 } ) \beta _ { 1 } ^ { t } \left[ \frac { 1 } { \sqrt { ( 1 - \beta _ { 2 } ) \beta _ { 2 } ^ { t } C ^ { 2 } + ( 1 + \beta _ { 2 } ^ { t + 1 } - \beta _ { 2 } ^ { k } ) \mathbb E [ g _ { i } ^ { 2 } ] } } + \frac { 3 D _ { t } } { 8 [ ( 1 - \beta _ { 2 } ) \beta _ { 2 } ^ { t } C ^ { 2 } + ( 1 + \beta _ { 2 } ^ { t + 1 } - \beta _ { 2 } ^ { t } ) \mathbb E [ g _ { i } ^ { 2 } ] ] ^ { \frac { 5 } { 2 } } } \right] } \end{array}
+$$
+
+and
+
+$$
+\begin{array} { r } { k ( - 1 ) = \sum _ { t = 0 } ^ { \infty } ( 1 - \beta _ { 1 } ) \beta _ { 1 } ^ { t } \left[ \frac { 1 } { \sqrt { ( 1 - \beta _ { 2 } ) \beta _ { 2 } ^ { t } + ( 1 + \beta _ { 2 } ^ { t + 1 } - \beta _ { 2 } ^ { k } ) \mathbb { E } [ g _ { \ast } ^ { 2 } ] } } + \frac { 3 D _ { t } } { 8 [ ( 1 - \beta _ { 2 } ) \beta _ { 2 } ^ { t } + ( 1 + \beta _ { 2 } ^ { t + 1 } - \beta _ { 2 } ^ { t } ) \mathbb { E } [ g _ { \ast } ^ { 2 } ] ] ^ { \frac { 5 } { 2 } } } \right] } \end{array}
+$$
+
+We can see that each term in the infinite series of $k ( C )$ is smaller than the corresponding one in $k ( - 1 )$ . Thus, $k ( C ) < k ( - 1 )$ .
+
+# H PROOF OF LEMMA 6
+
+Proof. From Lemma 2, we can get:
+
+$$
+\operatorname* { l i m } _ { n d  \infty } { \frac { m _ { n d + i } } { \sqrt { v _ { n d + i } } } } = { \frac { { \frac { 1 - \beta _ { 1 } } { 1 - \beta _ { 1 } ^ { d } } } ( C + 1 ) \beta _ { 1 } ^ { i - 1 } - 1 } { \sqrt { { \frac { 1 - \beta _ { 2 } } { 1 - \beta _ { 2 } ^ { d } } } ( C ^ { 2 } - 1 ) \beta _ { 2 } ^ { i - 1 } + 1 } } }
+$$
+
+We sum up all updates in an epoch, and define the summation as $S ( \beta _ { 1 } , \beta _ { 2 } , C )$ .
+
+$$
+\displaystyle { \mathcal { S } } ( \beta _ { 1 } , \beta _ { 2 } , C ) = \sum _ { i = 1 } ^ { d } \operatorname* { l i m } _ { n d  \infty } { \frac { m _ { n d + i } } { \sqrt { v _ { n d + i } } } }
+$$
+
+Assume $\beta _ { 2 }$ and $C$ are large enough such that $v _ { t } \gg 1$ , we get the approximation of limit of $v _ { n d + i }$ as:
+
+$$
+\operatorname* { l i m } _ { n d  \infty } v _ { n d + i } \approx \frac { 1 - \beta _ { 2 } } { 1 - \beta _ { 2 } ^ { d } } ( C ^ { 2 } - 1 ) \beta _ { 2 } ^ { i - 1 }
+$$
+
+Then we can draw the expression of $S ( \beta _ { 1 } , \beta _ { 2 } , C )$ as:
+
+$$
+\begin{array} { r l } { \xi ( \beta _ { 1 } , \beta _ { 2 } , C ) = \displaystyle \sum _ { i = 1 } ^ { d } \frac { \frac { 1 - \beta _ { i } } { 2 \beta _ { 2 } ^ { i } } ( C + 1 ) \beta _ { 1 } ^ { i - 1 } - 1 } { \sqrt { \frac { 1 - \beta _ { i } } { 1 - \beta _ { 2 } ^ { i } } ( C ^ { 2 } - 1 ) \beta _ { 2 } ^ { i - 1 } } } } \\ { = \displaystyle \sum _ { i = 1 } ^ { d } \frac { \frac { 1 - \beta _ { i } } { 2 \beta _ { 1 } ^ { i } } ( C + 1 ) \beta _ { 1 } ^ { i - 1 } } { \sqrt { \frac { 1 - \beta _ { i } } { 1 - \beta _ { 2 } ^ { i } } ( C ^ { 2 } - 1 ) \beta _ { 2 } ^ { i - 1 } } } - \displaystyle \sum _ { i = 1 } ^ { d } \frac { 1 } { \sqrt { \frac { 1 - \beta _ { 2 } } { 1 - \beta _ { 2 } ^ { i } } ( C ^ { 2 } - 1 ) \beta _ { 2 } ^ { i - 1 } } } } \\ { = \displaystyle \sqrt { \frac { 1 - \beta _ { 2 } ^ { d } } { ( 1 - \beta _ { 2 } ) \beta _ { 2 } ^ { d - 1 } } } \sqrt { \frac { C + 1 } { C - 1 } } \cdot \frac { 1 - \beta _ { 1 } } { 1 - \beta _ { 1 } ^ { d } } \cdot \sqrt { \frac { \beta _ { 2 } ^ { d } - \beta _ { 1 } ^ { d } } { \sqrt { 2 } - \beta _ { 1 } } } - \sqrt { \frac { 1 - \beta _ { 2 } ^ { d } } { ( 1 - \beta _ { 2 } ) \beta _ { 2 } ^ { d - 1 } } } \cdot \frac { 1 } { \sqrt { C ^ { 2 } - 1 } } \frac { \sqrt { \beta _ { 2 } ^ { d } } } { \sqrt { \beta _ { 2 } } } } \\  = \displaystyle \sqrt { \frac { 1 - \beta _ { 2 } ^ { d } } { ( 1 - \beta _ { 2 } ) \beta _ { 2 } ^ { d - 1 } ( C - 1 ) } } [ \frac { ( 1 - \beta _ { 1 } ) ( \beta _ { 2 } ^ { d } - \beta _ { 1 } ^ { d } ) \sqrt { C + 1 } } { ( 1 - \beta _ { 1 } ^ { d } ) ( \sqrt { 2 } - \beta _ { 1 } ) } - \frac { \sqrt { \beta _ { 2 } ^ { d } } - 1 }  \sqrt { C + 1 } ( \sqrt { \beta _ { 2 } } -  \end{array}
+$$
+
+Let $S ( \beta _ { 1 } , \beta _ { 2 } , C ) = 0$ , we get the equation about critical condition:
+
+$$
+C + 1 = \frac { ( 1 - \beta _ { 1 } ^ { d } ) ( \sqrt { \beta _ { 2 } ^ { d } } - \beta _ { 1 } ^ { d } ) ( 1 - \sqrt { \beta _ { 2 } } ) } { ( 1 - \beta _ { 1 } ) ( \sqrt { \beta _ { 2 } } - \beta _ { 1 } ) ( 1 - \sqrt { \beta _ { 2 } ^ { d } } ) }
+$$
+
+# I HYPER-PARAMETERS INVESTIGATION
+
+# I.1 HYPER-PARAMETERS SETTING
+
+Here, we list all hyper-parameter setting of all above experiments.
+
+Table 5: Hyper-parameter setting of logistic regression in Figure 2.   
+
+<table><tr><td rowspan=1 colspan=1>Optimizer</td><td rowspan=1 colspan=1>learning rate</td><td rowspan=1 colspan=1>β1</td><td rowspan=1 colspan=1>β</td><td rowspan=1 colspan=1>n</td></tr><tr><td rowspan=1 colspan=1>SGD</td><td rowspan=1 colspan=1>0.1</td><td rowspan=1 colspan=1>N/A</td><td rowspan=1 colspan=1>N/A</td><td rowspan=1 colspan=1>N/A</td></tr><tr><td rowspan=1 colspan=1>Adam</td><td rowspan=1 colspan=1>0.001</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0.999</td><td rowspan=1 colspan=1>N/A</td></tr><tr><td rowspan=1 colspan=1>AMSGrad</td><td rowspan=1 colspan=1>0.001</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0.999</td><td rowspan=1 colspan=1>N/A</td></tr><tr><td rowspan=1 colspan=1>non-AdaShift</td><td rowspan=1 colspan=1>0.001</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0.999</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=1 colspan=1>max-AdaShift</td><td rowspan=1 colspan=1>0.01</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0.999</td><td rowspan=1 colspan=1>1</td></tr></table>
+
+Table 6: Hyper-parameter setting of Multilayer Perceptron on MNIST in Figure 3.   
+
+<table><tr><td rowspan=1 colspan=1>Optimizer</td><td rowspan=1 colspan=1>learning rate</td><td rowspan=1 colspan=1>β1</td><td rowspan=1 colspan=1>β2</td><td rowspan=1 colspan=1>n</td></tr><tr><td rowspan=1 colspan=1>SGD</td><td rowspan=1 colspan=1>0.001</td><td rowspan=1 colspan=1>N/A</td><td rowspan=1 colspan=1>N/A</td><td rowspan=1 colspan=1>N/A</td></tr><tr><td rowspan=1 colspan=1>Adam</td><td rowspan=1 colspan=1>0.001</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0.999</td><td rowspan=1 colspan=1>N/A</td></tr><tr><td rowspan=1 colspan=1>AMSGrad</td><td rowspan=1 colspan=1>0.001</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0.999</td><td rowspan=1 colspan=1>N/A</td></tr><tr><td rowspan=1 colspan=1>non-AdaShift</td><td rowspan=1 colspan=1>0.0005</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0.999</td><td rowspan=1 colspan=1>1</td></tr><tr><td rowspan=1 colspan=1>max-AdaShift</td><td rowspan=1 colspan=1>0.01</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0.999</td><td rowspan=1 colspan=1>1</td></tr></table>
+
+Table 7: Hyper-parameter setting of WGAN-GP in Figure 7a.   
+
+<table><tr><td rowspan=1 colspan=1>Optimizer</td><td rowspan=1 colspan=1>learning rate</td><td rowspan=1 colspan=1>β1</td><td rowspan=1 colspan=1>β</td><td rowspan=1 colspan=1>n</td></tr><tr><td rowspan=1 colspan=1>Adam</td><td rowspan=1 colspan=1>1e-5</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0.999</td><td rowspan=1 colspan=1>N/A</td></tr><tr><td rowspan=1 colspan=1>AMSGrad</td><td rowspan=1 colspan=1>1e-5</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0.999</td><td rowspan=1 colspan=1>N/A</td></tr><tr><td rowspan=1 colspan=1>AdaShift</td><td rowspan=1 colspan=1>1.5e-4</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0.999</td><td rowspan=1 colspan=1>1</td></tr></table>
+
+Table 8: Hyper-parameter setting of Neural Machine Translation BLEU in Figure 7b.   
+
+<table><tr><td rowspan=1 colspan=1>Optimizer</td><td rowspan=1 colspan=1>learning rate</td><td rowspan=1 colspan=1>β1</td><td rowspan=1 colspan=1>β</td><td rowspan=1 colspan=1>n</td></tr><tr><td rowspan=1 colspan=1>Adam</td><td rowspan=1 colspan=1>0.0001</td><td rowspan=1 colspan=1>0.9</td><td rowspan=1 colspan=1>0.999</td><td rowspan=1 colspan=1>N/A</td></tr><tr><td rowspan=1 colspan=1>AMSGrad</td><td rowspan=1 colspan=1>0.0001</td><td rowspan=1 colspan=1>0.9</td><td rowspan=1 colspan=1>0.999</td><td rowspan=1 colspan=1>N/A</td></tr><tr><td rowspan=1 colspan=1>AdaShift</td><td rowspan=1 colspan=1>0.01</td><td rowspan=1 colspan=1>0.9</td><td rowspan=1 colspan=1>0.999</td><td rowspan=1 colspan=1>30</td></tr></table>
+
+Table 9: Hyper-parameter setting of ResNet on Cifar-10 in Figure 4, DenseNet on Cifar-10 in Figure 5 and DenseNet on Tiny-Imagenet in Figure 6.   
+
+<table><tr><td rowspan=1 colspan=1>Optimizer</td><td rowspan=1 colspan=1>learning rate</td><td rowspan=1 colspan=1>β1</td><td rowspan=1 colspan=1>β</td><td rowspan=1 colspan=1>n</td></tr><tr><td rowspan=1 colspan=1>Adam</td><td rowspan=1 colspan=1>0.001</td><td rowspan=1 colspan=1>0.9</td><td rowspan=1 colspan=1>0.999</td><td rowspan=1 colspan=1>N/A</td></tr><tr><td rowspan=1 colspan=1>AMSGrad</td><td rowspan=1 colspan=1>0.001</td><td rowspan=1 colspan=1>0.9</td><td rowspan=1 colspan=1>0.999</td><td rowspan=1 colspan=1>N/A</td></tr><tr><td rowspan=1 colspan=1>AdaShift</td><td rowspan=1 colspan=1>0.01</td><td rowspan=1 colspan=1>0.9</td><td rowspan=1 colspan=1>0.999</td><td rowspan=1 colspan=1>10</td></tr></table>
+
+# I.2 LEARNING RATE $\alpha _ { t }$ SENSITIVITY
+
+In this section, we discuss the learning rate $\alpha _ { t }$ sensitivity of AdaShift. We set $\alpha _ { t } \in$ $\{ 0 . 1 , 0 . 0 1 , 0 . 0 0 1 \}$ and let $n = 1 0$ , $\beta _ { 1 } = 0 . 9$ and $\beta _ { 2 } ~ = ~ 0 . 9 9 9$ . The results are shown in Figure 9 and Figure 10. Empirically, we found that when using the max spatial operation, the best learning rate for AdaShift is around ten times of Adam.
+
+![](images/4909f0aa650c12fc621d18f78fa81dcc3607d1662116578f1074f92971972268.jpg)  
+Figure 9: Learning rate sensitivity experiment with ResNet on CIFAR-10.
+
+![](images/b8da852604c7acdfb7df1f564048ada98e0832aedd7a2fde94e219b89deaa30d.jpg)  
+Figure 10: Learning rate sensitivity experiment with DenseNet on CIFAR-10.
+
+# I.3 $\beta _ { 1 }$ AND $\beta _ { 2 }$ SENSITIVITY
+
+In this section, we discuss the $\beta _ { 1 }$ and $\beta _ { 2 }$ sensitivity of AdaShift. We set $\alpha = 0 . 0 1$ , $n = 1 0$ and let $\beta _ { 1 } \in \{ 0 , 0 . 9 \}$ and $\beta _ { 2 } \in \{ 0 . 9 , 0 . 9 9 , 0 . 9 9 9 \}$ . The results are shown in Figure 11 and Figure 12. According to the results, AdaShift holds a low sensitivity to $\beta _ { 1 }$ and $\beta _ { 2 }$ . In some tasks, using the first moment estimation (with $\beta _ { 1 } = 0 . 9$ and $n = 1 0$ ) or using a large $\beta _ { 2 }$ , e.g., 0.999 can attain better performance. The suggested parameters setting is $n = 1 0 , \beta _ { 1 } = 0 . 9 , \beta _ { 2 } = 0 . 9 9 9$ .
+
+![](images/8e7bb46a383387bd3524591b4c8cb89de059dd625839a1a322e4e80b19df406a.jpg)  
+Figure 11: $\beta _ { 1 }$ and $\beta _ { 2 }$ sensitivity experiment with ResNet on CIFAR-10.
+
+![](images/c85774be92122c65af3a80fbb5f0fd00083975edd04234d9d8b32b7a218d3fa2.jpg)  
+Figure 12: $\beta _ { 1 }$ and $\beta _ { 2 }$ sensitivity experiment with DenseNet on CIFAR-10.
+
+# I.4 $n$ AND $m$ SENSITIVITY
+
+In this section, we discuss the $n$ sensitivity of AdaShift. Here we also test a extended version of first moment estimation where it only uses the latest $m$ gradients $( m \leq n )$ ):
+
+$$
+v _ { t } = \beta _ { 2 } v _ { t - 1 } + ( 1 - \beta _ { 2 } ) \phi ( g _ { t - n } ^ { 2 } ) \mathrm { a n d } m _ { t } = \frac { \sum _ { i = 0 } ^ { m - 1 } \beta _ { 1 } ^ { i } g _ { t - i } } { \sum _ { i = 0 } ^ { m - 1 } \beta _ { 1 } ^ { i } } .
+$$
+
+We set $\beta _ { 1 } = 0 . 9$ , $\beta _ { 2 } = 0 . 9 9 9$ . The results are shown in Figure 13, Figure 14 and Figure 15. In these experiments, AdaShift is fairly stable when changing $n$ and $m$ . We have not find a clear pattern on the performance change with respect to $n$ and $m$ .
+
+![](images/d20198ba19bd14cdcebb3328bf7211062951399b92c25c689d8ae862a767a33d.jpg)  
+Figure 13: $n$ sensitivity experiment with DenseNet on Tiny-ImageNet.
+
+![](images/80fcf03bfa6bd2d8ab43b04564de3c04dd7e155e690a450f03c7072bfad35f30.jpg)  
+Figure 14: $m$ sensitivity experiment with DenseNet on Tiny-ImageNet.
+
+![](images/032e91db08eeaebf993a78a6617028a753cd2e2342db789dd673befa4d40ad36.jpg)  
+Figure 15: $n$ and $m$ sensitivity experiment with Neural Machine Translation BLEU.
+
+# J TEMPORAL-ONLY AND SPATIAL-ONLY
+
+In our proposed algorithm, we apply a spatial operation on the temporally shifted gradient $g _ { t - n }$ to update $v _ { t }$ : $v _ { t } [ i ] \ \stackrel {  } { = } \ \beta _ { 2 } v _ { t - 1 } [ i ] \ \stackrel {  } { + } \ ( 1 - \stackrel {  } { \beta } _ { 2 } ) \phi ( g _ { t - n } ^ { \bar { 2 } } [ i ] )$ . It is based on the temporal independent assumption, i.e., $g _ { t - n }$ is independent of $g _ { t }$ . And according to our argument in Section 4.2, one can further assume every element in $g _ { t - n }$ is independent of the $i$ -th dimension of $g _ { t }$ .
+
+We purposely avoid involving the spatial elements of the current gradient $g _ { t }$ , where the independence might not holds: when a sample which is rare and has a large gradient appear in the mini-batch $x _ { t }$ , the overall scale of gradient $g _ { t }$ might increase. However, for the temporally already decorrelation $g _ { t - i }$ , further taking the advantage of the spatial irrelevance will not suffer from this problem.
+
+We here provide extended experiments on two variants of AdaShift: (i) AdaShift (temporal-only), which only uses the vanilla temporal independent assumption and evaluate $v _ { t }$ with: $v _ { t } = \beta _ { 2 } v _ { t - 1 } +$ $( 1 - \beta _ { 2 } ) g _ { t - n } ^ { \bar { 2 } }$ ; (ii) AdaShift (spatial-only), which directly uses the spatial elements without temporal shifting.
+
+![](images/43ded6d429086b1ca8120caff4411bc4247d739e2994a25a060cb2893c8638e1.jpg)  
+Figure 16: ResNet on CIFAR-10.
+
+![](images/158ec95ec8fc937fd7d74963d4f18458944c13d5eb1ae5f51ab36073ab513882.jpg)  
+Figure 17: DenseNet on CIFAR-10.
+
+According to our experiments, AdaShift (temporal-only), i.e., without the spatial operation, is less stable than AdaShift. In some tasks, AdaShift (temporal-only) works just fine; while in some other cases, AdaShift (temporal-only) suffers from explosive gradient and requires a relatively small learning rate. The performance of AdaShift (spatial-only) is close to Adam. More experiments for AdaShift (spatial-only) are included in the next section.
+
+# K EXTENDED EXPERIMENTS: NADAM AND ADASHIFT(SPACE ONLY)
+
+In this section, we extend the experiments and add the comparisons with Nadam and AdaShift (spatial-only). The results are shown in Figure 18, Figure19 and Figure20. According to these experiments, Nadam and AdaShift (spatial-only) share similar performence as Adam.
+
+![](images/f143612acf98740673c3532f8adbc8d7dd054de401589894b586c34337d21efc.jpg)  
+Figure 18: ResNet on CIFAR-10.
+
+![](images/273296fa14c86b0b96fb32df1e7c0c51ee384892d3a7f05744a0a7cb2f0953de.jpg)  
+Figure 19: DenseNet on CIFAR-10.
+
+![](images/5ffcc99112b37cf81aa8293c8c94951ff38d3378e1f9e80a0298167ffab3d8c4.jpg)  
+Figure 20: DenseNet on Tiny-ImageNet.
+
+Rahimi & Recht raise the point, at test of time talk at NIPS 2017, that it is suspicious that gradient descent (aka back-propagation) is ultimate solution for optimization. A ill-conditioned quadratic problem with Two Layer Linear Net is showed to be challenging for gradient descent based methods, while alternative solutions, e.g., Levenberg-Marquardt, may converge faster and better. The problem is defined as follows:
+
+$$
+L ( W _ { 1 } , W _ { 2 } ; A ) = \mathbb { E } _ { x \in N ( 0 , 1 ) } \| W _ { 1 } W _ { 2 } x - A x \| ^ { 2 }
+$$
+
+where $A$ is some known badly conditioned matrix $k = 1 0 ^ { 2 0 }$ or $1 0 ^ { 5 }$ ), and $W _ { 1 }$ and $W _ { 2 }$ are the trainable parameters.
+
+We test SGD, Adam and AdaShift with this problem, the results are shown in Figure 21, Figure 24. It turns out as long as the training goes enough long, SGD, Adam, AdaShift all basically converge in this problem. Though SGD is significantly better than Adam and AdaShift.
+
+We would tend to believe this is a general issue of adaptive learning rate method when comparing with vanilla SGD. Because these adaptive learning rate methods generally are scale-invariance, i.e., the step-size in terms of $g _ { t } / s q r t ( v _ { t } )$ is basically around one, which makes it hard to converge very well in such a ill-conditioning quadratic problem. SGD, in contrast, has a step-size $g _ { t }$ ; as the training converges SGD would have a decreasing step-size, makes it much easier to converge better. The above analysis is confirmed with Figure 22 and Figure 23, with a decreasing learning rate, Adam and AdaShfit both converge very good.
+
+![](images/0c76e5cd1e56d1881ec8ccb489a5bb4f769063ad71e849b3d967357413f9a967.jpg)  
+Figure 21: Ill-conditioned quadratic problem, with fixed learning rate.
+
+![](images/2785842fb7b0951df69a97b128b1108c050d819477f6f3c3d5d7ec9e9a9350a5.jpg)  
+Figure 22: Ill-conditioned quadratic problem, with linear learning rate decay.
+
+![](images/f2186ddf0b881239064971896f44276acbdcf14a8b799ac08027a20feeda9590.jpg)  
+Figure 23: Ill-conditioned quadratic problem, with exp learning rate decay.
+
+![](images/4dbbb975886d297abc8b0d28430ec3c5c80fe7e38ec1e751180a99fb8124666c.jpg)  
+Figure 24: Ill-conditioned quadratic problem, with fixed learning rate and insufficient iterations.

parse/train/SJgMK64Ywr/SJgMK64Ywr.md

@@ -0,0 +1,283 @@
+# ASSEMBLENET: SEARCHING FOR MULTI-STREAM NEURAL CONNECTIVITY IN VIDEO ARCHITECTURES
+
+Michael S. Ryoo1,2, AJ Piergiovanni1,2,3, Mingxing Tan2 & Anelia Angelova1,2
+
+1Robotics at Google   
+2Google Research   
+3Indiana University Bloomington   
+mryoo@google.com
+
+# ABSTRACT
+
+Learning to represent videos is a very challenging task both algorithmically and computationally. Standard video CNN architectures have been designed by directly extending architectures devised for image understanding to include the time dimension, using modules such as 3D convolutions, or by using two-stream design to capture both appearance and motion in videos. We interpret a video CNN as a collection of multi-stream convolutional blocks connected to each other, and propose the approach of automatically finding neural architectures with better connectivity and spatio-temporal interactions for video understanding. This is done by evolving a population of overly-connected architectures guided by connection weight learning. Architectures combining representations that abstract different input types (i.e., RGB and optical flow) at multiple temporal resolutions are searched for, allowing different types or sources of information to interact with each other. Our method, referred to as AssembleNet, outperforms prior approaches on public video datasets, in some cases by a great margin. We obtain $5 8 . 6 \%$ mAP on Charades and $3 4 . 2 7 \%$ accuracy on Moments-in-Time.
+
+# 1 INTRODUCTION
+
+Learning to represent videos is a challenging problem. Because a video contains spatio-temporal data, its representation is required to abstract both appearance and motion information. This is particularly important for tasks such as activity recognition, as understanding detailed semantic contents of the video is needed. Previously, researchers approached this challenge by designing a two-stream model for appearance and motion information respectively, combining them by late or intermediate fusion to obtain successful results: Simonyan & Zisserman (2014); Feichtenhofer et al. (2016b;a; 2017; 2018). However, combining appearance and motion information is an open problem and the study on how and where different modalities should interchange representations and what temporal aspect/resolution each stream (or module) should focus on has been very limited.
+
+In this paper, we investigate how to learn feature representations across spatial and motion visual clues. We propose a new multi-stream neural architecture search algorithm with connection learning guided evolution, which focuses on finding higher-level connectivity between network blocks taking multiple input streams at different temporal resolutions. Each block itself is composed of multiple residual modules with space-time convolutional layers, learning spatio-temporal representations. Our architecture learning not only considers the connectivity between such multi-stream, multi-resolution blocks, but also merges and splits network blocks to find better multi-stream video CNN architectures. Our objective is to address two main questions in video representation learning: (1) what feature representations are needed at each intermediate stage of the network and at which resolution and (2) how to combine or exchange such intermediate representations (i.e., connectivity learning). Unlike previous neural architecture search methods for images that focus on finding a good ‘module’ of convolutional layers to be repeated in a single-stream networks (Zoph et al., 2018; Real et al., 2019), our objective is to search for higher-level connections between multiple sequential or concurrent blocks to form multi-stream architectures.
+
+We propose the concept of AssembleNet, a new method of fusing different sub-networks with different input modalities and temporal resolutions. AssembleNet is a general formulation that allows representing various forms of multi-stream CNNs as directed graphs, coupled with an efficient evolutionary algorithm to explore the network connectivity. Specifically, this is done by utilizing the learned connection weights to guide evolution, in addition to randomly combining, splitting, or connecting sub-network blocks. AssembleNet is a ‘family’ of learnable architectures; they provide a generic approach to learn connectivity among feature representations across input modalities, while being optimized for the target task. We believe this is the first work to (i) conduct research on automated architecture search with multi-stream connections for video understanding, and (ii) introduce the new connection-learning-guided evolutionary algorithm for neural architecture search.
+
+![](images/86acc0df5d6ad2360fb3f4e70dbfe72203edd22f47c166a12055c9b3d50d9f2c.jpg)  
+Figure 1: AssembleNet with multiple intermediate streams. Example learned architecture. Darker colors of connections indicate stronger connections. At each convolutional block, multiple 2D and $( 2 + 1 ) \mathrm { D }$ residual modules are repeated alternatingly. Our network has 4 block levels $^ +$ the stem level connected to raw data). Each convolutional block has its own output channel size (i.e., the number of filters) $C$ and the temporal resolution $r$ controlling the 1D temporal convolutional layers in it.
+
+Figure 1 shows an example learned AssembleNet. The proposed algorithm for learning video architectures is very effective: it outperforms all prior work and baselines on two very challenging benchmark datasets, and establishes a new state-of-the-art. AssembleNet models use equivalent number of parameters to standard two-stream $( 2 + 1 ) \mathrm { D }$ ResNet models.
+
+# 2 PREVIOUS WORK
+
+A video is a spatio-temporal data (i.e., image frames concatenated along time axis), and its representation must abstract both spatial and temporal information. Full 3D space-time (i.e., XYT) convolutional layers as well as $( 2 + 1 ) \mathrm { D }$ convolutional layers have been popularly used to represent videos (Tran et al., 2014; Carreira & Zisserman, 2017; Tran et al., 2018; Xie et al., 2018). Researchers studied replacing 2D convolutional layers in standard image-based CNNs such as Inception (Szegedy et al., 2016) and ResNet (He et al., 2016), so that it can be directly used for video classification.
+
+Two-stream network designs, which combine motion and appearance inputs, are commonly used (e.g., Simonyan & Zisserman, 2014; Feichtenhofer et al., 2016a; 2017; 2016b). Combining appearance information at two different temporal resolutions (e.g., 24 vs. 3 frames per second) with intermediate connections has been proposed by Feichtenhofer et al. (2018). Late fusion of the two-stream representations or architectures with more intermediate connections (Diba et al., 2019), have also been explored. However, these video CNN architectures are the result of careful manual designs by human experts.
+
+Neural Architecture Search (NAS), the concept of automatically finding better architectures based on data, is becoming increasingly popular (Zoph & Le, 2017; Zoph et al., 2018; Liu et al., 2018). Rather than relying on human expert knowledge to design a CNN model, neural architecture search allows the machines to generate better performing models optimized for the data. The use of reinforcement learning controllers (Zoph & Le, 2017; Zoph et al., 2018) as well as evolutionary algorithms (Real et al., 2019) have been studied, and they meaningfully outperform handcrafted architectures. Most of these works focus on learning architectures of modules (i.e., groupings of layers and their connections) to be repeated within a fixed single-stream meta-architecture (e.g., ResNet) for image-based object classification. One-shot architecture search to learn differentiable connections (Bender et al., 2018; Liu et al., 2019) has also been successful for images. However, it is very challenging to directly extend such work to find multi-stream models for videos, as it requires preparing all possible layers and interactions the final architecture may consider using. In multi-stream video CNNs, there are many possible convolutional blocks with different resolutions, and fully connecting them requires a significant amount of memory and training data, which makes it infeasible.
+
+Our work is also related to Ahmed & Torresani (2017) which used learnable gating to connect multiple residual module branches, and to the RandWire network (Xie et al., 2019), which showed that randomly connecting a sufficient number of convolutional layers creates performant architectures. However, similar to previous NAS work, the latter focuses only on generating connections between the layers within a block. The meta-architecture is fixed as a single stream model with a single input modality. In this work, our objective is to learn high-level connectivity between multi-stream blocks for video understanding driven by data. We confirm experimentally that in the multi-stream video CNNs, where multiple types of input modalities need to be considered at various resolutions, randomly connecting blocks is insufficient and the proposed architecture learning strategy is necessary.
+
+# 3 ASSEMBLENET
+
+We propose a new principled way to find better neural architectures for video representation learning. We first expand a video CNN to a multi-resolution, multi-stream model composed of multiple sequential and concurrent neural blocks, and introduce a novel algorithm to search for the optimal connectivity between the blocks for a given task.
+
+We model a video CNN architecture as a collection of convolutional blocks (i.e., sub-networks) connected to each other. Each block is composed of a residual module of space-time convolutional layers repeated multiple times, while having its own temporal resolution. The objective of our video architecture search is to automatically (1) decide the number of parallel blocks (i.e., how many streams to have) at each level of the network, (2) choose their temporal resolutions, and (3) find the optimal connectivity between such multi-stream neural blocks across various levels. The highly interconnected convolutional blocks allow learning of the video representations combining multiple input modalities at various temporal resolutions. We introduce the concept of connection-learningguided architecture evolution to enable multi-stream architecture search.
+
+We name our final architecture as an ‘AssembleNet’, since it is formulated by assembling (i.e., merging, splitting, and connecting) multiple building blocks.
+
+# 3.1 GRAPH FORMULATION
+
+In order to make our neural architecture evolution consider multiple different streams with different modalities at different temporal resolutions, we formulate the multi-stream model as a directed acyclic graph. Each node in the graph corresponds to a sub-network composed of multiple convolutional layers (i.e., a block), and the edges specify the connections between such sub-networks. Each architecture is denoted as $G _ { i } = ( \bar { N } _ { i } , \bar { E _ { i } } )$ where $N _ { i } = \{ n _ { 0 i } , n _ { 1 i } , n _ { 2 i } , \cdot \cdot \cdot \}$ is the set of nodes and $E _ { i }$ is the set of edges defining their connectivity.
+
+Nodes. A node in our graph representation is a ResNet block composed of a fixed number of interleaved 2D and $( 2 + 1 ) \mathrm { D }$ residual modules. A ‘2D module’ is composed of a 1x1 conv. layer, one 2D conv. layer with filter size 3x3, and one 1x1 convolutional layer. A $( 2 + 1 ) \mathrm { D }$ module’ consists of a temporal 1D convolutional layer (with filter size 3), a 2D conv. layer, and a 1x1 conv. layer. In each block, we repeat a regular 2D residual module followed by the $( 2 + 1 ) \mathrm { D }$ residual module $m$ times.
+
+Each node has its own block level, which naturally decides the directions of the edges connected to it. Similar to the standard ResNet models, we made the nodes have a total of four block levels ( $^ +$ the stem level). Having multiple nodes of the same level means the architecture has multiple parallel ‘streams’. Figure 1 illustrates an example. Each level has a different $m$ value: 1.5, 2, 3, and 1.5. $m = 1 . 5$ means that there is one 2D module, one $( 2 + 1 ) \mathrm { D }$ module, and one more 2D module. As a result, the depth of our network is 50 conv. layers. We also have a batch normalization layer followed by a ReLU after every conv. layer.
+
+There are two special types of nodes with different layer configurations: source nodes and sink nodes. A source node in the graph directly takes the input and applies a small number of convolutional/pooling layers (it is often referred as the ‘stem’ of a CNN model). In video CNNs, the input is a 4D tensor (XYT $^ +$ channel) obtained by concatenating either RGB frames or optical flow images along the time axis. Source nodes are treated as level-0 nodes. The source node is composed of one 2D conv. layer of filter size $7 \mathbf { x } 7$ , one 1D temporal conv. layer of filter size 5, and one spatial max pooling layer. The 1D conv. is omitted in optical flow stems. A sink node generates the final output of the model, and it is composed of one pooling, one fully connected, and one softmax layer. The sink node is also responsible for combining the outputs of multiple nodes at the highest level, by concatenating them after the pooling. More details are provided in Appendix.
+
+Each node in the graph also has two attributes controlling the convolutional block: its temporal resolution and the number of channels. We use temporally dilated 1D convolution to dynamically change the resolution of the temporal convolutional layers in different blocks, which are discussed more below. The channel size (i.e., the number of filters) of a node could take arbitrary values, but we constrain the sum of the channels of all nodes in the same block level to be a constant so that the capacity of an AssembleNet model is equivalent to a ResNet model with the same number of layers.
+
+Temporally Dilated 1D Convolution. One of the objectives is to allow the video architectures to look at multiple possible temporal resolutions. This could be done by preparing actual videos with different temporal resolutions as in Feichtenhofer et al. (2018) or by using temporally ‘dilated convolutions as we introduce here. Having dilated filters allow temporal 1D conv. layers to focus on different temporal resolution without losing temporal granularity. This essentially is a 1D temporal version of standard 2D dilated convolutions used in Chen et al. (2018) or Yu & Koltun (2016):
+
+Let $k$ be a temporal filter (i.e., a vector) with size $2 d + 1$ . The dilated convolution operator $* _ { r }$ is similar to regular convolution but has different steps for the summation, described as:
+
+$$
+( F * _ { r } k ) ( t ) = \sum _ { t _ { 1 } + r t _ { 2 } = t } F ( t _ { 1 } ) k ( t _ { 2 } + d )
+$$
+
+where $t$ , $t _ { 1 }$ , and $t _ { 2 }$ are time indexes. $r$ indicates the temporal resolution (or the amount of dilation), and the standard 1D temporal convolution is a special case where $r = 1$ . In the actual implementation, this is done by inserting $r - 1$ number of zeros between each element of $k$ to generate $k ^ { \prime }$ , and then convolving such zero-inflated filters with the input: $F * _ { r } k = F * k ^ { \prime }$ . Importantly, the use of the dilated convolution allows different intermediate sub-network blocks (i.e., not just input stems) to focus on very different temporal resolutions at different levels of the convolutional architecture.
+
+Note that our temporally dilated convolution is different from the one used in Lea et al. (2017), which designed a specific layer to combine representations from different frames with various step sizes. Our layers dilate the temporal filters themselves. Our dilated convolution can be viewed as a direct temporal version of the standard dilated convolutions used in Chen et al. (2018); Yu & Koltun (2016).
+
+Edges. Each directed edge specifies the connection between two sub-network blocks, and it describes how a representation is transferred from one block to another block. We constrain the direction of each edge so that it is connected from a lower level block to a higher level block to avoid forming a cycle and allow parallel streams. A node may receive inputs from any number of lower-level nodes (including skip connections) and provide its output to any number of higher-level nodes.
+
+Our architectures use a (learnable) weighted summation to aggregate inputs given from multiple connected nodes. That is, an input to a node is computed as $F ^ { i n } = \Sigma _ { i }$ sigmoid $( w _ { i } ) \cdot F _ { i } ^ { o u t }$ , where $F _ { i } ^ { o u t }$ are output tensors (i.e., representations) of the nodes connected to the node and $w _ { i }$ are their corresponding weights. Importantly, each $w _ { i }$ is considered as a variable that has to be learned from training data through back propagation. This has two key advantages compared to conventional feature map concatenation: (i) The input tensor size is consistent regardless of the number of connections. (ii) We use learned connection weights to ‘guide’ our architecture evolution algorithm in a preferable way, which we discuss more in Section 3.2.
+
+If the inputs from different nodes differ in their spatial size, we add spatial max pooling and striding to match their spatial size. If the inputs have different channel sizes, we add a 1x1 conv. layer to match the bigger channel size. Temporal sizes of the representations is always consistent in our graphs, as there is no temporal striding in our formulation and the layers in the nodes are fully convolutional.
+
+![](images/194c3d7588b709dce9d1701e42c4db805139f652c555b67dd26f782fa6908d2d.jpg)  
+Figure 2: An example showing a sequence of architecture evolution. These architectures have actual parent-child relationships. The fitness of the third model was worse than the second model (due to random mutations), but it was high enough to survive in the population pool and eventually evolve into a better model.
+
+# 3.2 EVOLUTION
+
+We design an evolutionary algorithm with discrete mutation operators that modify nodes and edges in architectures over iterations. The algorithm maintains a population of $P$ different architectures, $P = \{ G _ { 1 } , G _ { 2 } , \cdot \cdot \cdot , G _ { | P | } \}$ , where each architecture $G$ is represented with a set of nodes and their edges as described above.
+
+The initial population is formed by preparing a fixed number of randomly connected architectures (e.g., $| P | = 2 0 ,$ ). Specifically, we (1) prepare a fixed number of stems and nodes at each level (e.g., two per level), (2) apply a number of node split/merge mutation operators which we discuss more below, and (3) randomly connect nodes with the probability $p = 0 . 5$ while discarding architectures with graph depth $< 4$ . As mentioned above, edges are constrained so that there is no directed edge reversing the level ordering. Essentially, a set of overly-connected architectures are used as a starting point. Temporal resolutions are randomly assigned to the nodes.
+
+We use the tournament selection algorithm (Goldberg & Deb, 1991) as the main evolution framework: At each evolution round, the algorithm updates the population by selecting a ‘parent’ architecture and mutating (i.e., modifying) it to generate a new ‘child’ architecture. The parent is selected by randomly sampling a subset of the entire population $P ^ { \prime } \subset P$ , and then computing the architecture with the highest ‘fitness’: $G _ { p } = \mathrm { a r g m a x } _ { G _ { i } \in P ^ { \prime } } f ( G _ { i } )$ where $f ( G )$ is the fitness function. Our fitness is defined as a video classification accuracy of the model, measured by training the model with a certain number of initial iterations and then evaluating it on the validation set as its proxy task. More specifically, we use top-1 accuracy $^ +$ top-5 accuracy as the fitness function. The child is added into the population, and the model with the least fitness is discarded from the population.
+
+A child is evolved from the parent by following two steps. First, it changes the block connectivity (i.e., edges) based on their learned weights: ‘connection-learning-guided evolution’. Next, it applies a random number of mutation operators to further modify the node configuration. The mutation operators include (1) a random modification of the temporal resolution of a convolutional block (i.e., a node) as well as (2) a merge or split of a block. When splitting a node into two nodes, we make their input/output connections identical while making the number of channels in their convolutional layers half that of the node before the split (i.e., $C = C _ { p } / 2$ where $C _ { p }$ is the channel size of the parent). More details are found in Appendix. As a result, we maintain the total number of parameters, since splitting or merging does not change the number of parameters of the convolutional blocks.
+
+Connection-Learning-Guided Mutation. Instead of randomly adding, removing or modifying block connections to generate the child architecture, we take advantage of the learned connection weights from its parent architecture. Let $E _ { p }$ be the set of edges of the parent architecture. Then the edges of the child architecture $E _ { c }$ are inherited from $E _ { p }$ , by only maintaining high-weight connections while replacing the low-weight connections with new random ones. Specifically, $E _ { c } = E _ { c } ^ { 1 } \cup E _ { c } ^ { 2 }$ :
+
+$$
+E _ { c } ^ { 1 } = \left\{ e \in E _ { p } \mid W _ { e } > B \right\} , \quad E _ { c } ^ { 2 } = \left\{ e \in \left( E _ { * } - E _ { p } \right) \mid \frac { | E _ { p } - E _ { c } ^ { 1 } | } { | E - E _ { p } | } > X _ { e } \right\}
+$$
+
+where $X \sim \mathrm { u n i f } ( 0 , 1 )$ and $E _ { * }$ is the set of all possible edges. $E _ { c } ^ { 1 }$ corresponds to the edges the child architecture inherits from the parent architecture, decided based on the learned weight of the edge $W _ { e }$
+
+![](images/c1e825f4d108f3f9a43072bb9b56751de0658480b6cd479476bd11664238a9c4.jpg)  
+Figure 3: More AssembleNet examples. Similarly good performing diverse architectures, all with higher-than- $50 \%$ mean-average precision on Charades. For instance, even our simpler two-stem AssembleNet-50 (left) got $5 1 . 4 \%$ mAP on Charades. Darker edges mean higher weights.
+
+This is possible because our fitness measure involves initial proxy training of each model, providing the learned connection weight values $W _ { e }$ of the parent.
+
+$B$ , which controls whether or not to keep an edge from the parent architecture, could either be a constant threshold or a random variable following a uniform distribution: $B = b$ or $B = X _ { B } \sim$ unif $( 0 , 1 )$ . $E _ { c } ^ { 2 }$ corresponds to the new randomly added edges which were not in the parent architecture. We enumerate through each possible new edge, and randomly add it with the probably of $| E _ { p } -$ $E _ { c } ^ { 1 } | / | E - E _ { p } |$ . This makes the expected total number of added edges to be $| E _ { p } - E _ { c } ^ { 1 } |$ , maintaining the size of $E _ { c }$ . Figure 2 shows an example of the evolution process and Figure 3 shows final architectures.
+
+Evolution Implementation Details. Initial architectures are formed by randomly preparing either $\{ 2 \mathrm { o r } 4 \}$ stems, two nodes per level at levels 1 to 3, and one node at level 4. We then apply $1 { \sim } 5$ random number of node split operators so that each initial architecture has a different number of nodes. Each node is initialized with a random temporal resolution of 1, 2, 4, or 8. As mentioned, each possible connection is then added with the probability of $p = 0 . 5$ .
+
+At each evolution round, the best-performing parent architecture is selected from a random subset of 5 from the population. The child architecture is generated by modifying the connections from the parent architecture (Section 3.2). A random number of node split, merge, or temporal resolution change mutation operators $( 0 { \sim } 4 )$ are then applied. Evaluation of each architecture (i.e., measuring the fitness) is done by training the model for 10K iterations and then measuring its top- $1 + \mathrm { t o p } { - } 5$ accuracy on the validation subset. The Moments-in-Time dataset, described in the next section, is used as the proxy dataset to measure fitness. The evolution was run for ${ \sim } 2 0 0$ rounds, although a good performing architecture was found within only 40 rounds (e.g., Figure 3-right). Figure 1 shows the model found at the 165th round. 10K training iterations of each model during evolution took $3 { \sim } 5$ hours; with our setting, evolving a model for 40 rounds took less than a day with 10 parallel workers.
+
+# 4 EXPERIMENTS
+
+# 4.1 DATASETS
+
+Charades Dataset. We first test on the popular Charades dataset (Sigurdsson et al., 2016) which is unique in the activity recognition domain as it contains long sequences. It is one of the largest public datasets with continuous action videos, containing 9848 videos of 157 classes (7985 training and 1863 testing videos). Each video is ${ \sim } 3 0 $ seconds. It is a challenging dataset due to the duration and variety of the activities. Activities may temporally overlap in a Charades video, requiring the model to predict multiple class labels per video. We used the standard ‘Charades v1 classify’ setting for the evaluation. To comply with prior work (e.g. Feichtenhofer et al., 2018), we also report results when pre-training on Kinetics (Carreira & Zisserman, 2017), which is another large-scale dataset.
+
+Table 1: Reported state-of-the-art action classification performances (vs. AssembleNet) on Charades. ‘2-stream $( 2 + 1 ) \mathrm { D }$ ResNet-50’ is the two-stream model with connection learning for level-4 fusion.   
+
+<table><tr><td>Method</td><td>pre-train</td><td>modality</td><td>mAP</td></tr><tr><td>2-stream (Simonyan &amp; Zisserman, 2014)</td><td>UCF101</td><td>RGB+Flow</td><td>18.6</td></tr><tr><td>Asyn-TF (Sigurdsson et al., 2017)</td><td>UCF101</td><td>RGB+Flow</td><td>22.4</td></tr><tr><td>CoViAR (Wu et al., 2018b)</td><td>ImageNet</td><td>Compressed</td><td>21.9</td></tr><tr><td>MultiScale TRN (Zhou et al., 2018)</td><td>ImageNet</td><td>RGB</td><td>25.2</td></tr><tr><td>I3D (Carreira &amp; Zisserman, 2017)</td><td>Kinetics</td><td>RGB</td><td>32.9</td></tr><tr><td>I3D (from Wang et al., 2018)</td><td>Kinetics</td><td>RGB</td><td>35.5</td></tr><tr><td>I3D-NL (Wang et al., 2018)</td><td>Kinetics</td><td>RGB</td><td>37.5</td></tr><tr><td>STRG (Wang &amp; Gupta, 2018)</td><td>Kinetics</td><td>RGB</td><td>39.7</td></tr><tr><td>LFB-101 (Wu et al., 2018a)</td><td>Kinetics</td><td>RGB</td><td>42.5</td></tr><tr><td>SlowFast-1O1 (Feichtenhofer et al., 2018)</td><td>Kinetics</td><td>RGB+RGB</td><td>45.2</td></tr><tr><td>2-stream (2+1)D ResNet-50 (ours)</td><td>MiT</td><td>RGB+Flow</td><td>48.7</td></tr><tr><td>2-stream (2+1)D ResNet-50 (ours)</td><td>Kinetics</td><td>RGB+Flow</td><td>50.4</td></tr><tr><td>2-stream (2+1)D ResNet-101 (ours)</td><td>Kinetics</td><td>RGB+Flow</td><td>50.6</td></tr><tr><td>AssembleNet-50 (ours)</td><td>MiT</td><td>RGB+Flow</td><td>53.0</td></tr><tr><td>AssembleNet-50 (ours)</td><td>Kinetics</td><td>RGB+Flow</td><td>56.6</td></tr><tr><td>AssembleNet-101 (ours)</td><td>Kinetics</td><td>RGB+Flow</td><td>58.6</td></tr></table>
+
+Table 2: State-of-the-art action classification accuracies on Moments in Time (Monfort et al., 2018).   
+
+<table><tr><td>Method</td><td>modality</td><td>Top-1</td><td>Top-5</td></tr><tr><td>ResNet50-ImageNet</td><td>RGB</td><td>27.16</td><td>51.68</td></tr><tr><td>TSN (Wang et al., 2016)</td><td>RGB</td><td>24.11</td><td>49.10</td></tr><tr><td>Ioffe &amp; Szegedy (2015)</td><td>Flow</td><td>11.60</td><td>27.40</td></tr><tr><td>TSN-Flow (Wang et al.,2016)</td><td>Flow</td><td>15.71</td><td>34.65</td></tr><tr><td>TSN-2Stream (Wang et al., 2016)</td><td>RGB+F</td><td>25.32</td><td>50.10</td></tr><tr><td>TRN-Multi (Zhou et al.,2018)</td><td>RGB+F</td><td>28.27</td><td>53.87</td></tr><tr><td>Two-stream (2+1)D ResNet-50</td><td>RGB+F</td><td>28.97</td><td>55.55</td></tr><tr><td>I3D (Carreira &amp; Zisserman,2017)</td><td>RGB+F</td><td>29.51</td><td>56.06</td></tr><tr><td>AssembleNet-50</td><td>RGB+F</td><td>31.41</td><td>58.33</td></tr><tr><td>AssembleNet-50 (with Kinetics)</td><td>RGB+F</td><td>33.91</td><td>60.86</td></tr><tr><td>AssembleNet-101 (with Kinetics)</td><td>RGB+F</td><td>34.27</td><td>62.71</td></tr></table>
+
+![](images/2c86efeaf42b69f2963779f0a8591a645031fcb5cfc9c26136087e6b04284d67.jpg)  
+Figure 4: Comparison of different search methods.
+
+We note that Kinetics is shrinking in size $( \sim 1 5 \%$ videos removed from the original Kinetics-400) and the previous versions are no longer available from the official site.
+
+Moments in Time (MiT) Dataset. The Moments in Time (MiT) dataset (Monfort et al., 2018) is a large-scale video classification dataset with more than 800K videos ${ \sim } 3$ seconds per video). It is a very challenging dataset with the state-of-the-art models obtaining less than $30 \%$ accuracy. We use this dataset for the architecture evolution, and train/test the evolved models. We chose the MiT dataset because it provides a sufficient amount of training data for video CNN models and allows stable comparison against previous models. We used its standard classification evaluation setting.
+
+# 4.2 RESULTS
+
+Tables 1 and 2 compare the performance of AssembleNet against the state-of-the-art models. We denote AssembleNet more specifically as AssembleNet-50, since its depth is 50 layers and has an equivalent number of parameters to ResNet-50. AssembleNet-101 is its 101 layer version having equivalent number of parameters to ResNet-101. AssembleNet is outperforming prior works on both datasets, setting new state-of-the-art results for them. Its performance on MiT is the first above $34 \%$ . We also note that the performances on Charades is even more impressive at 58.6 whereas previous known best results are 42.5 and 45.2. For these experiments, the architecture search was done on the MiT dataset, and then the found models are trained and tested on both datasets, which demonstrates that the found architectures are useful across datasets.
+
+Table 3: Comparison between AssembleNet and architectures without evolution, but with connection weight learning. Four-stream models are reported here for the first time, and are very effective. All these models have a similar number of parameters.   
+
+<table><tr><td>Architecture</td><td>MiT Charades</td></tr><tr><td>Two-stream (late fusion) 28.97</td><td>46.5</td></tr><tr><td>Two-stream (fusion at lv. 4) Two-stream (flow-→RGB inter.)</td><td>30.00 48.7 30.21</td></tr><tr><td>Two-stream (fully, fuse at 4)</td><td>49.5 29.87 50.5</td></tr><tr><td>Four-stream (fully, fuse at 4)</td><td>29.98 50.7</td></tr><tr><td>Random (+ connection learning） 2</td><td>29.91 50.1</td></tr><tr><td>AssembleNet-50</td><td>31.41 53.0</td></tr></table>
+
+Table 4: Ablation comparing different AssembleNet architectures found with full vs. constrained search spaces. The models are trained from scratch.   
+
+<table><tr><td>Architecture MiT</td></tr><tr><td>Baseline (random + conn. learning) 29.91</td></tr><tr><td>No mutation 30.26</td></tr><tr><td>RGB-only 30.30</td></tr><tr><td>Without temporal dilation 30.49</td></tr><tr><td>Two-stem only 30.75</td></tr><tr><td>Full AssembleNet-50 31.41</td></tr></table>
+
+In addition, we compare the proposed connection-learning-guided evolution with random architecture search and the standard evolutionary algorithm with random connection mutations. We made the standard evolutionary algorithm randomly modify 1/3 of the total connections at each round, as that is roughly the number of edges the connection-learning-guided evolution modifies. Figure 4 shows the results, visualizing the average fitness score of the three top-performing models in each pool. We observe that the connection-learning-guided evolution is able to find better architectures, and it is able to do so more quickly. The standard evolution performs similarly to random search and is not as effective. We believe this is due to the large search space the approach is required to handle, which is exponential to the number of possible connections. For instance, if there are $N$ nodes, the search space complexity is $2 ^ { O ( N ^ { 2 } ) }$ just for the connectivity search. Note that the initial ${ \sim } 3 0 $ rounds are always used for random initialization of the model population, regardless of the search method.
+
+# 4.3 ABLATION STUDIES
+
+We conduct an ablation study comparing the evolved AssembleNet to multiple $( 2 + 1 ) \mathrm { D }$ two-stream (or multi-stream) architectures which are designed to match the abilities of Assemblenet but without evolution. We note that these include very strong architectures that have not been explored before, such as the four-stream model with dense intermediate connectivity. We design competitive networks having various connections between streams, where the connection weights are also learned (see the supplementary material for detailed descriptions and visualizations). Note that all these models have equivalent capacity (i.e., number of parameters). The performance difference is due to network structure. Table 3 shows the results, demonstrating that these architectures with learnable interconnectivity are very powerful themselves and evolution is further beneficial. The Moments in Time models were trained from scratch, and the Charades models were pre-trained on MiT. In particular, we evaluated an architecture with intermediate connectivity from the flow stream to RGB, inspired by Feichtenhofer et al. (2016b; 2018) $^ +$ connection weight learning). It gave $3 0 . 2 \%$ accuracy on MiT and $4 9 . 5 \%$ on Charades, which are not as accurate as AssembleNet. Randomly generated models (from 50 rounds of search) are also evaluated, confirming that such architectures do not perform well.
+
+Further, we conduct another ablation to confirm the effectiveness of our search space. Table 4 compares the models found with our full search space vs. more constrained search spaces, such as only using two stems and not using temporal dilation (i.e., fixed temporal resolution).
+
+# 4.4 GENERAL FINDINGS
+
+As the result of connection-learning-guided architecture evolution, non-obvious and non-intuitive connections are found (Figure 3). As expected, more than one possible “connectivity” solution can yield similarly good results. Simultaneously, models with random connectivity perform poorly compared to the found AssembleNet. Our observations also include: (1) The models prefer to have only one block at the highest level, although we allow the search to consider having more than one block at that level. (2) The final block prefers simple connections gathering all outputs of the blocks in the 2nd to last level. (3) Many models use multiple blocks with different temporal resolutions at the same level, justifying the necessity of the multi-stream architectures. (4) Often, there are 1 or 2 blocks heavily connected to many other blocks. (5) Architectures prefer using more than 2 streams, usually using 4 at many levels.
+
+# 5 CONCLUSION
+
+We present AssembleNet, a new approach for neural architecture search using connection-learningguided architecture evolution. AssembleNet finds multi-stream architectures with better connectivity and temporal resolutions for video representation learning. Our experiments confirm that the learned models significantly outperform previous models on two challenging benchmarks.
+
+# REFERENCES
+
+Karim Ahmed and Lorenzo Torresani. Connectivity learning in multi-branch networks. In Workshop on Meta-Learning (MetaLearn), NeurIPS, 2017.
+
+Gabriel Bender, Pieter-Jan Kindermans, Barret Zoph, Vijay Vasudevan, and Quoc Le. Understanding and simplifying one-shot architecture search. In International Conference on Machine Learning (ICML), 2018.
+
+Joao Carreira and Andrew Zisserman. Quo vadis, action recognition? a new model and the kinetics dataset. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2017.
+
+Liang-Chieh Chen, George Papandreou, Iasonas Kokkinos, Kevin Murphy, and Alan L. Yuille. Deeplab: Semantic image segmentation with deep convolutional nets, atrous convolution, and fully connected crfs. IEEE TPAMI, 40(4), 2018.
+
+Ali Diba, Mohsen Fayyaz, Vivek Sharma, Manohar Paluri, Jurgen Gall, , Rainer Stiefelhagen, and Luc Van Gool. Holistic large scale video understanding. In CoRR:1904.11451, 2019.
+
+Christoph Feichtenhofer, Axel Pinz, and Richard Wildes. Spatiotemporal residual networks for video action recognition. In Advances in Neural Information Processing Systems (NeurIPS), pp. 3468–3476, 2016a.
+
+Christoph Feichtenhofer, Axel Pinz, and Andrew Zisserman. Convolutional two-stream network fusion for video action recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 1933–1941, 2016b.
+
+Christoph Feichtenhofer, Axel Pinz, and Richard P Wildes. Spatiotemporal multiplier networks for video action recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 4768–4777, 2017.
+
+Christoph Feichtenhofer, Haoqi Fan, Jitendra Malik, and Kaiming He. Slowfast networks for video recognition. arXiv preprint arXiv:1812.03982, 2018.
+
+David E. Goldberg and Kalyanmoy Deb. A comparative analysis of selection schemes used in genetic algorithms. In Foundations of Genetic Algorithms, pp. 69–93. Morgan Kaufmann, 1991.
+
+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 (CVPR), 2016.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In International Conference on Machine Learning (ICML), 2015.
+
+Colin Lea, Michael D. Flynn, Rene Vidal, Austin Reiter, and Gregory D. Hager. Temporal convolutional networks for action segmentation and detection. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2017.
+
+Chenxi Liu, Barret Zoph, Maxim Neumann, Jonathon Shlens, Wei Hua, Li-Jia Li, Li Fei-Fei, Alan Yuille, Jonathan Huang, and Kevin Murphy. Progressive neural architecture search. In Proceedings of European Conference on Computer Vision (ECCV), 2018.
+
+Hanxiao Liu, Karen Simonyan, and Yiming Yang. DARTS: Differentiable architecture seach. In International Conference on Learning Representations (ICLR), 2019.
+
+Mathew Monfort, Alex Andonian, Bolei Zhou, Kandan Ramakrishnan, Sarah Adel Bargal, Tom Yan, Lisa Brown, Quanfu Fan, Dan Gutfruend, Carl Vondrick, et al. Moments in time dataset: one million videos for event understanding. arXiv preprint arXiv:1801.03150, 2018.
+
+AJ Piergiovanni and Michael S Ryoo. Representation flow for action recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2019.
+
+Esteban Real, Alok Aggarwal, Yanping Huang, and Quoc V. Le. Regularized evolution for image classifier architecture search. In Proceedings of AAAI Conference on Artificial Intelligence (AAAI), 2019.
+
+Gunnar A. Sigurdsson, Gul Varol, Xiaolong Wang, Ali Farhadi, Ivan Laptev, and Abhinav Gupta. ¨ Hollywood in homes: Crowdsourcing data collection for activity understanding. In Proceedings of European Conference on Computer Vision (ECCV), 2016.
+
+Gunnar A Sigurdsson, Santosh Divvala, Ali Farhadi, and Abhinav Gupta. Asynchronous temporal fields for action recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2017.
+
+Karen Simonyan and Andrew Zisserman. Two-stream convolutional networks for action recognition in videos. In Advances in Neural Information Processing Systems (NeurIPS), pp. 568–576, 2014.
+
+Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 2818–2826, 2016.
+
+Du Tran, Lubomir D Bourdev, Rob Fergus, Lorenzo Torresani, and Manohar Paluri. C3d: generic features for video analysis. CoRR, abs/1412.0767, 2(7):8, 2014.
+
+Du Tran, Heng Wang, Lorenzo Torresani, Jamie Ray, Yann LeCun, and Manohar Paluri. A closer look at spatiotemporal convolutions for action recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 6450–6459, 2018.
+
+Limin Wang, Yuanjun Xiong, Zhe Wang, Yu Qiao, Dahua Lin, Xiaoou Tang, and Luc Van Gool. Temporal segment networks: Towards good practices for deep action recognition. In Proceedings of European Conference on Computer Vision (ECCV), pp. 20–36. Springer, 2016.
+
+Xiaolong Wang and Abhinav Gupta. Videos as space-time region graphs. In Proceedings of European Conference on Computer Vision (ECCV), pp. 399–417, 2018.
+
+Xiaolong Wang, Ross Girshick, Abhinav Gupta, and Kaiming He. Non-local neural networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 7794–7803, 2018.
+
+Chao-Yuan Wu, Christoph Feichtenhofer, Haoqi Fan, Kaiming He, Philipp Krahenb ¨ uhl, and Ross Gir- ¨ shick. Long-term feature banks for detailed video understanding. arXiv preprint arXiv:1812.05038, 2018a.
+
+Chao-Yuan Wu, Manzil Zaheer, Hexiang Hu, R Manmatha, Alexander J Smola, and Philipp Krahenb ¨ uhl. Compressed video action recognition. In ¨ Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 6026–6035, 2018b.
+
+Saining Xie, Chen Sun, Jonathan Huang, Zhuowen Tu, and Kevin Murphy. Rethinking spatiotemporal feature learning: Speed-accuracy trade-offs in video classification. In Proceedings of European Conference on Computer Vision (ECCV), pp. 305–321, 2018.
+
+Saining Xie, Alexander Kirillov, Ross Girshick, and Kaiming He. Exploring randomly wired neural networks for image recognition. In CoRR:1904.01569, 2019.
+
+Fisher Yu and Vladlen Koltun. Multi-scale context aggregation by dilated convolutions. In International Conference on Learning Representations (ICLR), 2016.
+
+Christopher Zach, Thomas Pock, and Horst Bischof. A duality based approach for realtime tv-l 1 optical flow. In Joint Pattern Recognition Symposium, pp. 214–223. Springer, 2007.
+
+Bolei Zhou, Alex Andonian, Aude Oliva, and Antonio Torralba. Temporal relational reasoning in videos. In Proceedings of European Conference on Computer Vision (ECCV), pp. 803–818, 2018.
+
+Barret Zoph and Quoc Le. Neural architecture search with reinforcement learning. In International Conference on Learning Representations (ICLR), 2017.
+
+Barret Zoph, Vijay Vasudevan, Jonathon Shlens, and Quoc V. Le. Learning transferable architectures for scalable image recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2018.
+
+# A APPENDIX
+
+# A.1 SUPER-GRAPH VISUALIZATION OF THE CONNECTIVITY SEARCH SPACE
+
+Figure 5 visualizes all possible connections and channel/temporal resolution options our architecture evolution is able to consider. The objective of our evolutionary algorithm could be interpreted as finding the optimal sub-graph (of this super-graph) that maximizes the performance while maintaining the number of total parameters. Trying to directly fit such entire super-graph into the memory was infeasible in our experiments.
+
+![](images/ada175942c052a2ee09b2247ff89198586ec5515117df6d58adb8174098cc07c.jpg)  
+Figure 5: Visualization of the super-graph corresponding to our video architecture search space.
+
+A.2 CHANNEL SIZES OF THE LAYERS AND NODE SPLIT/MERGE MUTATIONS
+
+As we described in the paper, each node (i.e., a convolutional block) has a parameter $C$ controlling the number of filters of the convolutional layers in the block. When splitting or merging blocks, the number of filters are split or combined respectively. Figure 6 provides a visualization of a block with number of filter specified to the right and a split operation. While many designs are possible, we design the blocks and splitting as follows. The size of 1x1 convolutional layers and 1D temporal convolutional layers are strictly governed by $C$ , having the channel size of $C$ (some $4 C$ ). On the other hand, the number of 2D convolutional layer is fixed per level as a constant $D _ { v }$ where $v$ is the level of the block. $D _ { 1 } = 6 4$ , $D _ { 2 } = 1 2 8$ , $D _ { 3 } = 2 5 6$ , and $D _ { 4 } = 5 1 2$ . The layers in the stems have 64 channels if there are only two stems and 32 if there are four stems.
+
+When a node is split into two nodes, we update the resulting two nodes’ channel sizes to be half of their original node. This enables us to maintain the total number of model parameters before and after the node split to be identical. The first 1x1 convolutional layer will have half the parameters after the split, since its output channel size is now 1/2. The 2D convolutional layer will also have exactly half the parameters, since its input channel size is $1 / 2$ while the output channel size is staying fixed. The next 1x1 convolutional layer will have the fixed input channel size while the output channel size becomes 1/2: thus the total number of parameters would be $1 / 2$ of the original parameters.
+
+Merging of the nodes is done in an inverse of the way we split. When merging two nodes into one, the merged node inherits all input/output connections from the two nodes: we take a union of all the connections. The channel size of the merged node is the sum of the channel sizes of the two nodes being merged. The temporal dilation rate of the merged node is randomly chosen between the two nodes before the merge.
+
+# A.3 HAND-DESIGNED MODELS USED IN THE ABLATION STUDY
+
+Figure 7 illustrates the actual architectures of the hand-designed $( 2 + 1 ) \mathrm { D }$ CNN models used in our ablation study. We also show the final learned weights of the connections, illustrating which connections the model ended up using or not using. We note that these architectures are also very enlightening as the connectivity within them are learned in the process. We observe that stronger connections tend to be formed later for 2-stream architectures. For 4-stream architectures, stronger connections do form early, and, not surprisingly, a connection to at least one node of a different modality is established, i.e. a node stemming from RGB will connect to at least one flow node at the next level and vice versa.
+
+![](images/18130f671084e14cf9eacf7ef1ff26dd093fb31702ea9bb8a07aff6a4b8ea181.jpg)  
+Figure 6: An illustration of the node split mutation operator, used for both evolution and initial architecture population generation.
+
+![](images/f887a20794a882d74bdda474110c89e5d746f2f44ddc2b1095cc3fc5ef2ebbea.jpg)  
+Figure 7: Illustration of hand-designed baseline $( 2 + 1 ) \mathrm { D }$ CNN models used in our ablation study.
+
+Below is a more detailed description of the networks used in the paper: “Two-stream (late fusion)” means that the model has two separate streams at every level including the level 4, and the outputs of such two level 4 nodes are combined for the final classification. “Fusion at lv. 4” is the model that only has one level 4 node to combine the outputs of the two level 3 nodes using a weighted summation. “Two-stream (fully)” means that the model has two nodes at each level 1-3 and one node at level 4, and each node is always connected to every node in the immediate next level. “Flow RGB” means that only the RGB stream nodes combine outputs from both RGB and flow stream nodes of the immediate lower level.
+
+Table 5: The table form of the AssembleNet model with detailed parameters. This model corresponds to Figure 1. The parameters correspond to {node level, input node list, $C , r .$ , and spatial stride}   
+
+<table><tr><td rowspan=1 colspan=1>Index</td><td rowspan=1 colspan=1>Block parameters</td></tr><tr><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0,[RGB], 32, 4, 4</td></tr><tr><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0,[RGB], 32,4,4</td></tr><tr><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>0,[Flow], 32,1, 4</td></tr><tr><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>0,[Flow], 32, 1, 4</td></tr><tr><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>1, [1], 32, 1, 1</td></tr><tr><td rowspan=1 colspan=1>5</td><td rowspan=1 colspan=1>1, [0], 32, 4, 1</td></tr><tr><td rowspan=1 colspan=1>6</td><td rowspan=1 colspan=1>1,[0,1,2,3], 32, 1,1</td></tr><tr><td rowspan=1 colspan=1>7</td><td rowspan=1 colspan=1>1,[2,3], 32,2, 1</td></tr><tr><td rowspan=1 colspan=1>8</td><td rowspan=1 colspan=1>2, [0, 4, 5, 6, 7], 64, 2, 2</td></tr><tr><td rowspan=1 colspan=1>9</td><td rowspan=1 colspan=1>2,[0,2,4,7],64,1,2</td></tr><tr><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>2, [0, 5, 7], 64, 4, 2</td></tr><tr><td rowspan=1 colspan=1>11</td><td rowspan=1 colspan=1>2, [0, 5], 64,1,2</td></tr><tr><td rowspan=1 colspan=1>12</td><td rowspan=1 colspan=1>3, [4, 8, 10, 11], 256, 1, 2</td></tr><tr><td rowspan=1 colspan=1>13</td><td rowspan=1 colspan=1>3, [8, 9], 256, 4, 2</td></tr><tr><td rowspan=1 colspan=1>14</td><td rowspan=1 colspan=1>4,[12, 13], 512, 2, 2</td></tr></table>
+
+# A.4 ASSEMBLENET MODEL/LAYER DETAILS
+
+We also provide the final AssembleNet model in table form in Table 5. In particular, the 2nd element of each block description shows the list of where the input to that block is coming from (i.e., the connections). As already mentioned, 2D and $( 2 + 1 ) \mathrm { D }$ residual modules are repeated in each block. The number of repetitions $m$ are 1.5, 2, 3, and 1.5 at each level. $m = 1 . 5$ means that we have one 2D residual module, one $( 2 + 1 ) \mathrm { D }$ module, and one more 2D module. This makes the number of convolutional layers of each block at levels 1-4 to be 9, 12, 18, and 9. In addition, a stem has at most 2 convolutional layers. The total depth of our network is 50, similar to a conventional $( 2 + 1 ) \mathrm { D }$ ResNet-50. For AssembleNet-101, we use $m = 1 . 5$ , 2, 11.5, and 1.5 at each level.
+
+If a block has a spatial stride of 2, the striding happens at the first 2D convolutional layer of the block. In the stem which has the spatial stride of 4, the striding of size 2 happens twice, once at the 2D convolutional layer and at the max pooling layer. As mentioned, the model has a batch normalization layer followed by ReLU after every convolutional layer regardless of its type (i.e., 2D, 1D, and 1x1). 2D conv. filter sizes are $3 { \tt X } 3$ , and 1D conv. filter sizes are 3.
+
+# A.5 SINK NODE DETAILS
+
+When each evolved or baseline $( 2 + 1 ) \mathrm { D }$ model is applied to a video, it generates a 5D (BTYXC) tensor after the final convolutional layer, where B is the size of the batch and C is the number of channels. The sink node is responsible for mapping this into the output vector, whose dimensionality is identical to the number of video classes in the dataset. The sink node first applies a spatial average pooling to generate a 3D (BTC) tensor. If there are multiple level 4 nodes (which rarely is the case), the sink node combines them into a single tensor by averaging/concatenating them. Averaging or concatenating does not make much difference empirically. Next, temporal average/max pooling is applied to make the representation a 2D (BC) tensor (average pooling was used for the MiT dataset and max pooling was used for Charades), and the final fully connected layer and the soft max layer is applied to generate the final output.
+
+# A.6 TRAINING DETAILS
+
+For the Moments in Time (MiT) dataset training, 8 videos are provided per TPU core (with 16GB memory): the total batch size (for each gradient update) is 512 with 32 frames per video. The batch size used for Charades is 128 with 128 frames per video. The base framerate we used is 12.5 fps for MiT and 6 fps for Charades. The spatial input resolution is $2 2 4 \mathbf { x } 2 2 4$ during training. We used the standard Momentum Optimizer in TensorFlow. We used a learning rate of 3.2 (for MiT) and 25.6 (for Charades), 12k warmup iterations, and cosine decay. No dropout is used, weight decay is set to 1e-4 and label smoothing set to 0.2.
+
+Training a model for $1 0 \mathrm { k }$ iterations (during evolution) took $3 { \sim } 5$ hours and fully training the model (for 50k iterations) took ${ \sim } 2 4$ hours per dataset.
+
+We used the TV-L1 optical flow extraction algorithm (Zach et al., 2007) implemented with tensor operations by Piergiovanni & Ryoo (2019) to obtain flow input.
+
+# A.7 EVALUATION DETAILS
+
+When evaluating a model on the MiT dataset, we provide 36 frames per video. The duration of each MiT video is 3 seconds, making 36 frames roughly correspond to the entire video. For the Charades dataset where each video duration is roughly ${ \sim } 3 0 $ seconds, the final class labels are obtained by applying the model to five random 128 frame crops (i.e., segments) of each video. The output multi-class labels are max-pooled to get the final label, and is compared to the ground truth to measure the average precision scores. The spatial resolution used for the testing is $2 5 6 \times 2 5 6$ .

parse/train/SJgMK64Ywr/SJgMK64Ywr_content_list.json

@@ -0,0 +1,1543 @@
+[
+    {
+        "type": "text",
+        "text": "ASSEMBLENET: SEARCHING FOR MULTI-STREAM NEURAL CONNECTIVITY IN VIDEO ARCHITECTURES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            821,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Michael S. Ryoo1,2, AJ Piergiovanni1,2,3, Mingxing Tan2 & Anelia Angelova1,2 ",
+        "bbox": [
+            184,
+            169,
+            728,
+            184
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1Robotics at Google   \n2Google Research   \n3Indiana University Bloomington   \nmryoo@google.com ",
+        "bbox": [
+            184,
+            185,
+            405,
+            241
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            277,
+            544,
+            292
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Learning to represent videos is a very challenging task both algorithmically and computationally. Standard video CNN architectures have been designed by directly extending architectures devised for image understanding to include the time dimension, using modules such as 3D convolutions, or by using two-stream design to capture both appearance and motion in videos. We interpret a video CNN as a collection of multi-stream convolutional blocks connected to each other, and propose the approach of automatically finding neural architectures with better connectivity and spatio-temporal interactions for video understanding. This is done by evolving a population of overly-connected architectures guided by connection weight learning. Architectures combining representations that abstract different input types (i.e., RGB and optical flow) at multiple temporal resolutions are searched for, allowing different types or sources of information to interact with each other. Our method, referred to as AssembleNet, outperforms prior approaches on public video datasets, in some cases by a great margin. We obtain $5 8 . 6 \\%$ mAP on Charades and $3 4 . 2 7 \\%$ accuracy on Moments-in-Time. ",
+        "bbox": [
+            233,
+            306,
+            766,
+            512
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            535,
+            336,
+            551
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Learning to represent videos is a challenging problem. Because a video contains spatio-temporal data, its representation is required to abstract both appearance and motion information. This is particularly important for tasks such as activity recognition, as understanding detailed semantic contents of the video is needed. Previously, researchers approached this challenge by designing a two-stream model for appearance and motion information respectively, combining them by late or intermediate fusion to obtain successful results: Simonyan & Zisserman (2014); Feichtenhofer et al. (2016b;a; 2017; 2018). However, combining appearance and motion information is an open problem and the study on how and where different modalities should interchange representations and what temporal aspect/resolution each stream (or module) should focus on has been very limited. ",
+        "bbox": [
+            174,
+            565,
+            825,
+            689
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we investigate how to learn feature representations across spatial and motion visual clues. We propose a new multi-stream neural architecture search algorithm with connection learning guided evolution, which focuses on finding higher-level connectivity between network blocks taking multiple input streams at different temporal resolutions. Each block itself is composed of multiple residual modules with space-time convolutional layers, learning spatio-temporal representations. Our architecture learning not only considers the connectivity between such multi-stream, multi-resolution blocks, but also merges and splits network blocks to find better multi-stream video CNN architectures. Our objective is to address two main questions in video representation learning: (1) what feature representations are needed at each intermediate stage of the network and at which resolution and (2) how to combine or exchange such intermediate representations (i.e., connectivity learning). Unlike previous neural architecture search methods for images that focus on finding a good ‘module’ of convolutional layers to be repeated in a single-stream networks (Zoph et al., 2018; Real et al., 2019), our objective is to search for higher-level connections between multiple sequential or concurrent blocks to form multi-stream architectures. ",
+        "bbox": [
+            174,
+            696,
+            825,
+            888
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We propose the concept of AssembleNet, a new method of fusing different sub-networks with different input modalities and temporal resolutions. AssembleNet is a general formulation that allows representing various forms of multi-stream CNNs as directed graphs, coupled with an efficient evolutionary algorithm to explore the network connectivity. Specifically, this is done by utilizing the learned connection weights to guide evolution, in addition to randomly combining, splitting, or connecting sub-network blocks. AssembleNet is a ‘family’ of learnable architectures; they provide a generic approach to learn connectivity among feature representations across input modalities, while being optimized for the target task. We believe this is the first work to (i) conduct research on automated architecture search with multi-stream connections for video understanding, and (ii) introduce the new connection-learning-guided evolutionary algorithm for neural architecture search. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/86acc0df5d6ad2360fb3f4e70dbfe72203edd22f47c166a12055c9b3d50d9f2c.jpg",
+        "image_caption": [
+            "Figure 1: AssembleNet with multiple intermediate streams. Example learned architecture. Darker colors of connections indicate stronger connections. At each convolutional block, multiple 2D and $( 2 + 1 ) \\mathrm { D }$ residual modules are repeated alternatingly. Our network has 4 block levels $^ +$ the stem level connected to raw data). Each convolutional block has its own output channel size (i.e., the number of filters) $C$ and the temporal resolution $r$ controlling the 1D temporal convolutional layers in it. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            325,
+            102,
+            676,
+            309
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            416,
+            825,
+            527
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Figure 1 shows an example learned AssembleNet. The proposed algorithm for learning video architectures is very effective: it outperforms all prior work and baselines on two very challenging benchmark datasets, and establishes a new state-of-the-art. AssembleNet models use equivalent number of parameters to standard two-stream $( 2 + 1 ) \\mathrm { D }$ ResNet models. ",
+        "bbox": [
+            174,
+            534,
+            825,
+            589
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 PREVIOUS WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            613,
+            348,
+            630
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A video is a spatio-temporal data (i.e., image frames concatenated along time axis), and its representation must abstract both spatial and temporal information. Full 3D space-time (i.e., XYT) convolutional layers as well as $( 2 + 1 ) \\mathrm { D }$ convolutional layers have been popularly used to represent videos (Tran et al., 2014; Carreira & Zisserman, 2017; Tran et al., 2018; Xie et al., 2018). Researchers studied replacing 2D convolutional layers in standard image-based CNNs such as Inception (Szegedy et al., 2016) and ResNet (He et al., 2016), so that it can be directly used for video classification. ",
+        "bbox": [
+            174,
+            647,
+            825,
+            729
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Two-stream network designs, which combine motion and appearance inputs, are commonly used (e.g., Simonyan & Zisserman, 2014; Feichtenhofer et al., 2016a; 2017; 2016b). Combining appearance information at two different temporal resolutions (e.g., 24 vs. 3 frames per second) with intermediate connections has been proposed by Feichtenhofer et al. (2018). Late fusion of the two-stream representations or architectures with more intermediate connections (Diba et al., 2019), have also been explored. However, these video CNN architectures are the result of careful manual designs by human experts. ",
+        "bbox": [
+            174,
+            737,
+            825,
+            834
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Neural Architecture Search (NAS), the concept of automatically finding better architectures based on data, is becoming increasingly popular (Zoph & Le, 2017; Zoph et al., 2018; Liu et al., 2018). Rather than relying on human expert knowledge to design a CNN model, neural architecture search allows the machines to generate better performing models optimized for the data. The use of reinforcement learning controllers (Zoph & Le, 2017; Zoph et al., 2018) as well as evolutionary algorithms (Real et al., 2019) have been studied, and they meaningfully outperform handcrafted architectures. Most of these works focus on learning architectures of modules (i.e., groupings of layers and their connections) to be repeated within a fixed single-stream meta-architecture (e.g., ResNet) for image-based object classification. One-shot architecture search to learn differentiable connections (Bender et al., 2018; Liu et al., 2019) has also been successful for images. However, it is very challenging to directly extend such work to find multi-stream models for videos, as it requires preparing all possible layers and interactions the final architecture may consider using. In multi-stream video CNNs, there are many possible convolutional blocks with different resolutions, and fully connecting them requires a significant amount of memory and training data, which makes it infeasible. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            213
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our work is also related to Ahmed & Torresani (2017) which used learnable gating to connect multiple residual module branches, and to the RandWire network (Xie et al., 2019), which showed that randomly connecting a sufficient number of convolutional layers creates performant architectures. However, similar to previous NAS work, the latter focuses only on generating connections between the layers within a block. The meta-architecture is fixed as a single stream model with a single input modality. In this work, our objective is to learn high-level connectivity between multi-stream blocks for video understanding driven by data. We confirm experimentally that in the multi-stream video CNNs, where multiple types of input modalities need to be considered at various resolutions, randomly connecting blocks is insufficient and the proposed architecture learning strategy is necessary. ",
+        "bbox": [
+            174,
+            220,
+            825,
+            344
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 ASSEMBLENET ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            364,
+            333,
+            381
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We propose a new principled way to find better neural architectures for video representation learning. We first expand a video CNN to a multi-resolution, multi-stream model composed of multiple sequential and concurrent neural blocks, and introduce a novel algorithm to search for the optimal connectivity between the blocks for a given task. ",
+        "bbox": [
+            174,
+            396,
+            825,
+            450
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We model a video CNN architecture as a collection of convolutional blocks (i.e., sub-networks) connected to each other. Each block is composed of a residual module of space-time convolutional layers repeated multiple times, while having its own temporal resolution. The objective of our video architecture search is to automatically (1) decide the number of parallel blocks (i.e., how many streams to have) at each level of the network, (2) choose their temporal resolutions, and (3) find the optimal connectivity between such multi-stream neural blocks across various levels. The highly interconnected convolutional blocks allow learning of the video representations combining multiple input modalities at various temporal resolutions. We introduce the concept of connection-learningguided architecture evolution to enable multi-stream architecture search. ",
+        "bbox": [
+            174,
+            458,
+            825,
+            582
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We name our final architecture as an ‘AssembleNet’, since it is formulated by assembling (i.e., merging, splitting, and connecting) multiple building blocks. ",
+        "bbox": [
+            173,
+            589,
+            823,
+            617
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 GRAPH FORMULATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            633,
+            370,
+            647
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In order to make our neural architecture evolution consider multiple different streams with different modalities at different temporal resolutions, we formulate the multi-stream model as a directed acyclic graph. Each node in the graph corresponds to a sub-network composed of multiple convolutional layers (i.e., a block), and the edges specify the connections between such sub-networks. Each architecture is denoted as $G _ { i } = ( \\bar { N } _ { i } , \\bar { E _ { i } } )$ where $N _ { i } = \\{ n _ { 0 i } , n _ { 1 i } , n _ { 2 i } , \\cdot \\cdot \\cdot \\}$ is the set of nodes and $E _ { i }$ is the set of edges defining their connectivity. ",
+        "bbox": [
+            174,
+            660,
+            823,
+            742
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Nodes. A node in our graph representation is a ResNet block composed of a fixed number of interleaved 2D and $( 2 + 1 ) \\mathrm { D }$ residual modules. A ‘2D module’ is composed of a 1x1 conv. layer, one 2D conv. layer with filter size 3x3, and one 1x1 convolutional layer. A $( 2 + 1 ) \\mathrm { D }$ module’ consists of a temporal 1D convolutional layer (with filter size 3), a 2D conv. layer, and a 1x1 conv. layer. In each block, we repeat a regular 2D residual module followed by the $( 2 + 1 ) \\mathrm { D }$ residual module $m$ times. ",
+        "bbox": [
+            174,
+            751,
+            825,
+            820
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Each node has its own block level, which naturally decides the directions of the edges connected to it. Similar to the standard ResNet models, we made the nodes have a total of four block levels ( $^ +$ the stem level). Having multiple nodes of the same level means the architecture has multiple parallel ‘streams’. Figure 1 illustrates an example. Each level has a different $m$ value: 1.5, 2, 3, and 1.5. $m = 1 . 5$ means that there is one 2D module, one $( 2 + 1 ) \\mathrm { D }$ module, and one more 2D module. As a result, the depth of our network is 50 conv. layers. We also have a batch normalization layer followed by a ReLU after every conv. layer. ",
+        "bbox": [
+            174,
+            827,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "There are two special types of nodes with different layer configurations: source nodes and sink nodes. A source node in the graph directly takes the input and applies a small number of convolutional/pooling layers (it is often referred as the ‘stem’ of a CNN model). In video CNNs, the input is a 4D tensor (XYT $^ +$ channel) obtained by concatenating either RGB frames or optical flow images along the time axis. Source nodes are treated as level-0 nodes. The source node is composed of one 2D conv. layer of filter size $7 \\mathbf { x } 7$ , one 1D temporal conv. layer of filter size 5, and one spatial max pooling layer. The 1D conv. is omitted in optical flow stems. A sink node generates the final output of the model, and it is composed of one pooling, one fully connected, and one softmax layer. The sink node is also responsible for combining the outputs of multiple nodes at the highest level, by concatenating them after the pooling. More details are provided in Appendix. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            242
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Each node in the graph also has two attributes controlling the convolutional block: its temporal resolution and the number of channels. We use temporally dilated 1D convolution to dynamically change the resolution of the temporal convolutional layers in different blocks, which are discussed more below. The channel size (i.e., the number of filters) of a node could take arbitrary values, but we constrain the sum of the channels of all nodes in the same block level to be a constant so that the capacity of an AssembleNet model is equivalent to a ResNet model with the same number of layers. ",
+        "bbox": [
+            174,
+            248,
+            825,
+            332
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Temporally Dilated 1D Convolution. One of the objectives is to allow the video architectures to look at multiple possible temporal resolutions. This could be done by preparing actual videos with different temporal resolutions as in Feichtenhofer et al. (2018) or by using temporally ‘dilated convolutions as we introduce here. Having dilated filters allow temporal 1D conv. layers to focus on different temporal resolution without losing temporal granularity. This essentially is a 1D temporal version of standard 2D dilated convolutions used in Chen et al. (2018) or Yu & Koltun (2016): ",
+        "bbox": [
+            174,
+            343,
+            825,
+            426
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Let $k$ be a temporal filter (i.e., a vector) with size $2 d + 1$ . The dilated convolution operator $* _ { r }$ is similar to regular convolution but has different steps for the summation, described as: ",
+        "bbox": [
+            174,
+            433,
+            823,
+            462
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fa86f30b2e6106cf21226a635b6d45c0b8058fc791dc7801ac69a826b3fc6982.jpg",
+        "text": "$$\n( F * _ { r } k ) ( t ) = \\sum _ { t _ { 1 } + r t _ { 2 } = t } F ( t _ { 1 } ) k ( t _ { 2 } + d )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            367,
+            472,
+            629,
+            506
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $t$ , $t _ { 1 }$ , and $t _ { 2 }$ are time indexes. $r$ indicates the temporal resolution (or the amount of dilation), and the standard 1D temporal convolution is a special case where $r = 1$ . In the actual implementation, this is done by inserting $r - 1$ number of zeros between each element of $k$ to generate $k ^ { \\prime }$ , and then convolving such zero-inflated filters with the input: $F * _ { r } k = F * k ^ { \\prime }$ . Importantly, the use of the dilated convolution allows different intermediate sub-network blocks (i.e., not just input stems) to focus on very different temporal resolutions at different levels of the convolutional architecture. ",
+        "bbox": [
+            174,
+            515,
+            825,
+            598
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note that our temporally dilated convolution is different from the one used in Lea et al. (2017), which designed a specific layer to combine representations from different frames with various step sizes. Our layers dilate the temporal filters themselves. Our dilated convolution can be viewed as a direct temporal version of the standard dilated convolutions used in Chen et al. (2018); Yu & Koltun (2016). ",
+        "bbox": [
+            174,
+            604,
+            825,
+            661
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Edges. Each directed edge specifies the connection between two sub-network blocks, and it describes how a representation is transferred from one block to another block. We constrain the direction of each edge so that it is connected from a lower level block to a higher level block to avoid forming a cycle and allow parallel streams. A node may receive inputs from any number of lower-level nodes (including skip connections) and provide its output to any number of higher-level nodes. ",
+        "bbox": [
+            174,
+            672,
+            825,
+            743
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our architectures use a (learnable) weighted summation to aggregate inputs given from multiple connected nodes. That is, an input to a node is computed as $F ^ { i n } = \\Sigma _ { i }$ sigmoid $( w _ { i } ) \\cdot F _ { i } ^ { o u t }$ , where $F _ { i } ^ { o u t }$ are output tensors (i.e., representations) of the nodes connected to the node and $w _ { i }$ are their corresponding weights. Importantly, each $w _ { i }$ is considered as a variable that has to be learned from training data through back propagation. This has two key advantages compared to conventional feature map concatenation: (i) The input tensor size is consistent regardless of the number of connections. (ii) We use learned connection weights to ‘guide’ our architecture evolution algorithm in a preferable way, which we discuss more in Section 3.2. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            861
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "If the inputs from different nodes differ in their spatial size, we add spatial max pooling and striding to match their spatial size. If the inputs have different channel sizes, we add a 1x1 conv. layer to match the bigger channel size. Temporal sizes of the representations is always consistent in our graphs, as there is no temporal striding in our formulation and the layers in the nodes are fully convolutional. ",
+        "bbox": [
+            174,
+            868,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/194c3d7588b709dce9d1701e42c4db805139f652c555b67dd26f782fa6908d2d.jpg",
+        "image_caption": [
+            "Figure 2: An example showing a sequence of architecture evolution. These architectures have actual parent-child relationships. The fitness of the third model was worse than the second model (due to random mutations), but it was high enough to survive in the population pool and eventually evolve into a better model. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            99,
+            826,
+            226
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 EVOLUTION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            316,
+            299,
+            330
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We design an evolutionary algorithm with discrete mutation operators that modify nodes and edges in architectures over iterations. The algorithm maintains a population of $P$ different architectures, $P = \\{ G _ { 1 } , G _ { 2 } , \\cdot \\cdot \\cdot , G _ { | P | } \\}$ , where each architecture $G$ is represented with a set of nodes and their edges as described above. ",
+        "bbox": [
+            173,
+            342,
+            825,
+            398
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The initial population is formed by preparing a fixed number of randomly connected architectures (e.g., $| P | = 2 0 ,$ ). Specifically, we (1) prepare a fixed number of stems and nodes at each level (e.g., two per level), (2) apply a number of node split/merge mutation operators which we discuss more below, and (3) randomly connect nodes with the probability $p = 0 . 5$ while discarding architectures with graph depth $< 4$ . As mentioned above, edges are constrained so that there is no directed edge reversing the level ordering. Essentially, a set of overly-connected architectures are used as a starting point. Temporal resolutions are randomly assigned to the nodes. ",
+        "bbox": [
+            173,
+            405,
+            825,
+            502
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We use the tournament selection algorithm (Goldberg & Deb, 1991) as the main evolution framework: At each evolution round, the algorithm updates the population by selecting a ‘parent’ architecture and mutating (i.e., modifying) it to generate a new ‘child’ architecture. The parent is selected by randomly sampling a subset of the entire population $P ^ { \\prime } \\subset P$ , and then computing the architecture with the highest ‘fitness’: $G _ { p } = \\mathrm { a r g m a x } _ { G _ { i } \\in P ^ { \\prime } } f ( G _ { i } )$ where $f ( G )$ is the fitness function. Our fitness is defined as a video classification accuracy of the model, measured by training the model with a certain number of initial iterations and then evaluating it on the validation set as its proxy task. More specifically, we use top-1 accuracy $^ +$ top-5 accuracy as the fitness function. The child is added into the population, and the model with the least fitness is discarded from the population. ",
+        "bbox": [
+            173,
+            508,
+            825,
+            633
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "A child is evolved from the parent by following two steps. First, it changes the block connectivity (i.e., edges) based on their learned weights: ‘connection-learning-guided evolution’. Next, it applies a random number of mutation operators to further modify the node configuration. The mutation operators include (1) a random modification of the temporal resolution of a convolutional block (i.e., a node) as well as (2) a merge or split of a block. When splitting a node into two nodes, we make their input/output connections identical while making the number of channels in their convolutional layers half that of the node before the split (i.e., $C = C _ { p } / 2$ where $C _ { p }$ is the channel size of the parent). More details are found in Appendix. As a result, we maintain the total number of parameters, since splitting or merging does not change the number of parameters of the convolutional blocks. ",
+        "bbox": [
+            173,
+            638,
+            825,
+            763
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Connection-Learning-Guided Mutation. Instead of randomly adding, removing or modifying block connections to generate the child architecture, we take advantage of the learned connection weights from its parent architecture. Let $E _ { p }$ be the set of edges of the parent architecture. Then the edges of the child architecture $E _ { c }$ are inherited from $E _ { p }$ , by only maintaining high-weight connections while replacing the low-weight connections with new random ones. Specifically, $E _ { c } = E _ { c } ^ { 1 } \\cup E _ { c } ^ { 2 }$ : ",
+        "bbox": [
+            173,
+            772,
+            825,
+            844
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6602eae358959b5e5bf5ec58c8904d97bb6d9def5450234b6a0a5a7f41a58a95.jpg",
+        "text": "$$\nE _ { c } ^ { 1 } = \\left\\{ e \\in E _ { p } \\mid W _ { e } > B \\right\\} , \\quad E _ { c } ^ { 2 } = \\left\\{ e \\in \\left( E _ { * } - E _ { p } \\right) \\mid \\frac { | E _ { p } - E _ { c } ^ { 1 } | } { | E - E _ { p } | } > X _ { e } \\right\\}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            250,
+            852,
+            748,
+            887
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $X \\sim \\mathrm { u n i f } ( 0 , 1 )$ and $E _ { * }$ is the set of all possible edges. $E _ { c } ^ { 1 }$ corresponds to the edges the child architecture inherits from the parent architecture, decided based on the learned weight of the edge $W _ { e }$ ",
+        "bbox": [
+            174,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/c1e825f4d108f3f9a43072bb9b56751de0658480b6cd479476bd11664238a9c4.jpg",
+        "image_caption": [
+            "Figure 3: More AssembleNet examples. Similarly good performing diverse architectures, all with higher-than- $50 \\%$ mean-average precision on Charades. For instance, even our simpler two-stem AssembleNet-50 (left) got $5 1 . 4 \\%$ mAP on Charades. Darker edges mean higher weights. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            99,
+            823,
+            338
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "This is possible because our fitness measure involves initial proxy training of each model, providing the learned connection weight values $W _ { e }$ of the parent. ",
+        "bbox": [
+            174,
+            414,
+            823,
+            441
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "$B$ , which controls whether or not to keep an edge from the parent architecture, could either be a constant threshold or a random variable following a uniform distribution: $B = b$ or $B = X _ { B } \\sim$ unif $( 0 , 1 )$ . $E _ { c } ^ { 2 }$ corresponds to the new randomly added edges which were not in the parent architecture. We enumerate through each possible new edge, and randomly add it with the probably of $| E _ { p } -$ $E _ { c } ^ { 1 } | / | E - E _ { p } |$ . This makes the expected total number of added edges to be $| E _ { p } - E _ { c } ^ { 1 } |$ , maintaining the size of $E _ { c }$ . Figure 2 shows an example of the evolution process and Figure 3 shows final architectures. ",
+        "bbox": [
+            173,
+            449,
+            825,
+            534
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Evolution Implementation Details. Initial architectures are formed by randomly preparing either $\\{ 2 \\mathrm { o r } 4 \\}$ stems, two nodes per level at levels 1 to 3, and one node at level 4. We then apply $1 { \\sim } 5$ random number of node split operators so that each initial architecture has a different number of nodes. Each node is initialized with a random temporal resolution of 1, 2, 4, or 8. As mentioned, each possible connection is then added with the probability of $p = 0 . 5$ . ",
+        "bbox": [
+            174,
+            539,
+            825,
+            608
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "At each evolution round, the best-performing parent architecture is selected from a random subset of 5 from the population. The child architecture is generated by modifying the connections from the parent architecture (Section 3.2). A random number of node split, merge, or temporal resolution change mutation operators $( 0 { \\sim } 4 )$ are then applied. Evaluation of each architecture (i.e., measuring the fitness) is done by training the model for 10K iterations and then measuring its top- $1 + \\mathrm { t o p } { - } 5$ accuracy on the validation subset. The Moments-in-Time dataset, described in the next section, is used as the proxy dataset to measure fitness. The evolution was run for ${ \\sim } 2 0 0$ rounds, although a good performing architecture was found within only 40 rounds (e.g., Figure 3-right). Figure 1 shows the model found at the 165th round. 10K training iterations of each model during evolution took $3 { \\sim } 5$ hours; with our setting, evolving a model for 40 rounds took less than a day with 10 parallel workers. ",
+        "bbox": [
+            173,
+            611,
+            825,
+            750
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            770,
+            326,
+            785
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            794,
+            287,
+            808
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Charades Dataset. We first test on the popular Charades dataset (Sigurdsson et al., 2016) which is unique in the activity recognition domain as it contains long sequences. It is one of the largest public datasets with continuous action videos, containing 9848 videos of 157 classes (7985 training and 1863 testing videos). Each video is ${ \\sim } 3 0 $ seconds. It is a challenging dataset due to the duration and variety of the activities. Activities may temporally overlap in a Charades video, requiring the model to predict multiple class labels per video. We used the standard ‘Charades v1 classify’ setting for the evaluation. To comply with prior work (e.g. Feichtenhofer et al., 2018), we also report results when pre-training on Kinetics (Carreira & Zisserman, 2017), which is another large-scale dataset. ",
+        "bbox": [
+            174,
+            813,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/21a7de76ffce7ca89bb297b352e714fa8ae643809ea7255c723b4e1bea80641a.jpg",
+        "table_caption": [
+            "Table 1: Reported state-of-the-art action classification performances (vs. AssembleNet) on Charades. ‘2-stream $( 2 + 1 ) \\mathrm { D }$ ResNet-50’ is the two-stream model with connection learning for level-4 fusion. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>pre-train</td><td>modality</td><td>mAP</td></tr><tr><td>2-stream (Simonyan &amp; Zisserman, 2014)</td><td>UCF101</td><td>RGB+Flow</td><td>18.6</td></tr><tr><td>Asyn-TF (Sigurdsson et al., 2017)</td><td>UCF101</td><td>RGB+Flow</td><td>22.4</td></tr><tr><td>CoViAR (Wu et al., 2018b)</td><td>ImageNet</td><td>Compressed</td><td>21.9</td></tr><tr><td>MultiScale TRN (Zhou et al., 2018)</td><td>ImageNet</td><td>RGB</td><td>25.2</td></tr><tr><td>I3D (Carreira &amp; Zisserman, 2017)</td><td>Kinetics</td><td>RGB</td><td>32.9</td></tr><tr><td>I3D (from Wang et al., 2018)</td><td>Kinetics</td><td>RGB</td><td>35.5</td></tr><tr><td>I3D-NL (Wang et al., 2018)</td><td>Kinetics</td><td>RGB</td><td>37.5</td></tr><tr><td>STRG (Wang &amp; Gupta, 2018)</td><td>Kinetics</td><td>RGB</td><td>39.7</td></tr><tr><td>LFB-101 (Wu et al., 2018a)</td><td>Kinetics</td><td>RGB</td><td>42.5</td></tr><tr><td>SlowFast-1O1 (Feichtenhofer et al., 2018)</td><td>Kinetics</td><td>RGB+RGB</td><td>45.2</td></tr><tr><td>2-stream (2+1)D ResNet-50 (ours)</td><td>MiT</td><td>RGB+Flow</td><td>48.7</td></tr><tr><td>2-stream (2+1)D ResNet-50 (ours)</td><td>Kinetics</td><td>RGB+Flow</td><td>50.4</td></tr><tr><td>2-stream (2+1)D ResNet-101 (ours)</td><td>Kinetics</td><td>RGB+Flow</td><td>50.6</td></tr><tr><td>AssembleNet-50 (ours)</td><td>MiT</td><td>RGB+Flow</td><td>53.0</td></tr><tr><td>AssembleNet-50 (ours)</td><td>Kinetics</td><td>RGB+Flow</td><td>56.6</td></tr><tr><td>AssembleNet-101 (ours)</td><td>Kinetics</td><td>RGB+Flow</td><td>58.6</td></tr></table>",
+        "bbox": [
+            258,
+            138,
+            740,
+            390
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/569849bc47654ea2b055475d70d45351440c947060e5cb63805b98bd5f543352.jpg",
+        "table_caption": [
+            "Table 2: State-of-the-art action classification accuracies on Moments in Time (Monfort et al., 2018). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>modality</td><td>Top-1</td><td>Top-5</td></tr><tr><td>ResNet50-ImageNet</td><td>RGB</td><td>27.16</td><td>51.68</td></tr><tr><td>TSN (Wang et al., 2016)</td><td>RGB</td><td>24.11</td><td>49.10</td></tr><tr><td>Ioffe &amp; Szegedy (2015)</td><td>Flow</td><td>11.60</td><td>27.40</td></tr><tr><td>TSN-Flow (Wang et al.,2016)</td><td>Flow</td><td>15.71</td><td>34.65</td></tr><tr><td>TSN-2Stream (Wang et al., 2016)</td><td>RGB+F</td><td>25.32</td><td>50.10</td></tr><tr><td>TRN-Multi (Zhou et al.,2018)</td><td>RGB+F</td><td>28.27</td><td>53.87</td></tr><tr><td>Two-stream (2+1)D ResNet-50</td><td>RGB+F</td><td>28.97</td><td>55.55</td></tr><tr><td>I3D (Carreira &amp; Zisserman,2017)</td><td>RGB+F</td><td>29.51</td><td>56.06</td></tr><tr><td>AssembleNet-50</td><td>RGB+F</td><td>31.41</td><td>58.33</td></tr><tr><td>AssembleNet-50 (with Kinetics)</td><td>RGB+F</td><td>33.91</td><td>60.86</td></tr><tr><td>AssembleNet-101 (with Kinetics)</td><td>RGB+F</td><td>34.27</td><td>62.71</td></tr></table>",
+        "bbox": [
+            173,
+            441,
+            537,
+            608
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/2c86efeaf42b69f2963779f0a8591a645031fcb5cfc9c26136087e6b04284d67.jpg",
+        "image_caption": [
+            "Figure 4: Comparison of different search methods. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            565,
+            401,
+            813,
+            569
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We note that Kinetics is shrinking in size $( \\sim 1 5 \\%$ videos removed from the original Kinetics-400) and the previous versions are no longer available from the official site. ",
+        "bbox": [
+            174,
+            637,
+            821,
+            665
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Moments in Time (MiT) Dataset. The Moments in Time (MiT) dataset (Monfort et al., 2018) is a large-scale video classification dataset with more than 800K videos ${ \\sim } 3$ seconds per video). It is a very challenging dataset with the state-of-the-art models obtaining less than $30 \\%$ accuracy. We use this dataset for the architecture evolution, and train/test the evolved models. We chose the MiT dataset because it provides a sufficient amount of training data for video CNN models and allows stable comparison against previous models. We used its standard classification evaluation setting. ",
+        "bbox": [
+            174,
+            679,
+            825,
+            762
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            779,
+            277,
+            792
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Tables 1 and 2 compare the performance of AssembleNet against the state-of-the-art models. We denote AssembleNet more specifically as AssembleNet-50, since its depth is 50 layers and has an equivalent number of parameters to ResNet-50. AssembleNet-101 is its 101 layer version having equivalent number of parameters to ResNet-101. AssembleNet is outperforming prior works on both datasets, setting new state-of-the-art results for them. Its performance on MiT is the first above $34 \\%$ . We also note that the performances on Charades is even more impressive at 58.6 whereas previous known best results are 42.5 and 45.2. For these experiments, the architecture search was done on the MiT dataset, and then the found models are trained and tested on both datasets, which demonstrates that the found architectures are useful across datasets. ",
+        "bbox": [
+            173,
+            799,
+            825,
+            922
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/e52eb4c56e25347322948be9bd6c95cc384c6e509299c6255d12e6e505396dd5.jpg",
+        "table_caption": [
+            "Table 3: Comparison between AssembleNet and architectures without evolution, but with connection weight learning. Four-stream models are reported here for the first time, and are very effective. All these models have a similar number of parameters. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Architecture</td><td>MiT Charades</td></tr><tr><td>Two-stream (late fusion) 28.97</td><td>46.5</td></tr><tr><td>Two-stream (fusion at lv. 4) Two-stream (flow-→RGB inter.)</td><td>30.00 48.7 30.21</td></tr><tr><td>Two-stream (fully, fuse at 4)</td><td>49.5 29.87 50.5</td></tr><tr><td>Four-stream (fully, fuse at 4)</td><td>29.98 50.7</td></tr><tr><td>Random (+ connection learning） 2</td><td>29.91 50.1</td></tr><tr><td>AssembleNet-50</td><td>31.41 53.0</td></tr></table>",
+        "bbox": [
+            173,
+            181,
+            506,
+            309
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/c44f4bed90ac53cda9454f79b6078bb0cd707dc10db794ac5672c0ca9674af0b.jpg",
+        "table_caption": [
+            "Table 4: Ablation comparing different AssembleNet architectures found with full vs. constrained search spaces. The models are trained from scratch. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Architecture MiT</td></tr><tr><td>Baseline (random + conn. learning) 29.91</td></tr><tr><td>No mutation 30.26</td></tr><tr><td>RGB-only 30.30</td></tr><tr><td>Without temporal dilation 30.49</td></tr><tr><td>Two-stem only 30.75</td></tr><tr><td>Full AssembleNet-50 31.41</td></tr></table>",
+        "bbox": [
+            522,
+            181,
+            818,
+            295
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In addition, we compare the proposed connection-learning-guided evolution with random architecture search and the standard evolutionary algorithm with random connection mutations. We made the standard evolutionary algorithm randomly modify 1/3 of the total connections at each round, as that is roughly the number of edges the connection-learning-guided evolution modifies. Figure 4 shows the results, visualizing the average fitness score of the three top-performing models in each pool. We observe that the connection-learning-guided evolution is able to find better architectures, and it is able to do so more quickly. The standard evolution performs similarly to random search and is not as effective. We believe this is due to the large search space the approach is required to handle, which is exponential to the number of possible connections. For instance, if there are $N$ nodes, the search space complexity is $2 ^ { O ( N ^ { 2 } ) }$ just for the connectivity search. Note that the initial ${ \\sim } 3 0 $ rounds are always used for random initialization of the model population, regardless of the search method. ",
+        "bbox": [
+            173,
+            330,
+            825,
+            484
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3 ABLATION STUDIES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            496,
+            352,
+            508
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We conduct an ablation study comparing the evolved AssembleNet to multiple $( 2 + 1 ) \\mathrm { D }$ two-stream (or multi-stream) architectures which are designed to match the abilities of Assemblenet but without evolution. We note that these include very strong architectures that have not been explored before, such as the four-stream model with dense intermediate connectivity. We design competitive networks having various connections between streams, where the connection weights are also learned (see the supplementary material for detailed descriptions and visualizations). Note that all these models have equivalent capacity (i.e., number of parameters). The performance difference is due to network structure. Table 3 shows the results, demonstrating that these architectures with learnable interconnectivity are very powerful themselves and evolution is further beneficial. The Moments in Time models were trained from scratch, and the Charades models were pre-trained on MiT. In particular, we evaluated an architecture with intermediate connectivity from the flow stream to RGB, inspired by Feichtenhofer et al. (2016b; 2018) $^ +$ connection weight learning). It gave $3 0 . 2 \\%$ accuracy on MiT and $4 9 . 5 \\%$ on Charades, which are not as accurate as AssembleNet. Randomly generated models (from 50 rounds of search) are also evaluated, confirming that such architectures do not perform well. ",
+        "bbox": [
+            173,
+            515,
+            826,
+            707
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Further, we conduct another ablation to confirm the effectiveness of our search space. Table 4 compares the models found with our full search space vs. more constrained search spaces, such as only using two stems and not using temporal dilation (i.e., fixed temporal resolution). ",
+        "bbox": [
+            174,
+            714,
+            821,
+            756
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.4 GENERAL FINDINGS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            766,
+            354,
+            780
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "As the result of connection-learning-guided architecture evolution, non-obvious and non-intuitive connections are found (Figure 3). As expected, more than one possible “connectivity” solution can yield similarly good results. Simultaneously, models with random connectivity perform poorly compared to the found AssembleNet. Our observations also include: (1) The models prefer to have only one block at the highest level, although we allow the search to consider having more than one block at that level. (2) The final block prefers simple connections gathering all outputs of the blocks in the 2nd to last level. (3) Many models use multiple blocks with different temporal resolutions at the same level, justifying the necessity of the multi-stream architectures. (4) Often, there are 1 or 2 blocks heavily connected to many other blocks. (5) Architectures prefer using more than 2 streams, usually using 4 at many levels. ",
+        "bbox": [
+            173,
+            786,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            318,
+            118
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We present AssembleNet, a new approach for neural architecture search using connection-learningguided architecture evolution. AssembleNet finds multi-stream architectures with better connectivity and temporal resolutions for video representation learning. Our experiments confirm that the learned models significantly outperform previous models on two challenging benchmarks. ",
+        "bbox": [
+            174,
+            133,
+            826,
+            189
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            210,
+            287,
+            227
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Karim Ahmed and Lorenzo Torresani. Connectivity learning in multi-branch networks. In Workshop on Meta-Learning (MetaLearn), NeurIPS, 2017. ",
+        "bbox": [
+            173,
+            233,
+            823,
+            262
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Gabriel Bender, Pieter-Jan Kindermans, Barret Zoph, Vijay Vasudevan, and Quoc Le. Understanding and simplifying one-shot architecture search. In International Conference on Machine Learning (ICML), 2018. ",
+        "bbox": [
+            174,
+            272,
+            826,
+            314
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Joao Carreira and Andrew Zisserman. Quo vadis, action recognition? a new model and the kinetics dataset. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2017. ",
+        "bbox": [
+            173,
+            324,
+            826,
+            367
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Liang-Chieh Chen, George Papandreou, Iasonas Kokkinos, Kevin Murphy, and Alan L. Yuille. Deeplab: Semantic image segmentation with deep convolutional nets, atrous convolution, and fully connected crfs. IEEE TPAMI, 40(4), 2018. ",
+        "bbox": [
+            174,
+            376,
+            823,
+            419
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ali Diba, Mohsen Fayyaz, Vivek Sharma, Manohar Paluri, Jurgen Gall, , Rainer Stiefelhagen, and Luc Van Gool. Holistic large scale video understanding. In CoRR:1904.11451, 2019. ",
+        "bbox": [
+            169,
+            428,
+            823,
+            458
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Christoph Feichtenhofer, Axel Pinz, and Richard Wildes. Spatiotemporal residual networks for video action recognition. In Advances in Neural Information Processing Systems (NeurIPS), pp. 3468–3476, 2016a. ",
+        "bbox": [
+            173,
+            467,
+            825,
+            510
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Christoph Feichtenhofer, Axel Pinz, and Andrew Zisserman. Convolutional two-stream network fusion for video action recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 1933–1941, 2016b. ",
+        "bbox": [
+            173,
+            518,
+            825,
+            561
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Christoph Feichtenhofer, Axel Pinz, and Richard P Wildes. Spatiotemporal multiplier networks for video action recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 4768–4777, 2017. ",
+        "bbox": [
+            173,
+            570,
+            825,
+            614
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Christoph Feichtenhofer, Haoqi Fan, Jitendra Malik, and Kaiming He. Slowfast networks for video recognition. arXiv preprint arXiv:1812.03982, 2018. ",
+        "bbox": [
+            174,
+            623,
+            823,
+            652
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "David E. Goldberg and Kalyanmoy Deb. A comparative analysis of selection schemes used in genetic algorithms. In Foundations of Genetic Algorithms, pp. 69–93. Morgan Kaufmann, 1991. ",
+        "bbox": [
+            173,
+            661,
+            825,
+            691
+        ],
+        "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 (CVPR), 2016. ",
+        "bbox": [
+            173,
+            700,
+            825,
+            742
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In International Conference on Machine Learning (ICML), 2015. ",
+        "bbox": [
+            171,
+            752,
+            825,
+            781
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Colin Lea, Michael D. Flynn, Rene Vidal, Austin Reiter, and Gregory D. Hager. Temporal convolutional networks for action segmentation and detection. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2017. ",
+        "bbox": [
+            174,
+            790,
+            825,
+            833
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Chenxi Liu, Barret Zoph, Maxim Neumann, Jonathon Shlens, Wei Hua, Li-Jia Li, Li Fei-Fei, Alan Yuille, Jonathan Huang, and Kevin Murphy. Progressive neural architecture search. In Proceedings of European Conference on Computer Vision (ECCV), 2018. ",
+        "bbox": [
+            174,
+            843,
+            823,
+            886
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Hanxiao Liu, Karen Simonyan, and Yiming Yang. DARTS: Differentiable architecture seach. In International Conference on Learning Representations (ICLR), 2019. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mathew Monfort, Alex Andonian, Bolei Zhou, Kandan Ramakrishnan, Sarah Adel Bargal, Tom Yan, Lisa Brown, Quanfu Fan, Dan Gutfruend, Carl Vondrick, et al. Moments in time dataset: one million videos for event understanding. arXiv preprint arXiv:1801.03150, 2018. ",
+        "bbox": [
+            176,
+            103,
+            821,
+            146
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "AJ Piergiovanni and Michael S Ryoo. Representation flow for action recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2019. ",
+        "bbox": [
+            171,
+            154,
+            825,
+            184
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Esteban Real, Alok Aggarwal, Yanping Huang, and Quoc V. Le. Regularized evolution for image classifier architecture search. In Proceedings of AAAI Conference on Artificial Intelligence (AAAI), 2019. ",
+        "bbox": [
+            176,
+            191,
+            823,
+            234
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Gunnar A. Sigurdsson, Gul Varol, Xiaolong Wang, Ali Farhadi, Ivan Laptev, and Abhinav Gupta. ¨ Hollywood in homes: Crowdsourcing data collection for activity understanding. In Proceedings of European Conference on Computer Vision (ECCV), 2016. ",
+        "bbox": [
+            174,
+            243,
+            825,
+            286
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Gunnar A Sigurdsson, Santosh Divvala, Ali Farhadi, and Abhinav Gupta. Asynchronous temporal fields for action recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2017. ",
+        "bbox": [
+            173,
+            295,
+            826,
+            338
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan and Andrew Zisserman. Two-stream convolutional networks for action recognition in videos. In Advances in Neural Information Processing Systems (NeurIPS), pp. 568–576, 2014. ",
+        "bbox": [
+            173,
+            347,
+            823,
+            376
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 2818–2826, 2016. ",
+        "bbox": [
+            174,
+            383,
+            823,
+            428
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Du Tran, Lubomir D Bourdev, Rob Fergus, Lorenzo Torresani, and Manohar Paluri. C3d: generic features for video analysis. CoRR, abs/1412.0767, 2(7):8, 2014. ",
+        "bbox": [
+            173,
+            435,
+            823,
+            465
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Du Tran, Heng Wang, Lorenzo Torresani, Jamie Ray, Yann LeCun, and Manohar Paluri. A closer look at spatiotemporal convolutions for action recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 6450–6459, 2018. ",
+        "bbox": [
+            173,
+            473,
+            821,
+            517
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Limin Wang, Yuanjun Xiong, Zhe Wang, Yu Qiao, Dahua Lin, Xiaoou Tang, and Luc Van Gool. Temporal segment networks: Towards good practices for deep action recognition. In Proceedings of European Conference on Computer Vision (ECCV), pp. 20–36. Springer, 2016. ",
+        "bbox": [
+            174,
+            525,
+            823,
+            568
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xiaolong Wang and Abhinav Gupta. Videos as space-time region graphs. In Proceedings of European Conference on Computer Vision (ECCV), pp. 399–417, 2018. ",
+        "bbox": [
+            171,
+            577,
+            823,
+            606
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xiaolong Wang, Ross Girshick, Abhinav Gupta, and Kaiming He. Non-local neural networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 7794–7803, 2018. ",
+        "bbox": [
+            174,
+            613,
+            825,
+            656
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chao-Yuan Wu, Christoph Feichtenhofer, Haoqi Fan, Kaiming He, Philipp Krahenb ¨ uhl, and Ross Gir- ¨ shick. Long-term feature banks for detailed video understanding. arXiv preprint arXiv:1812.05038, 2018a. ",
+        "bbox": [
+            173,
+            665,
+            825,
+            708
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chao-Yuan Wu, Manzil Zaheer, Hexiang Hu, R Manmatha, Alexander J Smola, and Philipp Krahenb ¨ uhl. Compressed video action recognition. In ¨ Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 6026–6035, 2018b. ",
+        "bbox": [
+            174,
+            717,
+            823,
+            760
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Saining Xie, Chen Sun, Jonathan Huang, Zhuowen Tu, and Kevin Murphy. Rethinking spatiotemporal feature learning: Speed-accuracy trade-offs in video classification. In Proceedings of European Conference on Computer Vision (ECCV), pp. 305–321, 2018. ",
+        "bbox": [
+            176,
+            767,
+            823,
+            811
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Saining Xie, Alexander Kirillov, Ross Girshick, and Kaiming He. Exploring randomly wired neural networks for image recognition. In CoRR:1904.01569, 2019. ",
+        "bbox": [
+            173,
+            819,
+            823,
+            848
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Fisher Yu and Vladlen Koltun. Multi-scale context aggregation by dilated convolutions. In International Conference on Learning Representations (ICLR), 2016. ",
+        "bbox": [
+            174,
+            857,
+            821,
+            886
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Christopher Zach, Thomas Pock, and Horst Bischof. A duality based approach for realtime tv-l 1 optical flow. In Joint Pattern Recognition Symposium, pp. 214–223. Springer, 2007. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Bolei Zhou, Alex Andonian, Aude Oliva, and Antonio Torralba. Temporal relational reasoning in videos. In Proceedings of European Conference on Computer Vision (ECCV), pp. 803–818, 2018. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Barret Zoph and Quoc Le. Neural architecture search with reinforcement learning. In International Conference on Learning Representations (ICLR), 2017. ",
+        "bbox": [
+            174,
+            140,
+            823,
+            170
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Barret Zoph, Vijay Vasudevan, Jonathon Shlens, and Quoc V. Le. Learning transferable architectures for scalable image recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2018. ",
+        "bbox": [
+            178,
+            178,
+            823,
+            220
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            297,
+            117
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.1 SUPER-GRAPH VISUALIZATION OF THE CONNECTIVITY SEARCH SPACE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            135,
+            705,
+            148
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Figure 5 visualizes all possible connections and channel/temporal resolution options our architecture evolution is able to consider. The objective of our evolutionary algorithm could be interpreted as finding the optimal sub-graph (of this super-graph) that maximizes the performance while maintaining the number of total parameters. Trying to directly fit such entire super-graph into the memory was infeasible in our experiments. ",
+        "bbox": [
+            173,
+            160,
+            825,
+            229
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/ada175942c052a2ee09b2247ff89198586ec5515117df6d58adb8174098cc07c.jpg",
+        "image_caption": [
+            "Figure 5: Visualization of the super-graph corresponding to our video architecture search space. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            242,
+            823,
+            415
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.2 CHANNEL SIZES OF THE LAYERS AND NODE SPLIT/MERGE MUTATIONS ",
+        "bbox": [
+            178,
+            468,
+            705,
+            482
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "As we described in the paper, each node (i.e., a convolutional block) has a parameter $C$ controlling the number of filters of the convolutional layers in the block. When splitting or merging blocks, the number of filters are split or combined respectively. Figure 6 provides a visualization of a block with number of filter specified to the right and a split operation. While many designs are possible, we design the blocks and splitting as follows. The size of 1x1 convolutional layers and 1D temporal convolutional layers are strictly governed by $C$ , having the channel size of $C$ (some $4 C$ ). On the other hand, the number of 2D convolutional layer is fixed per level as a constant $D _ { v }$ where $v$ is the level of the block. $D _ { 1 } = 6 4$ , $D _ { 2 } = 1 2 8$ , $D _ { 3 } = 2 5 6$ , and $D _ { 4 } = 5 1 2$ . The layers in the stems have 64 channels if there are only two stems and 32 if there are four stems. ",
+        "bbox": [
+            173,
+            492,
+            825,
+            617
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "When a node is split into two nodes, we update the resulting two nodes’ channel sizes to be half of their original node. This enables us to maintain the total number of model parameters before and after the node split to be identical. The first 1x1 convolutional layer will have half the parameters after the split, since its output channel size is now 1/2. The 2D convolutional layer will also have exactly half the parameters, since its input channel size is $1 / 2$ while the output channel size is staying fixed. The next 1x1 convolutional layer will have the fixed input channel size while the output channel size becomes 1/2: thus the total number of parameters would be $1 / 2$ of the original parameters. ",
+        "bbox": [
+            173,
+            625,
+            825,
+            720
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Merging of the nodes is done in an inverse of the way we split. When merging two nodes into one, the merged node inherits all input/output connections from the two nodes: we take a union of all the connections. The channel size of the merged node is the sum of the channel sizes of the two nodes being merged. The temporal dilation rate of the merged node is randomly chosen between the two nodes before the merge. ",
+        "bbox": [
+            174,
+            727,
+            825,
+            797
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.3 HAND-DESIGNED MODELS USED IN THE ABLATION STUDY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            815,
+            620,
+            829
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Figure 7 illustrates the actual architectures of the hand-designed $( 2 + 1 ) \\mathrm { D }$ CNN models used in our ablation study. We also show the final learned weights of the connections, illustrating which connections the model ended up using or not using. We note that these architectures are also very enlightening as the connectivity within them are learned in the process. We observe that stronger connections tend to be formed later for 2-stream architectures. For 4-stream architectures, stronger connections do form early, and, not surprisingly, a connection to at least one node of a different modality is established, i.e. a node stemming from RGB will connect to at least one flow node at the next level and vice versa. ",
+        "bbox": [
+            173,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/18130f671084e14cf9eacf7ef1ff26dd093fb31702ea9bb8a07aff6a4b8ea181.jpg",
+        "image_caption": [
+            "Figure 6: An illustration of the node split mutation operator, used for both evolution and initial architecture population generation. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            271,
+            103,
+            725,
+            381
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/f887a20794a882d74bdda474110c89e5d746f2f44ddc2b1095cc3fc5ef2ebbea.jpg",
+        "image_caption": [
+            "Figure 7: Illustration of hand-designed baseline $( 2 + 1 ) \\mathrm { D }$ CNN models used in our ablation study. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            436,
+            826,
+            717
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            779,
+            823,
+            806
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Below is a more detailed description of the networks used in the paper: “Two-stream (late fusion)” means that the model has two separate streams at every level including the level 4, and the outputs of such two level 4 nodes are combined for the final classification. “Fusion at lv. 4” is the model that only has one level 4 node to combine the outputs of the two level 3 nodes using a weighted summation. “Two-stream (fully)” means that the model has two nodes at each level 1-3 and one node at level 4, and each node is always connected to every node in the immediate next level. “Flow RGB” means that only the RGB stream nodes combine outputs from both RGB and flow stream nodes of the immediate lower level. ",
+        "bbox": [
+            174,
+            813,
+            826,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/95d10c48cffac1552be7f06215e378597ade17e3d8b9a6cb31f16fccf65d4861.jpg",
+        "table_caption": [
+            "Table 5: The table form of the AssembleNet model with detailed parameters. This model corresponds to Figure 1. The parameters correspond to {node level, input node list, $C , r .$ , and spatial stride} "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Index</td><td rowspan=1 colspan=1>Block parameters</td></tr><tr><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0,[RGB], 32, 4, 4</td></tr><tr><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0,[RGB], 32,4,4</td></tr><tr><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>0,[Flow], 32,1, 4</td></tr><tr><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>0,[Flow], 32, 1, 4</td></tr><tr><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>1, [1], 32, 1, 1</td></tr><tr><td rowspan=1 colspan=1>5</td><td rowspan=1 colspan=1>1, [0], 32, 4, 1</td></tr><tr><td rowspan=1 colspan=1>6</td><td rowspan=1 colspan=1>1,[0,1,2,3], 32, 1,1</td></tr><tr><td rowspan=1 colspan=1>7</td><td rowspan=1 colspan=1>1,[2,3], 32,2, 1</td></tr><tr><td rowspan=1 colspan=1>8</td><td rowspan=1 colspan=1>2, [0, 4, 5, 6, 7], 64, 2, 2</td></tr><tr><td rowspan=1 colspan=1>9</td><td rowspan=1 colspan=1>2,[0,2,4,7],64,1,2</td></tr><tr><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>2, [0, 5, 7], 64, 4, 2</td></tr><tr><td rowspan=1 colspan=1>11</td><td rowspan=1 colspan=1>2, [0, 5], 64,1,2</td></tr><tr><td rowspan=1 colspan=1>12</td><td rowspan=1 colspan=1>3, [4, 8, 10, 11], 256, 1, 2</td></tr><tr><td rowspan=1 colspan=1>13</td><td rowspan=1 colspan=1>3, [8, 9], 256, 4, 2</td></tr><tr><td rowspan=1 colspan=1>14</td><td rowspan=1 colspan=1>4,[12, 13], 512, 2, 2</td></tr></table>",
+        "bbox": [
+            379,
+            141,
+            617,
+            371
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.4 ASSEMBLENET MODEL/LAYER DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            392,
+            493,
+            406
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We also provide the final AssembleNet model in table form in Table 5. In particular, the 2nd element of each block description shows the list of where the input to that block is coming from (i.e., the connections). As already mentioned, 2D and $( 2 + 1 ) \\mathrm { D }$ residual modules are repeated in each block. The number of repetitions $m$ are 1.5, 2, 3, and 1.5 at each level. $m = 1 . 5$ means that we have one 2D residual module, one $( 2 + 1 ) \\mathrm { D }$ module, and one more 2D module. This makes the number of convolutional layers of each block at levels 1-4 to be 9, 12, 18, and 9. In addition, a stem has at most 2 convolutional layers. The total depth of our network is 50, similar to a conventional $( 2 + 1 ) \\mathrm { D }$ ResNet-50. For AssembleNet-101, we use $m = 1 . 5$ , 2, 11.5, and 1.5 at each level. ",
+        "bbox": [
+            174,
+            417,
+            825,
+            529
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "If a block has a spatial stride of 2, the striding happens at the first 2D convolutional layer of the block. In the stem which has the spatial stride of 4, the striding of size 2 happens twice, once at the 2D convolutional layer and at the max pooling layer. As mentioned, the model has a batch normalization layer followed by ReLU after every convolutional layer regardless of its type (i.e., 2D, 1D, and 1x1). 2D conv. filter sizes are $3 { \\tt X } 3$ , and 1D conv. filter sizes are 3. ",
+        "bbox": [
+            174,
+            535,
+            825,
+            603
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.5 SINK NODE DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            621,
+            359,
+            635
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "When each evolved or baseline $( 2 + 1 ) \\mathrm { D }$ model is applied to a video, it generates a 5D (BTYXC) tensor after the final convolutional layer, where B is the size of the batch and C is the number of channels. The sink node is responsible for mapping this into the output vector, whose dimensionality is identical to the number of video classes in the dataset. The sink node first applies a spatial average pooling to generate a 3D (BTC) tensor. If there are multiple level 4 nodes (which rarely is the case), the sink node combines them into a single tensor by averaging/concatenating them. Averaging or concatenating does not make much difference empirically. Next, temporal average/max pooling is applied to make the representation a 2D (BC) tensor (average pooling was used for the MiT dataset and max pooling was used for Charades), and the final fully connected layer and the soft max layer is applied to generate the final output. ",
+        "bbox": [
+            174,
+            646,
+            825,
+            785
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.6 TRAINING DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            801,
+            352,
+            815
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "For the Moments in Time (MiT) dataset training, 8 videos are provided per TPU core (with 16GB memory): the total batch size (for each gradient update) is 512 with 32 frames per video. The batch size used for Charades is 128 with 128 frames per video. The base framerate we used is 12.5 fps for MiT and 6 fps for Charades. The spatial input resolution is $2 2 4 \\mathbf { x } 2 2 4$ during training. We used the standard Momentum Optimizer in TensorFlow. We used a learning rate of 3.2 (for MiT) and 25.6 (for Charades), 12k warmup iterations, and cosine decay. No dropout is used, weight decay is set to 1e-4 and label smoothing set to 0.2. ",
+        "bbox": [
+            174,
+            827,
+            825,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Training a model for $1 0 \\mathrm { k }$ iterations (during evolution) took $3 { \\sim } 5$ hours and fully training the model (for 50k iterations) took ${ \\sim } 2 4$ hours per dataset. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We used the TV-L1 optical flow extraction algorithm (Zach et al., 2007) implemented with tensor operations by Piergiovanni & Ryoo (2019) to obtain flow input. ",
+        "bbox": [
+            173,
+            138,
+            823,
+            166
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "A.7 EVALUATION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            184,
+            372,
+            198
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "When evaluating a model on the MiT dataset, we provide 36 frames per video. The duration of each MiT video is 3 seconds, making 36 frames roughly correspond to the entire video. For the Charades dataset where each video duration is roughly ${ \\sim } 3 0 $ seconds, the final class labels are obtained by applying the model to five random 128 frame crops (i.e., segments) of each video. The output multi-class labels are max-pooled to get the final label, and is compared to the ground truth to measure the average precision scores. The spatial resolution used for the testing is $2 5 6 \\times 2 5 6$ . ",
+        "bbox": [
+            174,
+            209,
+            825,
+            292
+        ],
+        "page_idx": 14
+    }
+]

parse/train/SJxeI6EYwS/SJxeI6EYwS.md

@@ -0,0 +1,304 @@
+# SIMPLE AND EFFECTIVE STOCHASTIC NEURAL NETWORKS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Stochastic neural networks (SNNs) are currently topical, with several paradigms being actively investigated including dropout, Bayesian neural networks, variational information bottleneck (VIB) and noise regularized learning. These neural network variants impact several major considerations, including generalization, network compression, and robustness against adversarial attack and label noise. However, many existing networks are complicated and expensive to train, and/or only address one or two of these practical considerations. In this paper we propose a simple and effective stochastic neural network (SE-SNN) architecture for discriminative learning by directly modeling activation uncertainty and encouraging high activation variability. Compared to existing SNNs, our SE-SNN is simpler to implement and faster to train, and produces state of the art results on network compression by pruning, adversarial defense and learning with label noise.
+
+# 1 INTRODUCTION
+
+Stochastic neural networks (SNNs) have a long history. Recently various stochastic neural network instantiations have been topical in their applications to reducing overfitting (Gal & Ghahramani, 2016; Neelakantan et al., 2015) and training data requirements (Garnelo et al., 2018), providing confidence estimates on predictions (Gal & Ghahramani, 2016), enabling network compression (Dai et al., 2018), improving robustness to adversarial attack (Alemi et al., 2017), improving optimization (Neelakantan et al., 2015), generative modeling (Kingma & Welling, 2014), and inputting or producing probability distributions (de Bie et al., 2019; Frogner et al., 2019).
+
+One of the most theoretically appealing stochastic neural network formulations is Bayesian neural networks, which place a prior distribution on the weights of the network (Graves, 2011; Blundell et al., 2015; Ritter et al., 2018). However this usually necessitates more complex learning and inference procedures that rely on variational approximations or sampling. Another group of works instead focus on modeling the uncertainty in neural network activations. Notably the variational information bottleneck (VIB) approach (Alemi et al., 2017) is motivated by information theoretic considerations (Tishby et al., 1999) to learn a hidden representation that carries maximum information about the output and minimum information about the input. Evaluating the required mutual information terms requires modeling probability distributions over activations rather than weights. Deep VIB (Alemi et al., 2017) leads to improved generalization, adversarial robustness and model compression algorithms (Dai et al., 2018). Furthermore, modeling stochastic activations through noise is often practically useful for improving exploration and local minima escape during optimization, generalization and adversarial robustness (You et al., 2018; Noh et al., 2017; Bishop, 1995; Gulcehre et al., 2016), and in some cases can be linked back to Bayesian models of weights (Noh et al., 2017; Gal & Ghahramani, 2016) when the noise added at each activation can be considered as a result of different samples from the weight posterior.
+
+In this paper we propose a simple and effective stochastic neural network (SE-SNN) that models activation uncertainty through predicting a Gaussian mean and variance at each layer, which is then sampled during the forward pass. This is similar to the strategy used to model activation distributions in VAE (Kingma & Welling, 2014) and VIB (Alemi et al., 2017). Differently, we then place a non-informative prior on activation distribution and derive an activation regularizer that directly encourages high activation variability via preferring high-entropy activations. In conjunction with a discriminative learning loss, this means that the network is optimized for activation patterns that have high uncertainty while simultaneously being predictive of the target variable. The interplay between these two objectives leads to several appealing capabilities in pruning, adversarial defense and learning with label noise. Pruning: Optimizing for high per-activation variability/uncertainty and predictive accuracy simultaneously lead to the network packing more entropy into the least significant neurons – so that the most crucial neurons are free to operate unperturbed. This leads to a simple pruning criterion based on each neuron’s entropy value. Adversarial defense: By optimizing for both peractivation uncertainty and the network’s predictive accuracy, a representation-level data augmentation policy is trained that perturbs the internal features during training for increased robustness (Alemi et al., 2017; You et al., 2018). Label noise: With SE-SNN, per-activation uncertainty can be easily aggregated to produce per-instance uncertainty. By optimizing for per-instance uncertainty and predictive accuracy, the network allocates the uncertainty to spread the representation and prediction of the hard-to-classify instances so as to downweight their influence on parameter learning. The result is a model robust to label noise as well as outlying training samples.
+
+![](images/3d6cee1a31d4fb965a58f7b1cd414df15ae004bec72581ec40f5d3409024eca1.jpg)  
+Figure 1: An illustration of the stochastic learning module in a SE-SNN. The output of layer $l$ is sampled from the learned distribution defined by $f ^ { \mu } ( h ^ { l - 1 } )$ and $f ^ { \sigma } ( h ^ { l - 1 } )$ .
+
+To summarize, our contributions are: (1) A new simple yet effective stochastic neural network formulation. (2) We show that our SE-SNN has connections to VIB (Alemi et al., 2017), Dropout (Srivastava et al., 2014) and non-informative activation priors while being simpler to implement and faster to train, as well as impactful on a variety of practical problems. (3) Comprehensive evaluations show excellent performance on pruning-based model compression, adversarial defense, and label noise robust learning.
+
+# 2 METHODOLOGY
+
+Stochastic Layers We consider a neural network discriminatively trained for a predictive task such as object recognition. Instead computing fixed point estimates of feature vectors, we propose to use stochastic neurons. More specifically, for an input $h$ , a layer will output a series of univariate distributions. By sampling from those distributions independently, we get a random output $z$ . Finally we apply the non-linear activation function $\psi ( \cdot )$ to $z$ and get the input for the next layer. In this study, we choose to use Gaussian distribution with parameterized mean and variance, which has been popularized by VAE (Kingma & Welling, 2014) and VIB (Alemi et al., 2017) due to the ease of reparameterization. Formally, for the $l$ -th layer, this forward-pass process can be written as (omitting neuron index for notation simplicity),
+
+$$
+\begin{array} { r l r } & { } & { \mu ^ { ( l ) } = f ^ { \mu } \big ( h ^ { ( l - 1 ) } \big ) , } \\ & { } & { \sigma ^ { ( l ) } = f ^ { \sigma } \big ( h ^ { ( l - 1 ) } \big ) , } \\ & { } & { z ^ { ( l ) } \sim \mathcal { N } ( \mu ^ { ( l ) } , \sigma ^ { ( l ) } ) , } \\ & { } & { h ^ { ( l ) } = \psi ( z ^ { ( l ) } ) . } \end{array}
+$$
+
+This process is illustrated in Figure 1, where each standard deviation predictor $f ^ { \sigma }$ comes with a softplus activation $f ( x ) = \log ( \bar { 1 } + \exp ( x ) )$ to ensure non-negativity.
+
+Supervised Learning Loss We can choose to replace some or all intermediate layers of a vanilla neural network with such stochastic layers. For the final layer (i.e., the classifier) we opt for a standard linear layer, and the classification loss is the same as that of a vanilla neural network, e.g., cross-entropy. Since a Gaussian distribution is fully reparameterizable, the network can be trained end-to-end as long as the sampling process $z \sim \mathcal { N } ( \mu , \overline { { \sigma } } )$ is realized by $z = \mu + \epsilon \cdot \sigma$ where $\epsilon \sim \mathcal { N } ( 0 , 1 )$ .
+
+Max-entropy Regularization We place a non-informative prior on the produced Gaussian (denoted as $\mathcal { N } ( \mu _ { 1 } , \sigma _ { 1 } ) )$ . The non-informative prior is a Gaussian with arbitrary mean $( \mu _ { 1 } )$ and infinite variance $( \sigma _ { 1 } ^ { 2 } )$ . This reflects the prior that none of neurons is meaningful for predictive purposes. The non-informative prior leads to a regularization term that minimizes the KL divergence of the produced Gaussian ( $\mathcal { N } ( \mu _ { 2 } , \sigma _ { 2 } ) )$ and the infinite-variance Gaussian
+
+$$
+\begin{array} { r l r } & { \underset { \mu _ { 1 } , \sigma _ { 1 } } { \mathrm { m i n } } \ ( \underset { \sigma _ { 2 } \to \infty } { \mathrm { l i m } } \mathrm { K L } ( \mathcal { N } ( \mu _ { 1 } , \sigma _ { 1 } ) | | \mathcal { N } ( \mu _ { 2 } , \sigma _ { 2 } ) ) ) , \ } & { \qquad } & { \forall \mu _ { 2 } \in \mathbb { R } } \\ & { \Rightarrow \ \underset { \mu _ { 1 } , \sigma _ { 1 } } { \mathrm { m i n } } \ ( \underset { \sigma _ { 2 } \to \infty } { \mathrm { l i m } } ( \log \frac { \sigma _ { 2 } } { \sigma _ { 1 } } + \frac { \sigma _ { 1 } ^ { 2 } + ( \mu _ { 1 } - \mu _ { 2 } ) ^ { 2 } } { 2 \sigma _ { 2 } ^ { 2 } } - \frac { 1 } { 2 } ) ) , \ } & { \qquad } & { \forall \mu _ { 2 } \in \mathbb { R } } \\ & { \Rightarrow \ \underset { \sigma _ { 1 } } { \mathrm { m i n } } \ ( \underset { \sigma _ { 2 } \to \infty } { \mathrm { l i m } } ( \log \frac { \sigma _ { 2 } } { \sigma _ { 1 } } ) ) } & { \Rightarrow \ \underset { \sigma _ { 1 } } { \mathrm { m i n } } \ ( - \log \sigma _ { 1 } ) } \end{array}
+$$
+
+Eq. 2 suggests that we simply need to maximize the predicted standard deviation, or equivalently the entropy of the predicted Gaussian. Thus we call it a max-entropy regularizer $\Omega$ . It can be easily used in any existing neural network architecture:
+
+$$
+\operatorname* { m i n } _ { \theta } - \log ( \sigma ( h | \theta ) )
+$$
+
+where $\sigma ( h | \theta )$ denotes the predicted standard deviation of hidden unit $h$ given the neuron uncertainty prediction parameter $\theta$ . For numerical safety, we introduce a margin $b$ in the loss,
+
+$$
+\operatorname* { m i n } _ { \theta } { ( b - \log ( \sigma ( h | \theta ) ) ^ { + } }
+$$
+
+This means that the regularization does not punish the model as long as the entropy is larger than a threshold $b$ . Note that, this loss design is not absolutely necessary as the increment for $\sigma$ shrinks (since the gradient is $- { \frac { 1 } { \sigma } } .$ ) during training, and thus never reaches infinity with a finite number of updates. However, one can think of it as an early-stopping mechanism for this regularization term.
+
+So far we have introduced the stochasticity to the smallest unit of a network, i.e., a single neuron. To compute the value of the regularizer over a mini-batch consisting of $N$ training samples, we need to aggregate the entropy of multiple neurons and set the margin $b$ on the aggregation. How to aggregate exactly is task-dependent, and we next provide some suggestions for three tasks including network pruning, adversarial defense, and label noise defense.
+
+Pruning For network pruning, we aggregate entropy over samples for each neuron, and then penalize if that neuron’s aggregated entropy is low. To this end, the regularizer is formulated as:
+
+$$
+\Omega ( \theta ) = \frac { 1 } { K } \sum _ { j = 1 } ^ { K } ( b - \frac { 1 } { N } \sum _ { i = 1 } ^ { N } \log ( \sigma _ { i , j } ) ) ^ { + } ,
+$$
+
+where $i = 1 \dots N$ indexes the training samples, and $j = 1 \ldots K$ neurons in a layer (i.e., feature channels). This regularizer aims to make neurons very stochastic, to the point of compromising their reliability for computing a supervised learning task. Thus only those neurons that are most useful for the task get their entropy lowered and thus pay the regularization cost. Less useful neurons get their entropy maximized, allowing them to be detected and pruned after training.
+
+Label Noise Different from pruning, we aim to identify uncertain samples. Therefore, we aggregate entropy over neurons for each sample, and prefer high sample-wise entropy, leading to
+
+$$
+\Omega ( \theta ) = \frac { 1 } { N } \sum _ { i = 1 } ^ { N } ( b - \frac { 1 } { K } \sum _ { j = 1 } ^ { K } \log ( \sigma _ { i , j } ) ) ^ { + } .
+$$
+
+With this regularizer, inlier samples pay the entropy cost in order to produce a clean feature for classification to satisfy the supervised learning loss. Outlier samples, caused by either label noise or being out-of-distribution, are anyway hard to classify; the regularizer naturally inflates their entropy since doing so does not impact the supervised learning loss. This high-variance representation in turn reduces their (negative) impact on network fitting.
+
+Adversarial Defense To defend against adversarial samples, we aim to inflate entropy over both the neuron- and sample-axes to produce a highly stochastic model:
+
+$$
+\Omega ( \theta ) = \frac { 1 } { N } \frac { 1 } { K } \sum _ { i = 1 } ^ { N } \sum _ { j = 1 } ^ { K } ( b - \log ( \sigma _ { i , j } ) ) ^ { + }
+$$
+
+This looks similar to VIB’s adversarial defense (Alemi et al., 2017), but with the vital difference that our entropy regularizer is not restricted to the $\mathcal { N } ( 0 , 1 )$ prior used in VIB. It can be seen as learning a layer-wise data augmentation policy, which turns out to be very useful for adversarial defense in practice (see Sec. 4.2).
+
+# 3 RELATED WORK
+
+Connection to VIB and Sparse VD Though we derive the max-entropy regularizer from the perspective of a non-informative activation prior, our work is closely related to VIB (Alemi et al., 2017) and sparse variational dropout (VD) (Molchanov et al., 2017a), despite their different perspectives. Specifically, if we replace our infinite-variance Gaussian with a standard Gaussian, it becomes VIB (see Eq. 17 in (Alemi et al., 2017)). The max-entropy regularizer is also linked to Eq. 14 in Sparse VD (Molchanov et al., 2017a), which also encourages large variance/entropy (at a different rate). But again, Sparse VD (Molchanov et al., 2017a) is derived with a completely different motivation: It has an intuitive explanation that the regularizer corresponds to a sparsity prior on the weights. We note that enforcing uncertainty on activations rather than weights has a number of advantages: (i) The weight prior is intractable analytically, which leads to the fact that Sparse VD regularization is itself an approximation. (ii) Deriving the regularizer from a weight prior is unnecessarily complicated for the purpose of sparsifying the model compared to ours. In contrast, our approach sidesteps the need to sample weights and avoids keeping multiple copies of the network, which can potentially improve efficiency (e.g., in memory usage).
+
+Note that stochastic layers have been used in several other works in order to achieve better classification or regression accuracy. Kingma et al. (2015) proposes a generalization of Gaussian dropout where the dropout rates are learned, leading to higher classification accuracy. Natural-parameter networks (NPN) (Wang et al., 2016) is a class of probabilistic neural networks where the input, target output, weights, and neurons can all be modeled by arbitrary exponential-family distributions (e.g., Poisson distributions for word counts) instead of being limited to Gaussian distributions, achieving state-of-the-art performance on classification, regression, and representation learning tasks. To reduce computational cost, Postels et al. (2019) approximates uncertainty estimates using a sampling-free approach and obtains better results on classification and regression tasks.
+
+Network Compression Network compression based on pruning typically uses heuristics based on pruning low-importance weights or low-activation neurons (Molchanov et al., 2017b; Wen et al., 2016), often assisted by sparsity-enhancing priors such as lasso (Wen et al., 2016). We avoid the complication of Bayesian learning of weights by proposing a simpler and direct activation prior that predisposes neurons towards deactivation unless necessary to solve the supervised task.
+
+Adversarial Defense Our method is related to existing randomization-based methods for adversarial defense (Liu et al., 2018; Xie et al., 2018; Alemi et al., 2017; Ye & Zhu, 2018; Liu et al., 2019). However unlike these studies which use a fixed distribution for noise (Liu et al., 2018; Alemi et al., 2017), a learned model distribution for effective randomization (Liu et al., 2019), image perturbations (Xie et al., 2018) or a learned adversarial data-generating distribution (Ye & Zhu, 2018), our randomization-based defense is both learned, and data-dependent since the variance at each layer is generated based on the output of the previous layer.
+
+Label Noise Robustness A number of existing label noise-robust deep learning approaches require a subset of noisy data to be reliably re-annotated (cleaned) to verify which samples contain noise (Lee et al., 2017; Jiang et al., 2018). In contrast, some others including SE-SNN do not rely on additional human noise annotation. These methods address label noise by either iterative label correction via bootstrapping (Reed et al., 2015), adding additional layers on top of a softmax classification layer to estimate the noise pattern (Sukhbaatar et al., 2015; Goldberger & Ben-Reuven, 2017), or loss correlation (Patrini et al., 2017). By allocating large uncertainty to outlying samples, SE-SNN can handle both label noise and out-of-distribution samples with correct labels. This approach to label noise robustness is appealingly simple in that it requires neither explicit detection of noisy samples, nor additional annotation. However label noise robustness has been largely ignored by existing SNNs.
+
+# 4 EXPERIMENTS
+
+Experiments are carried out to evaluate the efficacy of the proposed framework in three applications: neural network pruning, adversarial attack defense and learning with label noise.
+
+# 4.1 NEURAL NETWORK PRUNING
+
+Competitors We follow the architecture/dataset combinations used in most recent neural network pruning studies, including LeNet-5-Caffe1 network on MNIST (LeCun, 1998), VGG-16 (Simonyan & Zisserman, 2015) on CIFAR10 (Krizhevsky & Hinton, 2009) and a variant of VGG–16 on CIFAR100. Under these settings, the proposed method is compared with the following contemporary state-of-the-art methods including Generalized Dropout (GD) (Srinivas & Babu, 2016), Group Lasso (GL) (Wen et al., 2016), Sparse Variational Dropout (VD) (Molchanov et al., 2017a), Structured Bayesian Pruning (SBP) (Neklyudov et al., 2017), Bayesian Compression with Group Normal Jeffreys Prior (BC-GNJ) and Group Horseshoe Prior (BC-GHS) (Louizos et al., 2017), Sparse l0 Regularization (L0) and L0 with separate $\lambda$ for each layer (L0-sep) (Louizos et al., 2018), Variational Information Bottleneck (VIBNet) (Dai et al., 2018), and Network Slimming (NS) (Liu et al., 2017).
+
+Evaluation Metrics Following the majority of the existing evaluations, we monitor the test error while focusing on the following three compression/complexity metrics: (a) Model size: The ratio of nonzero weights in the compressed network versus the original model. (b) FLOPs: The number of floating point operations required to predict a label from an input image during test2. (c) Run-time memory footprint: The ratio of the space for storing hidden feature maps during run-time in the pruned network versus the original network.
+
+Training While many existing studies remove redundant weights, we remove redundant neurons during compression. Therefore, we can use the pipeline proposed in Molchanov et al. (2017b). Specifically, after training the neural network, an initial batch pruning stage is followed by a loop of removing the least important neuron and fine-tuning. Since SE-SNN is designed to discount unimportant neurons through inflating their pre-activation variance, we find that the network achieves this by simultaneously assigning high-variance and negative mean. As a result, a large portion of redundant neurons never activate their RELU non-linearity. In the initial batch pruning stage, neuron inactivity thus provides a single-step pruning criterion before the iterative pruning begins (and one that is guaranteed not to affect the test accuracy since these neurons propagate no information). The pruning then enters the second stage where the least important neuron removal $^ +$ fine-tuning loop continues until reaching the target trade-off between accuracy and model compression objectives. Since one neuron/channel is removed at each iteration, the accuracy never drops sharply. We set the uncertainty loss/regularizer weighting factor and margin $b$ (Eq. 5) as 0.0001 and 4, respectively.
+
+Testing During testing, only the mean of the learned distribution is passed between layers. So there are no additional parameters and inference cost compared to the network’s deterministic counterpart. The distribution generation branches are only used during training to identify redundant neurons.
+
+Results on MNIST The most commonly used benchmark and architecture is MNIST with LeNet5-Caffe. We follow the standard training and testing protocols. The results are shown in Table 1. It is clear that SE-SNN achieves the best performance on FLOPs, run-time memory footprint, and test error. In terms of model size, our model is only comparable with the state of art. This is because it does not prune the linear layer as much as other methods. Instead, it focuses on pruning the convolutional filters, hence the excellent performance on FLOPS and memory footprint.
+
+Results on CIFAR10 For CIFAR10, several VGG16 variants and training protocols have been proposed in different works. We use the standard VGG16 architecture but change the dimension of linear layers from 4096 to 512, as in (Louizos et al., 2017; Dai et al., 2018). The results in Table 2 compare our method with (Louizos et al., 2017; Dai et al., 2018). The error rate for VIBNet in parentheses was obtained by further fine-tuning the pruned architecture. Our model achieves the best performance across all the evaluation metrics and error rates.
+
+Table 1: Compression results on MNIST using LeNet-5-Caffe.   
+
+<table><tr><td>Methods</td><td>Model size (%)</td><td>FLOPs (Mil)</td><td>Memory (%)</td><td>Error(%)</td></tr><tr><td>GD (Srinivas &amp; Babu,2016)</td><td>1.38</td><td>0.250</td><td>32.00</td><td>1.1</td></tr><tr><td>GL (Wen et al., 2016)</td><td>23.69</td><td>0.201</td><td>19.35</td><td>1.0</td></tr><tr><td>VD (Molchanov et al., 2017a)</td><td>9.29</td><td>0.660</td><td>60.78</td><td>1.0</td></tr><tr><td>SBP (Neklyudov et al., 2017)</td><td>19.66</td><td>0.213</td><td>21.15</td><td>0.9</td></tr><tr><td>BC-GNJ (Louizos et al., 2017)</td><td>0.95</td><td>0.283</td><td>35.03</td><td>1.0</td></tr><tr><td>BC-GHS (Louizos et al., 2017)</td><td>0.64</td><td>0.153</td><td>22.80</td><td>1.0</td></tr><tr><td>LO (Louizos et al., 2018)</td><td>8.92</td><td>1.113</td><td>85.82</td><td>0.9</td></tr><tr><td>LO-sep (Louizos et al., 2018)</td><td>1.08</td><td>0.389</td><td>40.36</td><td>1.0</td></tr><tr><td>VIBNet (Dai et al., 2018)</td><td>0.83</td><td>0.094</td><td>15.55</td><td>1.0</td></tr><tr><td>SE-SNN</td><td>2.35</td><td>0.061</td><td>11.08</td><td>0.9</td></tr></table>
+
+Table 2: Compression results on CIFAR10 using VGG16.   
+
+<table><tr><td>Methods</td><td>Model size (%)</td><td>FLOPs (Mil)</td><td>Memory (%)</td><td>Error (%)</td></tr><tr><td>BC-GNJ (Louizos et al., 2017)</td><td>6.57</td><td>141.50</td><td>81.68</td><td>8.6</td></tr><tr><td>BC-GHS (Louizos et al., 2017)</td><td>5.40</td><td>121.90</td><td>74.82</td><td>9.0</td></tr><tr><td>VIBNet (Dai et al.,2018)</td><td>5.30</td><td>70.63</td><td>49.57</td><td>8.8(8.5)</td></tr><tr><td>SE-SNN</td><td>2.57</td><td>53.61</td><td>49.41</td><td>8.0</td></tr></table>
+
+Results on CIFAR100 We compare with the study in (Liu et al., 2017), which uses the same VGG16 variant that replaces two fully connected layers with three convolutional layers. This architecture improves accuracy at the expense of FLOPs and memory. The results in Table 3 show that our model produces the best compression result while maintaining comparable accuracy. Note that the $2 6 . 2 \%$ error rate achieved by our model is identical to that of the original network. So if the accuracy drop is used as a compression metric, our model is as good as any competitor.
+
+# 4.2 ADVERSARIAL DEFENSE
+
+Experimental Setting Following Alemi et al. (2017), we focus on two types of adversarial attacks: Fast Gradient Sign (FGS) (Goodfellow et al., 2015) and an optimization-based attack – CW-L2 (Carlini & Wagner, 2017). We evaluate untargeted FGS attacks with attack magnitude $\epsilon$ ranging from 0.0 to 0.5 and untargeted CW-L2 attack on models trained on MNIST. We use a popular architecture including three FC layers with 1024, 1024 and 256 output neurons respectively. The third FC layer is implemented as a stochastic layer. We set the uncertainty loss/regularizer weighting factor and margin as 0.1 and 16, respectively. Results averaged over 20 runs are reported. We compare against the original (undefended) network, termed as ‘Baseline’, Deep VIB (Alemi et al., 2017) using the variational information bottleneck, Bayesian Adversarial Learning (BAL) (Ye & Zhu, 2018) putting a distribution on the adversarial data-generating process and Adv-BNN (Liu et al., 2019) learning a BNN to incorporate the effective randomness and using adversarial training to seek the best model distribution. Since our model is stochastic, we follow the best practice recommended in (Athalye et al., 2018) for attacking stochastic models: We compute the expected gradient over multiple stochastic samples for each input when constructing attacks. This is because using the expected gradient over multiple posterior samples produces a better gradient estimator for the attacker, allowing it to generate samples that are much harder to defend against (Athalye et al., 2018). For the FGS attack, we evaluate two settings, namely normal training and adversarial training, the latter of which generates and uses FGS attack samples during training to increase adversarial robustness.
+
+Results From the comparative results shown in Figure 2a, we can see that our SE-SNN outperforms the competing defense methods over a range of FGS attack strengths when trained with adversarial attack samples (Figure $2 \mathrm { a } ( \mathrm { R } ) )$ or with only normal samples (Figure 2a(L)). The advantage of SE-SNN is particularly pronounced when the attack magnitude is large. We can also see from Figure 2b that under the stronger CW attacks the Baseline now fails completely. In this case SE-SNN provides the most effective defense. It is worth pointing out that, unlike BAL (Ye & Zhu, 2018), which learns their models with explicit adversarial sampling, our SE-SNN can also work with training with only normal samples - Figure 2a suggests that our SE-SNN beats BAL even without being trained with adversarial attack samples (comparing SE-SNN in Figure 2a(L) to BAL in Figure 2a(R)).
+
+Table 3: Compression results on CIFAR100 using a VGG16 variant.   
+
+<table><tr><td>Methods</td><td>Model size (%)</td><td>FLOPs (Mil)</td><td>Memory (%)</td><td>Error (%)</td></tr><tr><td>NS-Single (Liu et al., 2017)</td><td>24.90</td><td>250.50</td><td>1</td><td>26.5</td></tr><tr><td>NS-Best (Liu et al., 2017)</td><td>20.80</td><td>214.80</td><td>1</td><td>26.0</td></tr><tr><td>VIBNet (Dai et al., 2018)</td><td>15.08</td><td>203.10</td><td>73.80</td><td>25.9(25.7)</td></tr><tr><td>SE-SNN</td><td>14.93</td><td>181.31</td><td>70.16</td><td>26.2</td></tr></table>
+
+![](images/4e0db648e6cbb51b018d1fcb324b9df469c62eba7c8c388da09529c50da9fdb8.jpg)  
+Figure 2: Adversarial defense accuracy (mean $^ +$ standard deviation) under untargeted FGS and CW attacks on MNIST.
+
+# 4.3 ROBUSTNESS AGAINST LABEL NOISE
+
+In this section, tasks including digit recognition and person re-identification (ReID) are considered. Compared to Digit recognition, ReID is much more challenging. Particularly, ReID is an instance recognition task, which aims to match people under disjoint camera views. Although the performance of state-of-the-art ReID models on public benchmarks approaches saturation, ReID with label noise remains an unsolved and under-studied problem.
+
+Datasets The label noise robustness of our SE-SNN is evaluated for digit recognition using MNIST and ReID using Market-1501 (Zheng et al., 2015) benchmark. Market1501 is collected by 6 cameras and contains 751 training identities (12,936 images) and 750 test identities (19,281 images). The test set is organized into a query set and a gallery set. Cumulative Matching Characteristics (CMC) ranks and mean Average Precision are used as the performance measure.
+
+Noise Generation We consider patterned label noise which is more common in practice. Specifically, for MNIST, one class label will be flipped to a different one at a strength $p$ . The flipping pattern is fixed for each run but varies across different runs following (Hendrycks et al., 2018). For Market-1501, we use the commonly used ResNet-50 (He et al., 2016) trained on the clean data to obtain the feature of each training sample and find the most visually similar samples using feature Euclidean distance. Then for randomly selected training samples, their identity labels are assigned to that of the most similar sample that has a different identity, imitating human annotation errors.
+
+Competitors Baseline: The main baseline is the original network without adding our stochastic layers. For a fair comparison, we add a parallel layer to the penultimate (feature) layer in the baseline to guarantee the two networks have the same number of parameters. The input of the added layer is the same as the feature layer, and its output is element-wise added along with the output of the feature layer to get the final feature, which is then fed to a fully connected layer for computing the classification loss. Bootstrap_hard and Bootstrap_soft (Reed et al., 2015): Both iteratively use the model-predicted labels to refine the original labels that are potentially corrupted by noise. They differ in whether the updated label is binary or continuous. Forward Correction (Patrini et al., 2017): This model predicts the label corruption matrix (capturing the label flipping pattern) by first training a classifier on the noisy labels followed by corruption matrix estimation using the resulting softmax probabilities. The estimated matrix is then employed to regularize the retraining of the model. For MNIST, we stick to the original setting, which uses the argmax at the 97th percentile of softmax probabilities for label noise detection. For the ReID experiment, we replace this with the argmax over all softmax probabilities for a given class following what Patrini et al. (2017) did on datasets of more classes such as CIFAR100. CleanNet (Lee et al., 2017): different from other models, this one requires a subset of noisy training samples to be re-annotated by a more reliable source (i.e., cleaned). It then learns the similarity between class and query-embedding vectors, which is further used to detect noisy samples for sample pruning. Having a cleaned subset gives CleanNet an unfair advantage over other compared models. The model requires at least 5 FC layers so cannot be implemented for the MNIST backbone. For person ReID, $10 \%$ of the training set without noise is used as a clean reference set to train CleanNet using the author-provided code. After training, $20 \%$ of the whole training set deemed most likely to be noisy are removed before the final ReID model is trained on the remainder. Note that unlike the four competitors, our SE-SNN does not have any additional steps to refine the label or prune the training samples. As explained earlier, it works by discounting/neutralizing the negative influence of noisy samples (hence also works on out-of-distribution samples with correct labels). Having said that, it can be easily combined with a label refinement procedure such as the corruption matrix based one in Forward Correction (Patrini et al., 2017).
+
+![](images/6216d76c2639e3deccd582e6c00e11213c98d68b8fd0f0d0e000006fffe91fca.jpg)  
+Figure 3: Label noise results on MINIST (a) and ablation study results on Market-1501 (b,c). In (c), the top row shows samples with the highest variance and bottom row those with the lowest when there is no label noise. The high variance uncertain samples correspond to poor detections and occlusions.
+
+<table><tr><td rowspan="2">Strengths Models</td><td colspan="4">10%</td><td colspan="4">20%</td><td colspan="4">50%</td></tr><tr><td>mAP</td><td>Rank1</td><td>Rank5</td><td>Rank10</td><td>mAP</td><td>Rank1</td><td>Rank5</td><td>Rank10</td><td>mAP</td><td>Rank1</td><td>Rank5</td><td>Rank10</td></tr><tr><td>B</td><td>25.87</td><td>51.46</td><td>70.21</td><td>76.81</td><td>23.49</td><td>48.44</td><td>67.85</td><td>74.67</td><td>20.74</td><td>44.04</td><td>64.32</td><td>72.27</td></tr><tr><td>H</td><td>25.76</td><td>51.08</td><td>70.11</td><td>77.06</td><td>23.40</td><td>48.25</td><td>67.34</td><td>74.40</td><td>19.87</td><td>42.87</td><td>63.37</td><td>71.40</td></tr><tr><td>S</td><td>25.50</td><td>50.47</td><td>69.43</td><td>76.32</td><td>24.08</td><td>49.51</td><td>68.77</td><td>75.62</td><td>20.72</td><td>43.86</td><td>64.49</td><td>72.55</td></tr><tr><td>C</td><td>26.64</td><td>52.47</td><td>70.90</td><td>77.41</td><td>24.28</td><td>49.54</td><td>68.35</td><td>75.33</td><td>19.90</td><td>43.01</td><td>63.13</td><td>71.34</td></tr><tr><td>F</td><td>21.17</td><td>45.88</td><td>64.79</td><td>71.69</td><td>18.91</td><td>42.11</td><td>62.12</td><td>69.99</td><td>15.34</td><td>36.06</td><td>56.23</td><td>64.55</td></tr><tr><td>SE-SNN</td><td>27.30</td><td>53.21</td><td>71.03</td><td>77.38</td><td>24.72</td><td>49.87</td><td>68.90</td><td>76.10</td><td>21.32</td><td>44.86</td><td>65.03</td><td>72.93</td></tr></table>
+
+Table 4: Re-ID results on Market-1501 with label-noise. Model abbreviations: B: ResNet-Baseline, H: Bootstrap_hard (Reed et al., 2015), S: Bootstrap_soft (Reed et al., 2015), C: CleanNet (Lee et al., 2017), F: Forward Correction (Patrini et al., 2017).
+
+Results The results on MNIST are shown in Figure 3a. We can see that even without any label correction/refinement procedure, our SE-SNN is already very competitive – it is only beaten by Forward Correction when the corruption strength (percentage of samples with label noise) is large $( > 0 . 2 )$ . Once our SE-SNN is combined with the same procedure adopted by Forward Correction (SE-SNN $+$ Forward), we achieve the best result. On the more challenging ReID task in Market-1501 (Table 4), our SE-SNN also achieves the best overall performance - even beating CleanNet which needs an additional cleaned training subset. Note that the strongest competitor on MNIST, Forward Correction now is the weakest. This is because, as admitted in (Patrini et al., 2017), it struggles with estimating an accurate correction matrix given a small number of training samples per class (e.g., 500 per class in CIFAR100). The $< 2 0$ class size in Market-1501 means that the label correction procedure only has a detrimental effect. Figure 3b compares the average variance/uncertainty inferred for clean and noisy data in Market-1501. We can see that, indeed the variance of noisy data is larger than that of clean data on average. We also notice that even when there is no label noise, SE-SNN beats the baseline by a clear margin ( $7 0 . 2 0 \%$ mAP vs. $6 7 . 6 6 \%$ ). This suggests that the mechanism of neutralizing outlying samples is still in play when the labels are clean. To validate this, we show some examples of outliers (those with the largest variance) in Figure 3c when there is no label noise. It is clear that these are mostly caused by either poor person detection or occlusion (i.e., outliers). In contrast, images with the smallest variance mostly contain people detected perfectly and without occlusion – the model is thus most confident about the feature representations for these.
+
+More SE-SNN implementation details for the label noise robust learning and more results can be found in the Appendix A. Further analyses across all tasks including hyperparameter analysis, solving multiple tasks in one model, effects of the number of stochastic layers are given in Appendix B.
+
+# 5 CONCLUSION
+
+We proposed a simple and effective stochastic neural network framework. Our model is related to VIB and variational dropout, but provides a simpler and more direct realization via neuron regularization by a non-informative activation prior. Our extensive experiments show that this simple framework has diverse benefits for network pruning, adversarial defense and label noise robust learning.
+
+# REFERENCES
+
+Alexander A Alemi, Ian Fischer, Joshua V Dillon, and Kevin Murphy. Deep variational information bottleneck. In ICLR, 2017.
+
+Anish Athalye, Nicholas Carlini, and David Wagner. Obfuscated gradients give a false sense of security: Circumventing defenses to adversarial examples. In ICML, 2018.
+
+Chris M. Bishop. Training with noise is equivalent to tikhonov regularization. Neural Computation, 7(1):108–116, 1995.
+
+Charles Blundell, Julien Cornebise, Koray Kavukcuoglu, and Daan Wierstra. Weight uncertainty in neural networks. In ICML, 2015.
+
+Nicholas Carlini and David Wagner. Towards evaluating the robustness of neural networks. In IEEESSP, 2017.
+
+Bin Dai, Chen Zhu, Baining Guo, and David Wipf. Compressing neural networks using the variational information bottleneck. In ICML, 2018.
+
+Gwendoline de Bie, Gabriel Peyré, and Marco Cuturi. Stochastic deep networks. In ICML, 2019.
+
+Charlie Frogner, Farzaneh Mirzazadeh, and Justin Solomon. Learning embeddings into entropic wasserstein spaces. In ICLR, 2019.
+
+Yarin Gal and Zoubin Ghahramani. Dropout as a Bayesian approximation: Representing model uncertainty in deep learning. In ICML, 2016.
+
+Marta Garnelo, Dan Rosenbaum, Christopher Maddison, Tiago Ramalho, David Saxton, Murray Shanahan, Yee Whye Teh, Danilo Rezende, and S. M. Ali Eslami. Conditional neural processes. In ICML, 2018.
+
+Jacob Goldberger and Ehud Ben-Reuven. Training deep neural-networks using a noise adaptation layer. In ICLR, 2017.
+
+Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. In ICLR, 2015.
+
+Alex Graves. Practical variational inference for neural networks. In NIPS, 2011.
+
+Caglar Gulcehre, Marcin Moczulski, Misha Denil, and Yoshua Bengio. Noisy activation functions. In ICML, 2016.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016.
+
+Dan Hendrycks, Mantas Mazeika, Duncan Wilson, and Kevin Gimpel. Using trusted data to train deep networks on labels corrupted by severe noise. In NIPS, 2018.
+
+Lu Jiang, Zhengyuan Zhou, Thomas Leung, Li-Jia Li, and Li Fei-Fei. Mentornet: Learning datadriven curriculum for very deep neural networks on corrupted labels. In ICML, 2018.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In ICLR, 2015.
+
+Diederik P. Kingma and Max Welling. Auto-encoding variational bayes. In ICLR, 2014.
+
+Durk P Kingma, Tim Salimans, and Max Welling. Variational dropout and the local reparameterization trick. In NIPS, 2015.
+
+Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. Technical report, Citeseer, 2009.
+
+Yann LeCun. The mnist database of handwritten digits. http://yann. lecun. com/exdb/mnist/, 1998.
+
+Kuang-Huei Lee, Xiaodong He, Lei Zhang, and Linjun Yang. Cleannet: Transfer learning for scalable image classifier training with label noise. In ICCV, 2017.
+
+Xuanqing Liu, Minhao Cheng, Huan Zhang, and Cho-Jui Hsieh. Towards robust neural networks via random self-ensemble. In ECCV, 2018.
+
+Xuanqing Liu, Yao Li, Chongruo Wu, and Cho-Jui Hsieh. Adv-bnn: Improved adversarial defense through robust bayesian neural network. In ICLR, 2019.
+
+Zhuang Liu, Jianguo Li, Zhiqiang Shen, Gao Huang, Shoumeng Yan, and Changshui Zhang. Learning efficient convolutional networks through network slimming. In ICCV, 2017.
+
+Christos Louizos, Karen Ullrich, and Max Welling. Bayesian compression for deep learning. In NIPS, 2017.
+
+Christos Louizos, Max Welling, and Diederik P Kingma. Learning sparse neural networks through l_0 regularization. In ICLR, 2018.
+
+Dmitry Molchanov, Arsenii Ashukha, and Dmitry Vetrov. Variational dropout sparsifies deep neural networks. In ICML, 2017a.
+
+Pavlo Molchanov, Stephen Tyree, Tero Karras, Timo Aila, and Jan Kautz. Pruning convolutional neural networks for resource efficient inference. In ICLR, 2017b.
+
+Arvind Neelakantan, Luke Vilnis, Quoc V. Le, Lukasz Kaiser, Karol Kurach, Ilya Sutskever, and James Martens. Adding gradient noise improves learning for very deep networks. CoRR, abs/1511.06807, 2015.
+
+Kirill Neklyudov, Dmitry Molchanov, Arsenii Ashukha, and Dmitry P Vetrov. Structured bayesian pruning via log-normal multiplicative noise. In NIPS, 2017.
+
+Hyeonwoo Noh, Tackgeun You, Jonghwan Mun, and Bohyung Han. Regularizing deep neural networks by noise: Its interpretation and optimization. In NIPS, 2017.
+
+Giorgio Patrini, Alessandro Rozza, Aditya Krishna Menon, Richard Nock, and Lizhen Qu. Making deep neural networks robust to label noise: A loss correction approach. In CVPR, 2017.
+
+Janis Postels, Francesco Ferroni, Huseyin Coskun, Nassir Navab, and Federico Tombari. Samplingfree epistemic uncertainty estimation using approximated variance propagation. In ICCV, 2019.
+
+Scott E. Reed, Honglak Lee, Dragomir Anguelov, Christian Szegedy, Dumitru Erhan, and Andrew Rabinovich. Training deep neural networks on noisy labels with bootstrapping. In ICLR Workshop, 2015.
+
+Hippolyt Ritter, Aleksandar Botev, and David Barber. A scalable laplace approximation for neural networks. In ICLR, 2018.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. In ICLR, 2015.
+
+Suraj Srinivas and R Venkatesh Babu. Generalized dropout. CoRR, abs/1611.06791, 2016.
+
+Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: A simple way to prevent neural networks from overfitting. JMLR, 15:1929–1958, 2014.
+
+Sainbayar Sukhbaatar, Joan Bruna, Manohar Paluri, Lubomir Bourdev, and Rob Fergus. Training convolutional networks with noisy labels. In ICLR, 2015.
+
+Table A.1: Standard deviation value of Re-ID results on Market-1501 with label-noise.   
+
+<table><tr><td>Strengths</td><td colspan="4">10%</td><td colspan="4">20%</td><td colspan="4">50%</td></tr><tr><td>Models</td><td>mAP</td><td>Rank1</td><td>Rank5</td><td>Rank10</td><td>mAP</td><td>Rank1</td><td>Rank5</td><td>Rank10</td><td>mAP</td><td>Rank1</td><td>Rank5</td><td>Rank10</td></tr><tr><td>B</td><td>0.41</td><td>0.83</td><td>0.75</td><td>0.98</td><td>0.56</td><td>0.82</td><td>0.74</td><td>0.62</td><td>1.25</td><td>2.04</td><td>1.48</td><td>1.56</td></tr><tr><td>H</td><td>0.60</td><td>0.76</td><td>1.34</td><td>1.12</td><td>0.70</td><td>0.97</td><td>0.57</td><td>0.77</td><td>0.93</td><td>1.82</td><td>1.55</td><td>0.97</td></tr><tr><td>S</td><td>0.78</td><td>0.93</td><td>0.85</td><td>0.95</td><td>0.82</td><td>1.48</td><td>1.45</td><td>1.38</td><td>0.51</td><td>1.11</td><td>0.85</td><td>0.61</td></tr><tr><td>C</td><td>0.83</td><td>1.45</td><td>0.98</td><td>0.90</td><td>0.44</td><td>0.53</td><td>0.96</td><td>0.58</td><td>1.08</td><td>1.68</td><td>1.85</td><td>1.66</td></tr><tr><td>F</td><td>1.03</td><td>1.64</td><td>1.98</td><td>1.53</td><td>0.82</td><td>1.50</td><td>1.12</td><td>0.86</td><td>0.56</td><td>1.48</td><td>1.63</td><td>1.97</td></tr><tr><td>SE-SNN</td><td>0.43</td><td>1.11</td><td>0.88</td><td>0.74</td><td>0.24</td><td>0.68</td><td>0.67</td><td>0.44</td><td>0.94</td><td>1.46</td><td>1.42</td><td>1.11</td></tr></table>
+
+Naftali Tishby, Fernando C Pereira, and William Bialek. The information bottleneck method. In Allerton, 1999.
+
+Hao Wang, SHI Xingjian, and Dit-Yan Yeung. Natural-parameter networks: A class of probabilistic neural networks. In NIPS, 2016.
+
+Wei Wen, Chunpeng Wu, Yandan Wang, Yiran Chen, and Hai Li. Learning structured sparsity in deep neural networks. In NIPS, 2016.
+
+Cihang Xie, Jianyu Wang, Zhishuai Zhang, Zhou Ren, and Alan L. Yuille. Mitigating adversarial effects through randomization. In ICLR, 2018.
+
+Nanyang Ye and Zhanxing Zhu. Bayesian adversarial learning. In NIPS, 2018.
+
+Zhonghui You, Jinmian Ye, Kunming Li, and Ping Wang. Adversarial noise layer: Regularize neural network by adding noise. CoRR, abs/1805.08000, 2018.
+
+Liang Zheng, Liyue Shen, Lu Tian, Shengjin Wang, Jingdong Wang, and Qi Tian. Scalable person re-identification: A benchmark. In ICCV, 2015.
+
+# A EXPERIMENTAL DETAILS OF LABEL NOISE
+
+For the experiments on MNIST, we follow (Patrini et al., 2017) to train a neural network with two FC layers of dimension 128, where both FC layers are implemented as stochastic layers. For Market-1501, following most recent state-of-the-art ReID models we use ResNet-50 (He et al., 2016) as the backbone. In this model, only the last unit of the final residual block is implemented as a stochastic layer.
+
+For Market-1501, we train our model for two stages: (1) We fine-tune ImageNet pretrained ResNet-50 (for identity classification) on Market-1501 training set for 60, 000 iterations. We use batch size 32 and Adam optimizer (Kingma & Ba, 2015) with learning rate $3 . 5 \times 1 0 ^ { - 4 }$ . (2) We retain the model parameters trained in stage (1) and extend the last unit to a stochastic layer with randomly initialized $\sigma$ layer. Then, we train the stochastic layer and the classifier for another 20, 000 iterations with a lower learning rate $5 \times 1 0 ^ { - 4 }$ . The margin $b$ is set as 4 in the max-entropy regularization loss (Eq. 6) and a loss weight $1 0 ^ { - 2 }$ is assigned.
+
+For both benchmarks, due to the randomness of noisy samples in selection and label reassignment, multiple runs of experiments are conducted. The standard deviation values of Re-ID results on Market-1501 with label-noise are shown in Table A.1.
+
+# B FURTHER ANALYSIS
+
+# B.1 HYPER-PARAMETERS ANALYSIS
+
+In this section, we analyze the impact of loss weight, which is denoted as $\omega$ , and the margin $b$ for regularizers of all tasks on MNIST. We report the FLOPs of the compressed model (Network pruning), adversarial defense accuracy under the FGSM attack (Adversarial defense) and test accuracy of a model trained with $40 \%$ label noise (Label noise) in Figure B.1.
+
+In Figure B.1(top), we evaluate the effects of having different values of $\omega$ from $[ 1 0 ^ { - 1 } , 1 0 ^ { - 2 } , 1 0 ^ { - 3 } ]$ . We can see that, for all three values and across the three tasks, the performance of our method is only marginally impacted by $\omega$ and the overall best performance is achieved when $\omega = 1 0 ^ { - 2 }$ .
+
+![](images/69c8feecd27f570b16ac7a611be0422a7581dd894cbc28c6ef71861ff9971777.jpg)  
+Figure B.1: Impact analysis of loss weight $\omega$ (top) and margin $b$ (bottom) on MNIST.
+
+![](images/028d8326137d39ac1891ff96be9dee83b9175deb4c795ae551b871da30c2fb6e.jpg)  
+Figure B.2: Test accuracy of different methods trained on MNIST with label noise.
+
+![](images/640e1e2b7367e65565fdf284527e3c8ce681a6727157ab254bf1f5475ab1e94f.jpg)  
+Figure B.3: Effect of the number of stochastic layers on MNIST with label noise.
+
+![](images/5596edc72715a074b4f2443056bd4fabd64c4d21b7e94c9087f4af4d6a73d26e.jpg)  
+Figure B.4: Convergence Curve on MNIST with label noise .
+
+In Figure B.1(bottom), we investigate the sensitivity of our model to the values of margin $b$ . Three values, $[ \log ( 1 ) , \log ( 4 ) , \log ( 1 6 ) ]$ are considered. Recall that our SE-SNN uses a non-informative prior to regularize the uncertainty of neuron activations, and a margin $b$ is employed to upper-bound the standard deviation of the stochastic layers in SE-SNN. Therefore, larger values of $b$ will lead to a higher degree of uncertainty of stochastic layers. From Figure B.1(bottom), we can see that increasing the value of $b$ improves the performance of our method on adversarial defense and label noise. However, for network pruning, smaller $b$ is preferred. Overall, our model is insensitive to the value of $b$ .
+
+# B.2 COMBINATION OF NETWORK PRUNING AND LABEL NOISE
+
+The effectiveness of our SE-SNN has been demonstrated on the three tasks separately, but there is no reason why it cannot be deployed to deal with multiple tasks simultaneously. To validate this, in this experiment, we train SE-SNN on MNIST with $40 \%$ label noise while conducting model pruning. We use the same architecture with three FC layers (784-128-128-10) as the previous label noise experiments, and make the first two layers stochastic layers. We compare the trained model with two competitors, including the baseline model (without stochastic layers) and our normal SE-SNN (without pruning) both trained with label noise.
+
+From the results in Figure B.2, we can see that we get a pruned SE-SNN (145-26-15-10) trained with label noise achieving $9 5 . 2 0 \%$ test accuracy, which is even slightly better than our normal SE-SNN $( 9 5 . 1 7 \% )$ and much better than the baseline $( 8 1 . 0 4 \% )$ .
+
+# B.3 EFFECT OF THE NUMBER OF STOCHASTIC LAYERS
+
+In this section, we study the effect of the number of used stochastic layers (SLs). The experiments are run on the label noise robust learning task with network comprising two FC layers. For the network
+
+with one SL, we make the penultimate layer stochastic. Note that the network with zero SL is the baseline. Figure B.3 shows the test accuracy of models with different numbers of SLs used. We can see that increasing the number of SLs helps improve the model’s robustness to label noise.
+
+# B.4 CONVERGENCE CURVE
+
+The training efficiency of the proposed method is studied here by examining how fast the algorithm converges. The experiments are run on the label noise robust learning task. Figure B.4 shows the losses of different methods during 10 training epochs. It is observed that Bootstrap and Forward have larger loss values than the rest. This is because they use losses in addition to the classification loss. Overall our method is shown to be as efficient as other methods, despite the fact that we have introduced stochastic layers and used a reparameterization trick during training.

parse/train/SJxeI6EYwS/SJxeI6EYwS_content_list.json

@@ -0,0 +1,1615 @@
+[
+    {
+        "type": "text",
+        "text": "SIMPLE AND EFFECTIVE STOCHASTIC NEURAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            826,
+            145
+        ],
+        "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,
+            250
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Stochastic neural networks (SNNs) are currently topical, with several paradigms being actively investigated including dropout, Bayesian neural networks, variational information bottleneck (VIB) and noise regularized learning. These neural network variants impact several major considerations, including generalization, network compression, and robustness against adversarial attack and label noise. However, many existing networks are complicated and expensive to train, and/or only address one or two of these practical considerations. In this paper we propose a simple and effective stochastic neural network (SE-SNN) architecture for discriminative learning by directly modeling activation uncertainty and encouraging high activation variability. Compared to existing SNNs, our SE-SNN is simpler to implement and faster to train, and produces state of the art results on network compression by pruning, adversarial defense and learning with label noise. ",
+        "bbox": [
+            233,
+            266,
+            766,
+            434
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            460,
+            336,
+            477
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Stochastic neural networks (SNNs) have a long history. Recently various stochastic neural network instantiations have been topical in their applications to reducing overfitting (Gal & Ghahramani, 2016; Neelakantan et al., 2015) and training data requirements (Garnelo et al., 2018), providing confidence estimates on predictions (Gal & Ghahramani, 2016), enabling network compression (Dai et al., 2018), improving robustness to adversarial attack (Alemi et al., 2017), improving optimization (Neelakantan et al., 2015), generative modeling (Kingma & Welling, 2014), and inputting or producing probability distributions (de Bie et al., 2019; Frogner et al., 2019). ",
+        "bbox": [
+            174,
+            492,
+            825,
+            590
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "One of the most theoretically appealing stochastic neural network formulations is Bayesian neural networks, which place a prior distribution on the weights of the network (Graves, 2011; Blundell et al., 2015; Ritter et al., 2018). However this usually necessitates more complex learning and inference procedures that rely on variational approximations or sampling. Another group of works instead focus on modeling the uncertainty in neural network activations. Notably the variational information bottleneck (VIB) approach (Alemi et al., 2017) is motivated by information theoretic considerations (Tishby et al., 1999) to learn a hidden representation that carries maximum information about the output and minimum information about the input. Evaluating the required mutual information terms requires modeling probability distributions over activations rather than weights. Deep VIB (Alemi et al., 2017) leads to improved generalization, adversarial robustness and model compression algorithms (Dai et al., 2018). Furthermore, modeling stochastic activations through noise is often practically useful for improving exploration and local minima escape during optimization, generalization and adversarial robustness (You et al., 2018; Noh et al., 2017; Bishop, 1995; Gulcehre et al., 2016), and in some cases can be linked back to Bayesian models of weights (Noh et al., 2017; Gal & Ghahramani, 2016) when the noise added at each activation can be considered as a result of different samples from the weight posterior. ",
+        "bbox": [
+            174,
+            597,
+            825,
+            819
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper we propose a simple and effective stochastic neural network (SE-SNN) that models activation uncertainty through predicting a Gaussian mean and variance at each layer, which is then sampled during the forward pass. This is similar to the strategy used to model activation distributions in VAE (Kingma & Welling, 2014) and VIB (Alemi et al., 2017). Differently, we then place a non-informative prior on activation distribution and derive an activation regularizer that directly encourages high activation variability via preferring high-entropy activations. In conjunction with a discriminative learning loss, this means that the network is optimized for activation patterns that have high uncertainty while simultaneously being predictive of the target variable. The interplay between these two objectives leads to several appealing capabilities in pruning, adversarial defense and learning with label noise. Pruning: Optimizing for high per-activation variability/uncertainty and predictive accuracy simultaneously lead to the network packing more entropy into the least significant neurons – so that the most crucial neurons are free to operate unperturbed. This leads to a simple pruning criterion based on each neuron’s entropy value. Adversarial defense: By optimizing for both peractivation uncertainty and the network’s predictive accuracy, a representation-level data augmentation policy is trained that perturbs the internal features during training for increased robustness (Alemi et al., 2017; You et al., 2018). Label noise: With SE-SNN, per-activation uncertainty can be easily aggregated to produce per-instance uncertainty. By optimizing for per-instance uncertainty and predictive accuracy, the network allocates the uncertainty to spread the representation and prediction of the hard-to-classify instances so as to downweight their influence on parameter learning. The result is a model robust to label noise as well as outlying training samples. ",
+        "bbox": [
+            174,
+            827,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/3d6cee1a31d4fb965a58f7b1cd414df15ae004bec72581ec40f5d3409024eca1.jpg",
+        "image_caption": [
+            "Figure 1: An illustration of the stochastic learning module in a SE-SNN. The output of layer $l$ is sampled from the learned distribution defined by $f ^ { \\mu } ( h ^ { l - 1 } )$ and $f ^ { \\sigma } ( h ^ { l - 1 } )$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            276,
+            101,
+            722,
+            185
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            241,
+            825,
+            422
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To summarize, our contributions are: (1) A new simple yet effective stochastic neural network formulation. (2) We show that our SE-SNN has connections to VIB (Alemi et al., 2017), Dropout (Srivastava et al., 2014) and non-informative activation priors while being simpler to implement and faster to train, as well as impactful on a variety of practical problems. (3) Comprehensive evaluations show excellent performance on pruning-based model compression, adversarial defense, and label noise robust learning. ",
+        "bbox": [
+            174,
+            429,
+            825,
+            513
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 METHODOLOGY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            537,
+            341,
+            554
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Stochastic Layers We consider a neural network discriminatively trained for a predictive task such as object recognition. Instead computing fixed point estimates of feature vectors, we propose to use stochastic neurons. More specifically, for an input $h$ , a layer will output a series of univariate distributions. By sampling from those distributions independently, we get a random output $z$ . Finally we apply the non-linear activation function $\\psi ( \\cdot )$ to $z$ and get the input for the next layer. In this study, we choose to use Gaussian distribution with parameterized mean and variance, which has been popularized by VAE (Kingma & Welling, 2014) and VIB (Alemi et al., 2017) due to the ease of reparameterization. Formally, for the $l$ -th layer, this forward-pass process can be written as (omitting neuron index for notation simplicity), ",
+        "bbox": [
+            173,
+            574,
+            825,
+            702
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/528edaa7ae4378774316fa5664296d4d3cfc8262ef9128925bcf610a94296f0a.jpg",
+        "text": "$$\n\\begin{array} { r l r } & { } & { \\mu ^ { ( l ) } = f ^ { \\mu } \\big ( h ^ { ( l - 1 ) } \\big ) , } \\\\ & { } & { \\sigma ^ { ( l ) } = f ^ { \\sigma } \\big ( h ^ { ( l - 1 ) } \\big ) , } \\\\ & { } & { z ^ { ( l ) } \\sim \\mathcal { N } ( \\mu ^ { ( l ) } , \\sigma ^ { ( l ) } ) , } \\\\ & { } & { h ^ { ( l ) } = \\psi ( z ^ { ( l ) } ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            411,
+            710,
+            552,
+            792
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "This process is illustrated in Figure 1, where each standard deviation predictor $f ^ { \\sigma }$ comes with a softplus activation $f ( x ) = \\log ( \\bar { 1 } + \\exp ( x ) )$ to ensure non-negativity. ",
+        "bbox": [
+            173,
+            801,
+            825,
+            830
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Supervised Learning Loss We can choose to replace some or all intermediate layers of a vanilla neural network with such stochastic layers. For the final layer (i.e., the classifier) we opt for a standard linear layer, and the classification loss is the same as that of a vanilla neural network, e.g., cross-entropy. Since a Gaussian distribution is fully reparameterizable, the network can be trained end-to-end as long as the sampling process $z \\sim \\mathcal { N } ( \\mu , \\overline { { \\sigma } } )$ is realized by $z = \\mu + \\epsilon \\cdot \\sigma$ where $\\epsilon \\sim \\mathcal { N } ( 0 , 1 )$ . ",
+        "bbox": [
+            173,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Max-entropy Regularization We place a non-informative prior on the produced Gaussian (denoted as $\\mathcal { N } ( \\mu _ { 1 } , \\sigma _ { 1 } ) )$ . The non-informative prior is a Gaussian with arbitrary mean $( \\mu _ { 1 } )$ and infinite variance $( \\sigma _ { 1 } ^ { 2 } )$ . This reflects the prior that none of neurons is meaningful for predictive purposes. The non-informative prior leads to a regularization term that minimizes the KL divergence of the produced Gaussian ( $\\mathcal { N } ( \\mu _ { 2 } , \\sigma _ { 2 } ) )$ and the infinite-variance Gaussian ",
+        "bbox": [
+            174,
+            102,
+            825,
+            174
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0f70d59b0666c4e862275a9f3fa2ee7f5b5b024a713e11f1ea6ce90606218514.jpg",
+        "text": "$$\n\\begin{array} { r l r } & { \\underset { \\mu _ { 1 } , \\sigma _ { 1 } } { \\mathrm { m i n } } \\ ( \\underset { \\sigma _ { 2 } \\to \\infty } { \\mathrm { l i m } } \\mathrm { K L } ( \\mathcal { N } ( \\mu _ { 1 } , \\sigma _ { 1 } ) | | \\mathcal { N } ( \\mu _ { 2 } , \\sigma _ { 2 } ) ) ) , \\ } & { \\qquad } & { \\forall \\mu _ { 2 } \\in \\mathbb { R } } \\\\ & { \\Rightarrow \\ \\underset { \\mu _ { 1 } , \\sigma _ { 1 } } { \\mathrm { m i n } } \\ ( \\underset { \\sigma _ { 2 } \\to \\infty } { \\mathrm { l i m } } ( \\log \\frac { \\sigma _ { 2 } } { \\sigma _ { 1 } } + \\frac { \\sigma _ { 1 } ^ { 2 } + ( \\mu _ { 1 } - \\mu _ { 2 } ) ^ { 2 } } { 2 \\sigma _ { 2 } ^ { 2 } } - \\frac { 1 } { 2 } ) ) , \\ } & { \\qquad } & { \\forall \\mu _ { 2 } \\in \\mathbb { R } } \\\\ & { \\Rightarrow \\ \\underset { \\sigma _ { 1 } } { \\mathrm { m i n } } \\ ( \\underset { \\sigma _ { 2 } \\to \\infty } { \\mathrm { l i m } } ( \\log \\frac { \\sigma _ { 2 } } { \\sigma _ { 1 } } ) ) } & { \\Rightarrow \\ \\underset { \\sigma _ { 1 } } { \\mathrm { m i n } } \\ ( - \\log \\sigma _ { 1 } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            251,
+            171,
+            745,
+            267
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Eq. 2 suggests that we simply need to maximize the predicted standard deviation, or equivalently the entropy of the predicted Gaussian. Thus we call it a max-entropy regularizer $\\Omega$ . It can be easily used in any existing neural network architecture: ",
+        "bbox": [
+            173,
+            267,
+            825,
+            309
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f803b3abfc30be7aa561231fdc73426a2511c4b7d71fd8c0337314fc6b34cf49.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\theta } - \\log ( \\sigma ( h | \\theta ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            431,
+            311,
+            566,
+            334
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\sigma ( h | \\theta )$ denotes the predicted standard deviation of hidden unit $h$ given the neuron uncertainty prediction parameter $\\theta$ . For numerical safety, we introduce a margin $b$ in the loss, ",
+        "bbox": [
+            173,
+            338,
+            825,
+            366
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9df35fc34ff407249661977e3da85190b70dace5336d8bea2d2ee3c0b392597c.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\theta } { ( b - \\log ( \\sigma ( h | \\theta ) ) ^ { + } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            418,
+            368,
+            578,
+            391
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "This means that the regularization does not punish the model as long as the entropy is larger than a threshold $b$ . Note that, this loss design is not absolutely necessary as the increment for $\\sigma$ shrinks (since the gradient is $- { \\frac { 1 } { \\sigma } } .$ ) during training, and thus never reaches infinity with a finite number of updates. However, one can think of it as an early-stopping mechanism for this regularization term. ",
+        "bbox": [
+            173,
+            393,
+            825,
+            450
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "So far we have introduced the stochasticity to the smallest unit of a network, i.e., a single neuron. To compute the value of the regularizer over a mini-batch consisting of $N$ training samples, we need to aggregate the entropy of multiple neurons and set the margin $b$ on the aggregation. How to aggregate exactly is task-dependent, and we next provide some suggestions for three tasks including network pruning, adversarial defense, and label noise defense. ",
+        "bbox": [
+            173,
+            457,
+            825,
+            527
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Pruning For network pruning, we aggregate entropy over samples for each neuron, and then penalize if that neuron’s aggregated entropy is low. To this end, the regularizer is formulated as: ",
+        "bbox": [
+            174,
+            536,
+            820,
+            565
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/470c48eed0fd43bd3ba4e26f5ae5f6bb11cb0472f7a7893d1ec0d2581903f542.jpg",
+        "text": "$$\n\\Omega ( \\theta ) = \\frac { 1 } { K } \\sum _ { j = 1 } ^ { K } ( b - \\frac { 1 } { N } \\sum _ { i = 1 } ^ { N } \\log ( \\sigma _ { i , j } ) ) ^ { + } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            366,
+            568,
+            629,
+            613
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $i = 1 \\dots N$ indexes the training samples, and $j = 1 \\ldots K$ neurons in a layer (i.e., feature channels). This regularizer aims to make neurons very stochastic, to the point of compromising their reliability for computing a supervised learning task. Thus only those neurons that are most useful for the task get their entropy lowered and thus pay the regularization cost. Less useful neurons get their entropy maximized, allowing them to be detected and pruned after training. ",
+        "bbox": [
+            173,
+            614,
+            825,
+            685
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Label Noise Different from pruning, we aim to identify uncertain samples. Therefore, we aggregate entropy over neurons for each sample, and prefer high sample-wise entropy, leading to ",
+        "bbox": [
+            173,
+            694,
+            823,
+            723
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/279fc3c75b7d65f608e309ff1161e0c6f7a2ae109e09661dfd825825e97828d6.jpg",
+        "text": "$$\n\\Omega ( \\theta ) = \\frac { 1 } { N } \\sum _ { i = 1 } ^ { N } ( b - \\frac { 1 } { K } \\sum _ { j = 1 } ^ { K } \\log ( \\sigma _ { i , j } ) ) ^ { + } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            382,
+            726,
+            647,
+            770
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "With this regularizer, inlier samples pay the entropy cost in order to produce a clean feature for classification to satisfy the supervised learning loss. Outlier samples, caused by either label noise or being out-of-distribution, are anyway hard to classify; the regularizer naturally inflates their entropy since doing so does not impact the supervised learning loss. This high-variance representation in turn reduces their (negative) impact on network fitting. ",
+        "bbox": [
+            173,
+            772,
+            825,
+            843
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Adversarial Defense To defend against adversarial samples, we aim to inflate entropy over both the neuron- and sample-axes to produce a highly stochastic model: ",
+        "bbox": [
+            173,
+            852,
+            821,
+            881
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/45e78c4a98c1663faa2da318e2849716aab61c2cc0d57c5ae7d9fb303cd32e16.jpg",
+        "text": "$$\n\\Omega ( \\theta ) = \\frac { 1 } { N } \\frac { 1 } { K } \\sum _ { i = 1 } ^ { N } \\sum _ { j = 1 } ^ { K } ( b - \\log ( \\sigma _ { i , j } ) ) ^ { + }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            385,
+            882,
+            643,
+            928
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "This looks similar to VIB’s adversarial defense (Alemi et al., 2017), but with the vital difference that our entropy regularizer is not restricted to the $\\mathcal { N } ( 0 , 1 )$ prior used in VIB. It can be seen as learning a layer-wise data augmentation policy, which turns out to be very useful for adversarial defense in practice (see Sec. 4.2). ",
+        "bbox": [
+            174,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            207,
+            344,
+            223
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Connection to VIB and Sparse VD Though we derive the max-entropy regularizer from the perspective of a non-informative activation prior, our work is closely related to VIB (Alemi et al., 2017) and sparse variational dropout (VD) (Molchanov et al., 2017a), despite their different perspectives. Specifically, if we replace our infinite-variance Gaussian with a standard Gaussian, it becomes VIB (see Eq. 17 in (Alemi et al., 2017)). The max-entropy regularizer is also linked to Eq. 14 in Sparse VD (Molchanov et al., 2017a), which also encourages large variance/entropy (at a different rate). But again, Sparse VD (Molchanov et al., 2017a) is derived with a completely different motivation: It has an intuitive explanation that the regularizer corresponds to a sparsity prior on the weights. We note that enforcing uncertainty on activations rather than weights has a number of advantages: (i) The weight prior is intractable analytically, which leads to the fact that Sparse VD regularization is itself an approximation. (ii) Deriving the regularizer from a weight prior is unnecessarily complicated for the purpose of sparsifying the model compared to ours. In contrast, our approach sidesteps the need to sample weights and avoids keeping multiple copies of the network, which can potentially improve efficiency (e.g., in memory usage). ",
+        "bbox": [
+            174,
+            260,
+            825,
+            454
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note that stochastic layers have been used in several other works in order to achieve better classification or regression accuracy. Kingma et al. (2015) proposes a generalization of Gaussian dropout where the dropout rates are learned, leading to higher classification accuracy. Natural-parameter networks (NPN) (Wang et al., 2016) is a class of probabilistic neural networks where the input, target output, weights, and neurons can all be modeled by arbitrary exponential-family distributions (e.g., Poisson distributions for word counts) instead of being limited to Gaussian distributions, achieving state-of-the-art performance on classification, regression, and representation learning tasks. To reduce computational cost, Postels et al. (2019) approximates uncertainty estimates using a sampling-free approach and obtains better results on classification and regression tasks. ",
+        "bbox": [
+            174,
+            460,
+            825,
+            585
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Network Compression Network compression based on pruning typically uses heuristics based on pruning low-importance weights or low-activation neurons (Molchanov et al., 2017b; Wen et al., 2016), often assisted by sparsity-enhancing priors such as lasso (Wen et al., 2016). We avoid the complication of Bayesian learning of weights by proposing a simpler and direct activation prior that predisposes neurons towards deactivation unless necessary to solve the supervised task. ",
+        "bbox": [
+            174,
+            597,
+            825,
+            666
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Adversarial Defense Our method is related to existing randomization-based methods for adversarial defense (Liu et al., 2018; Xie et al., 2018; Alemi et al., 2017; Ye & Zhu, 2018; Liu et al., 2019). However unlike these studies which use a fixed distribution for noise (Liu et al., 2018; Alemi et al., 2017), a learned model distribution for effective randomization (Liu et al., 2019), image perturbations (Xie et al., 2018) or a learned adversarial data-generating distribution (Ye & Zhu, 2018), our randomization-based defense is both learned, and data-dependent since the variance at each layer is generated based on the output of the previous layer. ",
+        "bbox": [
+            173,
+            676,
+            825,
+            775
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Label Noise Robustness A number of existing label noise-robust deep learning approaches require a subset of noisy data to be reliably re-annotated (cleaned) to verify which samples contain noise (Lee et al., 2017; Jiang et al., 2018). In contrast, some others including SE-SNN do not rely on additional human noise annotation. These methods address label noise by either iterative label correction via bootstrapping (Reed et al., 2015), adding additional layers on top of a softmax classification layer to estimate the noise pattern (Sukhbaatar et al., 2015; Goldberger & Ben-Reuven, 2017), or loss correlation (Patrini et al., 2017). By allocating large uncertainty to outlying samples, SE-SNN can handle both label noise and out-of-distribution samples with correct labels. This approach to label noise robustness is appealingly simple in that it requires neither explicit detection of noisy samples, nor additional annotation. However label noise robustness has been largely ignored by existing SNNs. ",
+        "bbox": [
+            173,
+            785,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            326,
+            117
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Experiments are carried out to evaluate the efficacy of the proposed framework in three applications: neural network pruning, adversarial attack defense and learning with label noise. ",
+        "bbox": [
+            176,
+            133,
+            823,
+            161
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 NEURAL NETWORK PRUNING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            179,
+            421,
+            193
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Competitors We follow the architecture/dataset combinations used in most recent neural network pruning studies, including LeNet-5-Caffe1 network on MNIST (LeCun, 1998), VGG-16 (Simonyan & Zisserman, 2015) on CIFAR10 (Krizhevsky & Hinton, 2009) and a variant of VGG–16 on CIFAR100. Under these settings, the proposed method is compared with the following contemporary state-of-the-art methods including Generalized Dropout (GD) (Srinivas & Babu, 2016), Group Lasso (GL) (Wen et al., 2016), Sparse Variational Dropout (VD) (Molchanov et al., 2017a), Structured Bayesian Pruning (SBP) (Neklyudov et al., 2017), Bayesian Compression with Group Normal Jeffreys Prior (BC-GNJ) and Group Horseshoe Prior (BC-GHS) (Louizos et al., 2017), Sparse l0 Regularization (L0) and L0 with separate $\\lambda$ for each layer (L0-sep) (Louizos et al., 2018), Variational Information Bottleneck (VIBNet) (Dai et al., 2018), and Network Slimming (NS) (Liu et al., 2017). ",
+        "bbox": [
+            174,
+            208,
+            825,
+            348
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Evaluation Metrics Following the majority of the existing evaluations, we monitor the test error while focusing on the following three compression/complexity metrics: (a) Model size: The ratio of nonzero weights in the compressed network versus the original model. (b) FLOPs: The number of floating point operations required to predict a label from an input image during test2. (c) Run-time memory footprint: The ratio of the space for storing hidden feature maps during run-time in the pruned network versus the original network. ",
+        "bbox": [
+            174,
+            357,
+            825,
+            441
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Training While many existing studies remove redundant weights, we remove redundant neurons during compression. Therefore, we can use the pipeline proposed in Molchanov et al. (2017b). Specifically, after training the neural network, an initial batch pruning stage is followed by a loop of removing the least important neuron and fine-tuning. Since SE-SNN is designed to discount unimportant neurons through inflating their pre-activation variance, we find that the network achieves this by simultaneously assigning high-variance and negative mean. As a result, a large portion of redundant neurons never activate their RELU non-linearity. In the initial batch pruning stage, neuron inactivity thus provides a single-step pruning criterion before the iterative pruning begins (and one that is guaranteed not to affect the test accuracy since these neurons propagate no information). The pruning then enters the second stage where the least important neuron removal $^ +$ fine-tuning loop continues until reaching the target trade-off between accuracy and model compression objectives. Since one neuron/channel is removed at each iteration, the accuracy never drops sharply. We set the uncertainty loss/regularizer weighting factor and margin $b$ (Eq. 5) as 0.0001 and 4, respectively. ",
+        "bbox": [
+            174,
+            453,
+            825,
+            632
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Testing During testing, only the mean of the learned distribution is passed between layers. So there are no additional parameters and inference cost compared to the network’s deterministic counterpart. The distribution generation branches are only used during training to identify redundant neurons. ",
+        "bbox": [
+            174,
+            643,
+            825,
+            685
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Results on MNIST The most commonly used benchmark and architecture is MNIST with LeNet5-Caffe. We follow the standard training and testing protocols. The results are shown in Table 1. It is clear that SE-SNN achieves the best performance on FLOPs, run-time memory footprint, and test error. In terms of model size, our model is only comparable with the state of art. This is because it does not prune the linear layer as much as other methods. Instead, it focuses on pruning the convolutional filters, hence the excellent performance on FLOPS and memory footprint. ",
+        "bbox": [
+            174,
+            695,
+            825,
+            779
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Results on CIFAR10 For CIFAR10, several VGG16 variants and training protocols have been proposed in different works. We use the standard VGG16 architecture but change the dimension of linear layers from 4096 to 512, as in (Louizos et al., 2017; Dai et al., 2018). The results in Table 2 compare our method with (Louizos et al., 2017; Dai et al., 2018). The error rate for VIBNet in parentheses was obtained by further fine-tuning the pruned architecture. Our model achieves the best performance across all the evaluation metrics and error rates. ",
+        "bbox": [
+            174,
+            790,
+            825,
+            873
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/655e2edbc264f083d80735d6b43865e95b915eb2e932b61e410e81453281e821.jpg",
+        "table_caption": [
+            "Table 1: Compression results on MNIST using LeNet-5-Caffe. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Methods</td><td>Model size (%)</td><td>FLOPs (Mil)</td><td>Memory (%)</td><td>Error(%)</td></tr><tr><td>GD (Srinivas &amp; Babu,2016)</td><td>1.38</td><td>0.250</td><td>32.00</td><td>1.1</td></tr><tr><td>GL (Wen et al., 2016)</td><td>23.69</td><td>0.201</td><td>19.35</td><td>1.0</td></tr><tr><td>VD (Molchanov et al., 2017a)</td><td>9.29</td><td>0.660</td><td>60.78</td><td>1.0</td></tr><tr><td>SBP (Neklyudov et al., 2017)</td><td>19.66</td><td>0.213</td><td>21.15</td><td>0.9</td></tr><tr><td>BC-GNJ (Louizos et al., 2017)</td><td>0.95</td><td>0.283</td><td>35.03</td><td>1.0</td></tr><tr><td>BC-GHS (Louizos et al., 2017)</td><td>0.64</td><td>0.153</td><td>22.80</td><td>1.0</td></tr><tr><td>LO (Louizos et al., 2018)</td><td>8.92</td><td>1.113</td><td>85.82</td><td>0.9</td></tr><tr><td>LO-sep (Louizos et al., 2018)</td><td>1.08</td><td>0.389</td><td>40.36</td><td>1.0</td></tr><tr><td>VIBNet (Dai et al., 2018)</td><td>0.83</td><td>0.094</td><td>15.55</td><td>1.0</td></tr><tr><td>SE-SNN</td><td>2.35</td><td>0.061</td><td>11.08</td><td>0.9</td></tr></table>",
+        "bbox": [
+            178,
+            99,
+            816,
+            257
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/745fb58c60f14300632a7e9a73a4962d80f59888133b8c081edc0bcbab489c55.jpg",
+        "table_caption": [
+            "Table 2: Compression results on CIFAR10 using VGG16. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Methods</td><td>Model size (%)</td><td>FLOPs (Mil)</td><td>Memory (%)</td><td>Error (%)</td></tr><tr><td>BC-GNJ (Louizos et al., 2017)</td><td>6.57</td><td>141.50</td><td>81.68</td><td>8.6</td></tr><tr><td>BC-GHS (Louizos et al., 2017)</td><td>5.40</td><td>121.90</td><td>74.82</td><td>9.0</td></tr><tr><td>VIBNet (Dai et al.,2018)</td><td>5.30</td><td>70.63</td><td>49.57</td><td>8.8(8.5)</td></tr><tr><td>SE-SNN</td><td>2.57</td><td>53.61</td><td>49.41</td><td>8.0</td></tr></table>",
+        "bbox": [
+            179,
+            292,
+            815,
+            367
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Results on CIFAR100 We compare with the study in (Liu et al., 2017), which uses the same VGG16 variant that replaces two fully connected layers with three convolutional layers. This architecture improves accuracy at the expense of FLOPs and memory. The results in Table 3 show that our model produces the best compression result while maintaining comparable accuracy. Note that the $2 6 . 2 \\%$ error rate achieved by our model is identical to that of the original network. So if the accuracy drop is used as a compression metric, our model is as good as any competitor. ",
+        "bbox": [
+            174,
+            400,
+            825,
+            484
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 ADVERSARIAL DEFENSE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            507,
+            387,
+            521
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Experimental Setting Following Alemi et al. (2017), we focus on two types of adversarial attacks: Fast Gradient Sign (FGS) (Goodfellow et al., 2015) and an optimization-based attack – CW-L2 (Carlini & Wagner, 2017). We evaluate untargeted FGS attacks with attack magnitude $\\epsilon$ ranging from 0.0 to 0.5 and untargeted CW-L2 attack on models trained on MNIST. We use a popular architecture including three FC layers with 1024, 1024 and 256 output neurons respectively. The third FC layer is implemented as a stochastic layer. We set the uncertainty loss/regularizer weighting factor and margin as 0.1 and 16, respectively. Results averaged over 20 runs are reported. We compare against the original (undefended) network, termed as ‘Baseline’, Deep VIB (Alemi et al., 2017) using the variational information bottleneck, Bayesian Adversarial Learning (BAL) (Ye & Zhu, 2018) putting a distribution on the adversarial data-generating process and Adv-BNN (Liu et al., 2019) learning a BNN to incorporate the effective randomness and using adversarial training to seek the best model distribution. Since our model is stochastic, we follow the best practice recommended in (Athalye et al., 2018) for attacking stochastic models: We compute the expected gradient over multiple stochastic samples for each input when constructing attacks. This is because using the expected gradient over multiple posterior samples produces a better gradient estimator for the attacker, allowing it to generate samples that are much harder to defend against (Athalye et al., 2018). For the FGS attack, we evaluate two settings, namely normal training and adversarial training, the latter of which generates and uses FGS attack samples during training to increase adversarial robustness. ",
+        "bbox": [
+            174,
+            536,
+            826,
+            787
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Results From the comparative results shown in Figure 2a, we can see that our SE-SNN outperforms the competing defense methods over a range of FGS attack strengths when trained with adversarial attack samples (Figure $2 \\mathrm { a } ( \\mathrm { R } ) )$ or with only normal samples (Figure 2a(L)). The advantage of SE-SNN is particularly pronounced when the attack magnitude is large. We can also see from Figure 2b that under the stronger CW attacks the Baseline now fails completely. In this case SE-SNN provides the most effective defense. It is worth pointing out that, unlike BAL (Ye & Zhu, 2018), which learns their models with explicit adversarial sampling, our SE-SNN can also work with training with only normal samples - Figure 2a suggests that our SE-SNN beats BAL even without being trained with adversarial attack samples (comparing SE-SNN in Figure 2a(L) to BAL in Figure 2a(R)). ",
+        "bbox": [
+            174,
+            799,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/f9b9fb7eff4ff7260ecde3d5dcc8c92cec5a1c78ea22d58b68163e9111c36c97.jpg",
+        "table_caption": [
+            "Table 3: Compression results on CIFAR100 using a VGG16 variant. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Methods</td><td>Model size (%)</td><td>FLOPs (Mil)</td><td>Memory (%)</td><td>Error (%)</td></tr><tr><td>NS-Single (Liu et al., 2017)</td><td>24.90</td><td>250.50</td><td>1</td><td>26.5</td></tr><tr><td>NS-Best (Liu et al., 2017)</td><td>20.80</td><td>214.80</td><td>1</td><td>26.0</td></tr><tr><td>VIBNet (Dai et al., 2018)</td><td>15.08</td><td>203.10</td><td>73.80</td><td>25.9(25.7)</td></tr><tr><td>SE-SNN</td><td>14.93</td><td>181.31</td><td>70.16</td><td>26.2</td></tr></table>",
+        "bbox": [
+            186,
+            101,
+            808,
+            174
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/4e0db648e6cbb51b018d1fcb324b9df469c62eba7c8c388da09529c50da9fdb8.jpg",
+        "image_caption": [
+            "Figure 2: Adversarial defense accuracy (mean $^ +$ standard deviation) under untargeted FGS and CW attacks on MNIST. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            205,
+            823,
+            324
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 ROBUSTNESS AGAINST LABEL NOISE",
+        "text_level": 1,
+        "bbox": [
+            176,
+            377,
+            473,
+            392
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section, tasks including digit recognition and person re-identification (ReID) are considered. Compared to Digit recognition, ReID is much more challenging. Particularly, ReID is an instance recognition task, which aims to match people under disjoint camera views. Although the performance of state-of-the-art ReID models on public benchmarks approaches saturation, ReID with label noise remains an unsolved and under-studied problem. ",
+        "bbox": [
+            174,
+            405,
+            825,
+            476
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Datasets The label noise robustness of our SE-SNN is evaluated for digit recognition using MNIST and ReID using Market-1501 (Zheng et al., 2015) benchmark. Market1501 is collected by 6 cameras and contains 751 training identities (12,936 images) and 750 test identities (19,281 images). The test set is organized into a query set and a gallery set. Cumulative Matching Characteristics (CMC) ranks and mean Average Precision are used as the performance measure. ",
+        "bbox": [
+            174,
+            486,
+            825,
+            555
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Noise Generation We consider patterned label noise which is more common in practice. Specifically, for MNIST, one class label will be flipped to a different one at a strength $p$ . The flipping pattern is fixed for each run but varies across different runs following (Hendrycks et al., 2018). For Market-1501, we use the commonly used ResNet-50 (He et al., 2016) trained on the clean data to obtain the feature of each training sample and find the most visually similar samples using feature Euclidean distance. Then for randomly selected training samples, their identity labels are assigned to that of the most similar sample that has a different identity, imitating human annotation errors. ",
+        "bbox": [
+            174,
+            565,
+            825,
+            664
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Competitors Baseline: The main baseline is the original network without adding our stochastic layers. For a fair comparison, we add a parallel layer to the penultimate (feature) layer in the baseline to guarantee the two networks have the same number of parameters. The input of the added layer is the same as the feature layer, and its output is element-wise added along with the output of the feature layer to get the final feature, which is then fed to a fully connected layer for computing the classification loss. Bootstrap_hard and Bootstrap_soft (Reed et al., 2015): Both iteratively use the model-predicted labels to refine the original labels that are potentially corrupted by noise. They differ in whether the updated label is binary or continuous. Forward Correction (Patrini et al., 2017): This model predicts the label corruption matrix (capturing the label flipping pattern) by first training a classifier on the noisy labels followed by corruption matrix estimation using the resulting softmax probabilities. The estimated matrix is then employed to regularize the retraining of the model. For MNIST, we stick to the original setting, which uses the argmax at the 97th percentile of softmax probabilities for label noise detection. For the ReID experiment, we replace this with the argmax over all softmax probabilities for a given class following what Patrini et al. (2017) did on datasets of more classes such as CIFAR100. CleanNet (Lee et al., 2017): different from other models, this one requires a subset of noisy training samples to be re-annotated by a more reliable source (i.e., cleaned). It then learns the similarity between class and query-embedding vectors, which is further used to detect noisy samples for sample pruning. Having a cleaned subset gives CleanNet an unfair advantage over other compared models. The model requires at least 5 FC layers so cannot be implemented for the MNIST backbone. For person ReID, $10 \\%$ of the training set without noise is used as a clean reference set to train CleanNet using the author-provided code. After training, $20 \\%$ of the whole training set deemed most likely to be noisy are removed before the final ReID model is trained on the remainder. Note that unlike the four competitors, our SE-SNN does not have any additional steps to refine the label or prune the training samples. As explained earlier, it works by discounting/neutralizing the negative influence of noisy samples (hence also works on out-of-distribution samples with correct labels). Having said that, it can be easily combined with a label refinement procedure such as the corruption matrix based one in Forward Correction (Patrini et al., 2017). ",
+        "bbox": [
+            173,
+            674,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/6216d76c2639e3deccd582e6c00e11213c98d68b8fd0f0d0e000006fffe91fca.jpg",
+        "image_caption": [
+            "Figure 3: Label noise results on MINIST (a) and ablation study results on Market-1501 (b,c). In (c), the top row shows samples with the highest variance and bottom row those with the lowest when there is no label noise. The high variance uncertain samples correspond to poor detections and occlusions. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            101,
+            820,
+            219
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/815995a0b25ae2d25b2b777ede3d626a42c004da9953d06fdad9c55b3d99a3f4.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 4: Re-ID results on Market-1501 with label-noise. Model abbreviations: B: ResNet-Baseline, H: Bootstrap_hard (Reed et al., 2015), S: Bootstrap_soft (Reed et al., 2015), C: CleanNet (Lee et al., 2017), F: Forward Correction (Patrini et al., 2017). "
+        ],
+        "table_body": "<table><tr><td rowspan=\"2\">Strengths Models</td><td colspan=\"4\">10%</td><td colspan=\"4\">20%</td><td colspan=\"4\">50%</td></tr><tr><td>mAP</td><td>Rank1</td><td>Rank5</td><td>Rank10</td><td>mAP</td><td>Rank1</td><td>Rank5</td><td>Rank10</td><td>mAP</td><td>Rank1</td><td>Rank5</td><td>Rank10</td></tr><tr><td>B</td><td>25.87</td><td>51.46</td><td>70.21</td><td>76.81</td><td>23.49</td><td>48.44</td><td>67.85</td><td>74.67</td><td>20.74</td><td>44.04</td><td>64.32</td><td>72.27</td></tr><tr><td>H</td><td>25.76</td><td>51.08</td><td>70.11</td><td>77.06</td><td>23.40</td><td>48.25</td><td>67.34</td><td>74.40</td><td>19.87</td><td>42.87</td><td>63.37</td><td>71.40</td></tr><tr><td>S</td><td>25.50</td><td>50.47</td><td>69.43</td><td>76.32</td><td>24.08</td><td>49.51</td><td>68.77</td><td>75.62</td><td>20.72</td><td>43.86</td><td>64.49</td><td>72.55</td></tr><tr><td>C</td><td>26.64</td><td>52.47</td><td>70.90</td><td>77.41</td><td>24.28</td><td>49.54</td><td>68.35</td><td>75.33</td><td>19.90</td><td>43.01</td><td>63.13</td><td>71.34</td></tr><tr><td>F</td><td>21.17</td><td>45.88</td><td>64.79</td><td>71.69</td><td>18.91</td><td>42.11</td><td>62.12</td><td>69.99</td><td>15.34</td><td>36.06</td><td>56.23</td><td>64.55</td></tr><tr><td>SE-SNN</td><td>27.30</td><td>53.21</td><td>71.03</td><td>77.38</td><td>24.72</td><td>49.87</td><td>68.90</td><td>76.10</td><td>21.32</td><td>44.86</td><td>65.03</td><td>72.93</td></tr></table>",
+        "bbox": [
+            173,
+            286,
+            825,
+            377
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            462,
+            825,
+            601
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Results The results on MNIST are shown in Figure 3a. We can see that even without any label correction/refinement procedure, our SE-SNN is already very competitive – it is only beaten by Forward Correction when the corruption strength (percentage of samples with label noise) is large $( > 0 . 2 )$ . Once our SE-SNN is combined with the same procedure adopted by Forward Correction (SE-SNN $+$ Forward), we achieve the best result. On the more challenging ReID task in Market-1501 (Table 4), our SE-SNN also achieves the best overall performance - even beating CleanNet which needs an additional cleaned training subset. Note that the strongest competitor on MNIST, Forward Correction now is the weakest. This is because, as admitted in (Patrini et al., 2017), it struggles with estimating an accurate correction matrix given a small number of training samples per class (e.g., 500 per class in CIFAR100). The $< 2 0$ class size in Market-1501 means that the label correction procedure only has a detrimental effect. Figure 3b compares the average variance/uncertainty inferred for clean and noisy data in Market-1501. We can see that, indeed the variance of noisy data is larger than that of clean data on average. We also notice that even when there is no label noise, SE-SNN beats the baseline by a clear margin ( $7 0 . 2 0 \\%$ mAP vs. $6 7 . 6 6 \\%$ ). This suggests that the mechanism of neutralizing outlying samples is still in play when the labels are clean. To validate this, we show some examples of outliers (those with the largest variance) in Figure 3c when there is no label noise. It is clear that these are mostly caused by either poor person detection or occlusion (i.e., outliers). In contrast, images with the smallest variance mostly contain people detected perfectly and without occlusion – the model is thus most confident about the feature representations for these. ",
+        "bbox": [
+            173,
+            611,
+            825,
+            875
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "More SE-SNN implementation details for the label noise robust learning and more results can be found in the Appendix A. Further analyses across all tasks including hyperparameter analysis, solving multiple tasks in one model, effects of the number of stochastic layers are given in Appendix B. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            318,
+            118
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We proposed a simple and effective stochastic neural network framework. Our model is related to VIB and variational dropout, but provides a simpler and more direct realization via neuron regularization by a non-informative activation prior. Our extensive experiments show that this simple framework has diverse benefits for network pruning, adversarial defense and label noise robust learning. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            190
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            212,
+            287,
+            227
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alexander A Alemi, Ian Fischer, Joshua V Dillon, and Kevin Murphy. Deep variational information bottleneck. In ICLR, 2017. ",
+        "bbox": [
+            174,
+            234,
+            823,
+            263
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Anish Athalye, Nicholas Carlini, and David Wagner. Obfuscated gradients give a false sense of security: Circumventing defenses to adversarial examples. In ICML, 2018. ",
+        "bbox": [
+            174,
+            273,
+            823,
+            303
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Chris M. Bishop. Training with noise is equivalent to tikhonov regularization. Neural Computation, 7(1):108–116, 1995. ",
+        "bbox": [
+            173,
+            313,
+            823,
+            342
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Charles Blundell, Julien Cornebise, Koray Kavukcuoglu, and Daan Wierstra. Weight uncertainty in neural networks. In ICML, 2015. ",
+        "bbox": [
+            173,
+            352,
+            825,
+            381
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Nicholas Carlini and David Wagner. Towards evaluating the robustness of neural networks. In IEEESSP, 2017. ",
+        "bbox": [
+            173,
+            390,
+            825,
+            420
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Bin Dai, Chen Zhu, Baining Guo, and David Wipf. Compressing neural networks using the variational information bottleneck. In ICML, 2018. ",
+        "bbox": [
+            176,
+            429,
+            823,
+            459
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Gwendoline de Bie, Gabriel Peyré, and Marco Cuturi. Stochastic deep networks. In ICML, 2019. ",
+        "bbox": [
+            176,
+            468,
+            810,
+            484
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Charlie Frogner, Farzaneh Mirzazadeh, and Justin Solomon. Learning embeddings into entropic wasserstein spaces. In ICLR, 2019. ",
+        "bbox": [
+            173,
+            493,
+            820,
+            523
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yarin Gal and Zoubin Ghahramani. Dropout as a Bayesian approximation: Representing model uncertainty in deep learning. In ICML, 2016. ",
+        "bbox": [
+            176,
+            532,
+            820,
+            563
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Marta Garnelo, Dan Rosenbaum, Christopher Maddison, Tiago Ramalho, David Saxton, Murray Shanahan, Yee Whye Teh, Danilo Rezende, and S. M. Ali Eslami. Conditional neural processes. In ICML, 2018. ",
+        "bbox": [
+            174,
+            571,
+            825,
+            614
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jacob Goldberger and Ehud Ben-Reuven. Training deep neural-networks using a noise adaptation layer. In ICLR, 2017. ",
+        "bbox": [
+            171,
+            625,
+            823,
+            654
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. In ICLR, 2015. ",
+        "bbox": [
+            171,
+            662,
+            825,
+            693
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alex Graves. Practical variational inference for neural networks. In NIPS, 2011. ",
+        "bbox": [
+            171,
+            702,
+            702,
+            718
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Caglar Gulcehre, Marcin Moczulski, Misha Denil, and Yoshua Bengio. Noisy activation functions. In ICML, 2016. ",
+        "bbox": [
+            171,
+            727,
+            825,
+            757
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016. ",
+        "bbox": [
+            173,
+            766,
+            823,
+            796
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Dan Hendrycks, Mantas Mazeika, Duncan Wilson, and Kevin Gimpel. Using trusted data to train deep networks on labels corrupted by severe noise. In NIPS, 2018. ",
+        "bbox": [
+            173,
+            805,
+            823,
+            835
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Lu Jiang, Zhengyuan Zhou, Thomas Leung, Li-Jia Li, and Li Fei-Fei. Mentornet: Learning datadriven curriculum for very deep neural networks on corrupted labels. In ICML, 2018. ",
+        "bbox": [
+            173,
+            844,
+            823,
+            875
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In ICLR, 2015. ",
+        "bbox": [
+            171,
+            883,
+            808,
+            898
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Diederik P. Kingma and Max Welling. Auto-encoding variational bayes. In ICLR, 2014. ",
+        "bbox": [
+            171,
+            909,
+            753,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Durk P Kingma, Tim Salimans, and Max Welling. Variational dropout and the local reparameterization trick. In NIPS, 2015. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            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,
+            140,
+            823,
+            170
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun. The mnist database of handwritten digits. http://yann. lecun. com/exdb/mnist/, 1998. ",
+        "bbox": [
+            176,
+            178,
+            820,
+            195
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kuang-Huei Lee, Xiaodong He, Lei Zhang, and Linjun Yang. Cleannet: Transfer learning for scalable image classifier training with label noise. In ICCV, 2017. ",
+        "bbox": [
+            173,
+            202,
+            823,
+            232
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xuanqing Liu, Minhao Cheng, Huan Zhang, and Cho-Jui Hsieh. Towards robust neural networks via random self-ensemble. In ECCV, 2018. ",
+        "bbox": [
+            173,
+            239,
+            825,
+            270
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xuanqing Liu, Yao Li, Chongruo Wu, and Cho-Jui Hsieh. Adv-bnn: Improved adversarial defense through robust bayesian neural network. In ICLR, 2019. ",
+        "bbox": [
+            171,
+            277,
+            823,
+            308
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zhuang Liu, Jianguo Li, Zhiqiang Shen, Gao Huang, Shoumeng Yan, and Changshui Zhang. Learning efficient convolutional networks through network slimming. In ICCV, 2017. ",
+        "bbox": [
+            171,
+            315,
+            823,
+            345
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Christos Louizos, Karen Ullrich, and Max Welling. Bayesian compression for deep learning. In NIPS, 2017. ",
+        "bbox": [
+            176,
+            353,
+            823,
+            382
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Christos Louizos, Max Welling, and Diederik P Kingma. Learning sparse neural networks through l_0 regularization. In ICLR, 2018. ",
+        "bbox": [
+            171,
+            390,
+            823,
+            421
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dmitry Molchanov, Arsenii Ashukha, and Dmitry Vetrov. Variational dropout sparsifies deep neural networks. In ICML, 2017a. ",
+        "bbox": [
+            173,
+            428,
+            823,
+            458
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Pavlo Molchanov, Stephen Tyree, Tero Karras, Timo Aila, and Jan Kautz. Pruning convolutional neural networks for resource efficient inference. In ICLR, 2017b. ",
+        "bbox": [
+            171,
+            465,
+            825,
+            496
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Arvind Neelakantan, Luke Vilnis, Quoc V. Le, Lukasz Kaiser, Karol Kurach, Ilya Sutskever, and James Martens. Adding gradient noise improves learning for very deep networks. CoRR, abs/1511.06807, 2015. ",
+        "bbox": [
+            176,
+            503,
+            823,
+            547
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kirill Neklyudov, Dmitry Molchanov, Arsenii Ashukha, and Dmitry P Vetrov. Structured bayesian pruning via log-normal multiplicative noise. In NIPS, 2017. ",
+        "bbox": [
+            171,
+            555,
+            823,
+            585
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hyeonwoo Noh, Tackgeun You, Jonghwan Mun, and Bohyung Han. Regularizing deep neural networks by noise: Its interpretation and optimization. In NIPS, 2017. ",
+        "bbox": [
+            171,
+            593,
+            823,
+            623
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Giorgio Patrini, Alessandro Rozza, Aditya Krishna Menon, Richard Nock, and Lizhen Qu. Making deep neural networks robust to label noise: A loss correction approach. In CVPR, 2017. ",
+        "bbox": [
+            174,
+            631,
+            823,
+            660
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Janis Postels, Francesco Ferroni, Huseyin Coskun, Nassir Navab, and Federico Tombari. Samplingfree epistemic uncertainty estimation using approximated variance propagation. In ICCV, 2019. ",
+        "bbox": [
+            174,
+            667,
+            823,
+            699
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Scott E. Reed, Honglak Lee, Dragomir Anguelov, Christian Szegedy, Dumitru Erhan, and Andrew Rabinovich. Training deep neural networks on noisy labels with bootstrapping. In ICLR Workshop, 2015. ",
+        "bbox": [
+            173,
+            705,
+            826,
+            750
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hippolyt Ritter, Aleksandar Botev, and David Barber. A scalable laplace approximation for neural networks. In ICLR, 2018. ",
+        "bbox": [
+            173,
+            757,
+            823,
+            787
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. In ICLR, 2015. ",
+        "bbox": [
+            173,
+            795,
+            825,
+            825
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Suraj Srinivas and R Venkatesh Babu. Generalized dropout. CoRR, abs/1611.06791, 2016. ",
+        "bbox": [
+            169,
+            833,
+            769,
+            849
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: A simple way to prevent neural networks from overfitting. JMLR, 15:1929–1958, 2014. ",
+        "bbox": [
+            176,
+            857,
+            823,
+            887
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sainbayar Sukhbaatar, Joan Bruna, Manohar Paluri, Lubomir Bourdev, and Rob Fergus. Training convolutional networks with noisy labels. In ICLR, 2015. ",
+        "bbox": [
+            176,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/f1169214c5179021dc74711cb96fbd089c6ff0e7a07db9c61fad298ddef37fd0.jpg",
+        "table_caption": [
+            "Table A.1: Standard deviation value of Re-ID results on Market-1501 with label-noise. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Strengths</td><td colspan=\"4\">10%</td><td colspan=\"4\">20%</td><td colspan=\"4\">50%</td></tr><tr><td>Models</td><td>mAP</td><td>Rank1</td><td>Rank5</td><td>Rank10</td><td>mAP</td><td>Rank1</td><td>Rank5</td><td>Rank10</td><td>mAP</td><td>Rank1</td><td>Rank5</td><td>Rank10</td></tr><tr><td>B</td><td>0.41</td><td>0.83</td><td>0.75</td><td>0.98</td><td>0.56</td><td>0.82</td><td>0.74</td><td>0.62</td><td>1.25</td><td>2.04</td><td>1.48</td><td>1.56</td></tr><tr><td>H</td><td>0.60</td><td>0.76</td><td>1.34</td><td>1.12</td><td>0.70</td><td>0.97</td><td>0.57</td><td>0.77</td><td>0.93</td><td>1.82</td><td>1.55</td><td>0.97</td></tr><tr><td>S</td><td>0.78</td><td>0.93</td><td>0.85</td><td>0.95</td><td>0.82</td><td>1.48</td><td>1.45</td><td>1.38</td><td>0.51</td><td>1.11</td><td>0.85</td><td>0.61</td></tr><tr><td>C</td><td>0.83</td><td>1.45</td><td>0.98</td><td>0.90</td><td>0.44</td><td>0.53</td><td>0.96</td><td>0.58</td><td>1.08</td><td>1.68</td><td>1.85</td><td>1.66</td></tr><tr><td>F</td><td>1.03</td><td>1.64</td><td>1.98</td><td>1.53</td><td>0.82</td><td>1.50</td><td>1.12</td><td>0.86</td><td>0.56</td><td>1.48</td><td>1.63</td><td>1.97</td></tr><tr><td>SE-SNN</td><td>0.43</td><td>1.11</td><td>0.88</td><td>0.74</td><td>0.24</td><td>0.68</td><td>0.67</td><td>0.44</td><td>0.94</td><td>1.46</td><td>1.42</td><td>1.11</td></tr></table>",
+        "bbox": [
+            174,
+            101,
+            825,
+            193
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Naftali Tishby, Fernando C Pereira, and William Bialek. The information bottleneck method. In Allerton, 1999. ",
+        "bbox": [
+            171,
+            227,
+            825,
+            256
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Hao Wang, SHI Xingjian, and Dit-Yan Yeung. Natural-parameter networks: A class of probabilistic neural networks. In NIPS, 2016. ",
+        "bbox": [
+            173,
+            263,
+            823,
+            292
+        ],
+        "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": [
+            176,
+            301,
+            825,
+            329
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Cihang Xie, Jianyu Wang, Zhishuai Zhang, Zhou Ren, and Alan L. Yuille. Mitigating adversarial effects through randomization. In ICLR, 2018. ",
+        "bbox": [
+            176,
+            338,
+            823,
+            366
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nanyang Ye and Zhanxing Zhu. Bayesian adversarial learning. In NIPS, 2018. ",
+        "bbox": [
+            174,
+            375,
+            694,
+            390
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zhonghui You, Jinmian Ye, Kunming Li, and Ping Wang. Adversarial noise layer: Regularize neural network by adding noise. CoRR, abs/1805.08000, 2018. ",
+        "bbox": [
+            176,
+            397,
+            823,
+            426
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Liang Zheng, Liyue Shen, Lu Tian, Shengjin Wang, Jingdong Wang, and Qi Tian. Scalable person re-identification: A benchmark. In ICCV, 2015. ",
+        "bbox": [
+            176,
+            434,
+            823,
+            463
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A EXPERIMENTAL DETAILS OF LABEL NOISE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            487,
+            570,
+            503
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "For the experiments on MNIST, we follow (Patrini et al., 2017) to train a neural network with two FC layers of dimension 128, where both FC layers are implemented as stochastic layers. For Market-1501, following most recent state-of-the-art ReID models we use ResNet-50 (He et al., 2016) as the backbone. In this model, only the last unit of the final residual block is implemented as a stochastic layer. ",
+        "bbox": [
+            174,
+            518,
+            825,
+            588
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "For Market-1501, we train our model for two stages: (1) We fine-tune ImageNet pretrained ResNet-50 (for identity classification) on Market-1501 training set for 60, 000 iterations. We use batch size 32 and Adam optimizer (Kingma & Ba, 2015) with learning rate $3 . 5 \\times 1 0 ^ { - 4 }$ . (2) We retain the model parameters trained in stage (1) and extend the last unit to a stochastic layer with randomly initialized $\\sigma$ layer. Then, we train the stochastic layer and the classifier for another 20, 000 iterations with a lower learning rate $5 \\times 1 0 ^ { - 4 }$ . The margin $b$ is set as 4 in the max-entropy regularization loss (Eq. 6) and a loss weight $1 0 ^ { - 2 }$ is assigned. ",
+        "bbox": [
+            174,
+            595,
+            825,
+            693
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "For both benchmarks, due to the randomness of noisy samples in selection and label reassignment, multiple runs of experiments are conducted. The standard deviation values of Re-ID results on Market-1501 with label-noise are shown in Table A.1. ",
+        "bbox": [
+            174,
+            699,
+            825,
+            741
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "B FURTHER ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            761,
+            379,
+            777
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "B.1 HYPER-PARAMETERS ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            792,
+            441,
+            808
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "In this section, we analyze the impact of loss weight, which is denoted as $\\omega$ , and the margin $b$ for regularizers of all tasks on MNIST. We report the FLOPs of the compressed model (Network pruning), adversarial defense accuracy under the FGSM attack (Adversarial defense) and test accuracy of a model trained with $40 \\%$ label noise (Label noise) in Figure B.1. ",
+        "bbox": [
+            174,
+            818,
+            825,
+            875
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "In Figure B.1(top), we evaluate the effects of having different values of $\\omega$ from $[ 1 0 ^ { - 1 } , 1 0 ^ { - 2 } , 1 0 ^ { - 3 } ]$ . We can see that, for all three values and across the three tasks, the performance of our method is only marginally impacted by $\\omega$ and the overall best performance is achieved when $\\omega = 1 0 ^ { - 2 }$ . ",
+        "bbox": [
+            176,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/69c8feecd27f570b16ac7a611be0422a7581dd894cbc28c6ef71861ff9971777.jpg",
+        "image_caption": [
+            "Figure B.1: Impact analysis of loss weight $\\omega$ (top) and margin $b$ (bottom) on MNIST. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            99,
+            825,
+            349
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/028d8326137d39ac1891ff96be9dee83b9175deb4c795ae551b871da30c2fb6e.jpg",
+        "image_caption": [
+            "Figure B.2: Test accuracy of different methods trained on MNIST with label noise. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            388,
+            369,
+            474
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/640e1e2b7367e65565fdf284527e3c8ce681a6727157ab254bf1f5475ab1e94f.jpg",
+        "image_caption": [
+            "Figure B.3: Effect of the number of stochastic layers on MNIST with label noise. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            406,
+            387,
+            594,
+            474
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/5596edc72715a074b4f2443056bd4fabd64c4d21b7e94c9087f4af4d6a73d26e.jpg",
+        "image_caption": [
+            "Figure B.4: Convergence Curve on MNIST with label noise . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            627,
+            388,
+            815,
+            474
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "In Figure B.1(bottom), we investigate the sensitivity of our model to the values of margin $b$ . Three values, $[ \\log ( 1 ) , \\log ( 4 ) , \\log ( 1 6 ) ]$ are considered. Recall that our SE-SNN uses a non-informative prior to regularize the uncertainty of neuron activations, and a margin $b$ is employed to upper-bound the standard deviation of the stochastic layers in SE-SNN. Therefore, larger values of $b$ will lead to a higher degree of uncertainty of stochastic layers. From Figure B.1(bottom), we can see that increasing the value of $b$ improves the performance of our method on adversarial defense and label noise. However, for network pruning, smaller $b$ is preferred. Overall, our model is insensitive to the value of $b$ . ",
+        "bbox": [
+            174,
+            551,
+            825,
+            662
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B.2 COMBINATION OF NETWORK PRUNING AND LABEL NOISE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            681,
+            614,
+            694
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The effectiveness of our SE-SNN has been demonstrated on the three tasks separately, but there is no reason why it cannot be deployed to deal with multiple tasks simultaneously. To validate this, in this experiment, we train SE-SNN on MNIST with $40 \\%$ label noise while conducting model pruning. We use the same architecture with three FC layers (784-128-128-10) as the previous label noise experiments, and make the first two layers stochastic layers. We compare the trained model with two competitors, including the baseline model (without stochastic layers) and our normal SE-SNN (without pruning) both trained with label noise. ",
+        "bbox": [
+            174,
+            705,
+            825,
+            803
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "From the results in Figure B.2, we can see that we get a pruned SE-SNN (145-26-15-10) trained with label noise achieving $9 5 . 2 0 \\%$ test accuracy, which is even slightly better than our normal SE-SNN $( 9 5 . 1 7 \\% )$ and much better than the baseline $( 8 1 . 0 4 \\% )$ . ",
+        "bbox": [
+            176,
+            810,
+            825,
+            852
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B.3 EFFECT OF THE NUMBER OF STOCHASTIC LAYERS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            871,
+            562,
+            883
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "In this section, we study the effect of the number of used stochastic layers (SLs). The experiments are run on the label noise robust learning task with network comprising two FC layers. For the network ",
+        "bbox": [
+            174,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "with one SL, we make the penultimate layer stochastic. Note that the network with zero SL is the baseline. Figure B.3 shows the test accuracy of models with different numbers of SLs used. We can see that increasing the number of SLs helps improve the model’s robustness to label noise. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B.4 CONVERGENCE CURVE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            162,
+            377,
+            176
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The training efficiency of the proposed method is studied here by examining how fast the algorithm converges. The experiments are run on the label noise robust learning task. Figure B.4 shows the losses of different methods during 10 training epochs. It is observed that Bootstrap and Forward have larger loss values than the rest. This is because they use losses in addition to the classification loss. Overall our method is shown to be as efficient as other methods, despite the fact that we have introduced stochastic layers and used a reparameterization trick during training. ",
+        "bbox": [
+            174,
+            188,
+            825,
+            272
+        ],
+        "page_idx": 12
+    }
+]