Add files using upload-large-folder tool

parse/train/9DlCh34E1bN/9DlCh34E1bN.md

@@ -0,0 +1,296 @@
+# On the Expressivity of Markov Reward
+
+David Abel DeepMind dmabel@deepmind.com
+
+Will Dabney DeepMind wdabney@deepmind.com
+
+Anna Harutyunyan DeepMind harutyunyan@deepmind.com
+
+Mark K. Ho Department of Computer Science Princeton University mho@princeton.edu
+
+Michael L. Littman Department of Computer Science Brown University mlittman@cs.brown.edu
+
+Doina Precup DeepMind doinap@deepmind.com
+
+Satinder Singh DeepMind baveja@deepmind.com
+
+# Abstract
+
+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.
+
+# 1 Introduction
+
+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.
+
+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.
+
+![](images/e8e8abd164d3f79d4a7a8a028af7674de12a1b7ef923da00922c85226e319ab2.jpg)  
+Figure 1: Alice, Bob, and the artifacts of task definition (blue) and task expression (purple).
+
+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.
+
+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).
+
+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.
+
+# 2 Background
+
+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.
+
+# 2.1 Other Perspectives on Reward
+
+We here briefly summarize relevant literature that provides distinct perspectives on reward.
+
+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.
+
+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.
+
+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].
+
+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.
+
+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].
+
+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.
+
+# 3 An Account of Reward’s Expressivity: The TASKQ and EXPRESSIONQ
+
+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.
+
+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?
+
+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.
+
+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]).
+
+# 3.1 Answers to the TASKQ: What is a Task?
+
+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”.
+
+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).
+
+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.
+
+<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>
+
+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.
+
+# 3.2 SOAPs, POs, and TOs
+
+(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.
+
+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$ .
+
+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.
+
+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 }$
+
+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.
+
+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 ^ { * } \}$ .
+
+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.
+
+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.
+
+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.
+
+(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.
+
+Definition 3.3. A policy order $( P O )$ of the deterministic policies $\Pi$ is a partial order, denoted $L _ { \Pi }$
+
+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 }$ .
+
+(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.
+
+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.
+
+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.”
+
+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.
+
+# 4 Analysis: The Expressivity of Markov Reward
+
+With our definitions and objectives in place, we now present our main results.
+
+# 4.1 Express SOAPs, POs, and TOs
+
+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.
+
+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$ .
+
+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.
+
+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.
+
+![](images/7e2521434653bc359042031494792030a541697f55fdd0726f183527d25b6f71.jpg)  
+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.
+
+Next, we show that Theorem 4.1 is not limited to a particular choice of transition function or $\gamma$
+
+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 }$ .
+
+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.
+
+# 4.2 Constructive Algorithms: Task to Reward
+
+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.
+
+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)$ .
+
+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.
+
+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.
+
+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.
+
+Corollary 4.4. For any task $\mathcal { T }$ and environment $E$ , deciding whether $\mathcal { T }$ is expressible in $E$ is solvable in polynomial time.
+
+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.
+
+# Algorithm 1 SOAP Reward Design
+
+INPUT: $E = ( { \mathcal { S } } , A , T , \gamma , s _ { 0 } ) , \Pi _ { G }$ .   
+OUTPUT: $R$ , or $\perp$ .   
+1: Πfringe = compute_fringe $\left( \Pi _ { G } \right)$   
+2: for $\bar { \pi } _ { g , i } \in \Pi _ { G }$ do . Compute state-visitation distributions. 3: $\rho _ { g , i } =$ compute_exp_visit $( \pi _ { g , i } , E )$   
+4: for $\pi _ { f , i } \in \Pi _ { \mathrm { f r i n g e } }$ do   
+5: $\rho _ { f , i } =$ compute_exp_visit $( \pi _ { f , i } , E )$   
+6: $C _ { \mathrm { { e q } } } = \{ \}$ . Make Equality Constraints. 7: for $\pi _ { g , i } \in \Pi _ { G }$ do   
+8: $C _ { \mathrm { e q . } } \mathsf { a d d } ( \rho _ { g , 0 } ( s _ { 0 } ) \cdot X = \rho _ { g , i } ( s _ { 0 } ) \cdot X )$   
+9: $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   
+11: $\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}$   
+12: $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 } }$   
+14: else   
+return ⊥
+
+# 4.3 Other Aspects of Reward’s Expressivity
+
+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.
+
+Theorem 4.5. A variant of the REWARDDESIGN problem with finite reward outputs is NP-hard.
+
+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.
+
+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 }$ .
+
+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.
+
+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.
+
+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].
+
+# 5 Experiments
+
+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.
+
+![](images/5005b54dfa05ba36af75a15b9ecb041099a770578c98353866ee22a5d1d671a8.jpg)  
+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.
+
+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.
+
+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.
+
+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.
+
+![](images/5d021953e8f8f26210e83664393ef931c7293318456b15ff88a24ede527d7e3a.jpg)  
+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.
+
+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.
+
+# 6 Conclusion
+
+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.
+
+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.
+
+# Acknowledgments and Disclosure of Funding
+
+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.
+
+References   
+[1] Pieter Abbeel and Andrew Y. Ng. Apprenticeship learning via inverse reinforcement learning. In Proceedings of the International Conference on Machine learning, 2004.   
+[2] David Ackley and Michael L. Littman. Interactions between learning and evolution. Artificial Life II, 1992.   
+[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.   
+[4] Kareem Amin, Nan Jiang, and Satinder Singh. Repeated inverse reinforcement learning. In Advances in Neural Information Processing Systems, 2017.   
+[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.   
+[6] Brian Christian. The Alignment Problem: Machine Learning and Human Values, pages 130–131. Atlantic Books, 2021.   
+[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.   
+[8] Gerard Debreu. Representation of a preference ordering by a numerical function. Decision Processes, 3:159–165, 1954.   
+[9] Daniel Dewey. Reinforcement learning and the reward engineering principle. In Proceedings of the AAAI Spring Symposium Series, 2014.   
+[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.   
+[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.   
+[12] Karl J. Friston. The free-energy principle: a unified brain theory? Nature reviews neuroscience, 11(2):127–138, 2010.   
+[13] Karl J. Friston, Jean Daunizeau, and Stefan J. Kiebel. Reinforcement learning or active inference? PloS One, 4(7):e6421, 2009.   
+[14] Dylan Hadfield-Menell, Anca Dragan, Pieter Abbeel, and Stuart Russell. Cooperative inverse reinforcement learning. In Advances in Neural Information Processing Systems, 2016.   
+[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.   
+[16] Dylan Hadfield-Menell, Smitha Milli, Pieter Abbeel, Stuart Russell, and Anca Dragan. Inverse reward design. In Advances in Neural Information Processing Systems, 2017.   
+[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.   
+[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.   
+[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.
+
+[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.
+
+[21] Kishor Jothimurugan, Rajeev Alur, and Osbert Bastani. A composable specification language for reinforcement learning tasks. In Advances in Neural Information Processing Systems, 2020.
+
+[22] Narendra Karmarkar. A new polynomial-time algorithm for linear programming. In Proceedings of the Annual ACM Symposium on Theory of Computing, 1984.
+
+[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.
+
+[24] Tjalling C. Koopmans. Stationary ordinal utility and impatience. Econometrica: Journal of the Econometric Society, pages 287–309, 1960.
+
+[25] David Kreps. Notes on the Theory of Choice. Westview Press, 1988.
+
+[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.
+
+[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.
+
+[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.
+
+[29] Michael L. Littman. The reward hypothesis, 2017. URL https:// www.coursera.org/lecture/fundamentals-of-reinforcement-learning/ michael-littman-the-reward-hypothesis-q6x0e.
+
+[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.
+
+[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.
+
+[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.
+
+[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.
+
+[34] Maja J. Mataric. Reward functions for accelerated learning. In Proceedings of the International Conference on Machine Learning, 1994.
+
+[35] L. G. Mitten. Preference order dynamic programming. Management Science, 21(1):43–46, 1974.
+
+[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.
+
+[37] Andrew Y. Ng, Stuart J. Russell, et al. Algorithms for inverse reinforcement learning. In Proceedings of the International Conference on Machine Learning, 2000.
+
+[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.   
+[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.   
+[40] Silviu Pitis. Rethinking the discount factor in reinforcement learning: A decision theoretic approach. In Proceedings of the AAAI Conference on Artificial Intelligence, 2019.   
+[41] Martin L. Puterman. Markov Decision Processes: Discrete Stochastic Dynamic Programming. John Wiley & Sons, 2014.   
+[42] Stuart J. Russell and Peter Norvig. Artificial Intelligence: A Modern Approach. Prentice-Hall, Englewood Cliffs, NJ, 1994. ISBN 0-13-103805-2.   
+[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.   
+[44] David Silver, Satinder Singh, Doina Precup, and Richard S. Sutton. Reward is enough. Artificial Intelligence, page 103535, 2021.   
+[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.   
+[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.   
+[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.   
+[48] Matthew J. Sobel. Ordinal dynamic programming. Management science, 21(9):967–975, 1975.   
+[49] Matthew J. Sobel. Discounting axioms imply risk neutrality. Annals of Operations Research, 208(1):417–432, 2013.   
+[50] Jonathan Sorg. The Optimal Reward Problem: Designing Effective Reward for Bounded Agents. PhD thesis, University of Michigan, 2011.   
+[51] Jonathan Sorg, Richard L. Lewis, and Satinder Singh. Reward design via online gradient ascent. Advances in Neural Information Processing Systems, 2010.   
+[52] Peter Sunehag and Marcus Hutter. Axioms for rational reinforcement learning. In Proceedings of the International Conference on Algorithmic Learning Theory, 2011.   
+[53] Richard S. Sutton. The reward hypothesis, 2004. URL http://incompleteideas.net/ rlai.cs.ualberta.ca/RLAI/rewardhypothesis.html.   
+[54] Richard S. Sutton and Andrew G. Barto. Reinforcement Learning: An Introduction. MIT Press, 2018.   
+[55] Umar Syed, Michael Bowling, and Robert E. Schapire. Apprenticeship learning using linear programming. In Proceedings of the International Conference on Machine Learning, 2008.   
+[56] Csaba Szepesvári. Constrained MDPs and the reward hypothesis, 2020. URL http:// readingsml.blogspot.com/2020/03/constrained-mdps-and-reward-hypothesis. html.   
+[57] Geraud Nangue Tasse, Steven James, and Benjamin Rosman. A Boolean task algebra for reinforcement learning. In Advances in Neural Information Processing Systems, 2020.   
+[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.   
+[59] John von Neumann and Oskar Morgenstern. Theory of Games and Economic Behavior. Princeton University Press, 1953.   
+[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.   
+[61] Martha White. Unifying task specification in reinforcement learning. In Proceedings of the International Conference on Machine Learning, 2017.   
+[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.   
+[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.   
+[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.   
+[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.   
+[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.

parse/train/EQbyD_KG6w-1h/EQbyD_KG6w-1h.md

@@ -0,0 +1,258 @@
+# Self-Supervised Bug Detection and Repair
+
+Miltiadis Allamanis, Henry Jackson-Flux∗, Marc Brockschmidt Microsoft Research, Cambridge, UK {miallama, mabrocks}@microsoft.com
+
+# Abstract
+
+Machine learning-based program analyses have recently shown the promise of integrating formal and probabilistic reasoning towards aiding software development. However, in the absence of large annotated corpora, training these analyses is challenging. Towards addressing this, we present BUGLAB, an approach for selfsupervised learning of bug detection and repair. BUGLAB co-trains two models: (1) a detector model that learns to detect and repair bugs in code, (2) a selector model that learns to create buggy code for the detector to use as training data. A Python implementation of BUGLAB improves by up to $30 \%$ upon baseline methods on a test dataset of 2374 real-life bugs and finds 19 previously unknown bugs in open-source software.
+
+# 1 Introduction
+
+Detecting and repairing bugs in source code requires strong reasoning skills over formal structures (e.g. data and control flow) and ambiguous information (e.g. identifier names, coding idioms, and comments). Traditional program analyses are able to detect critical bugs through formal reasoning and combinatorial search, but need to be manually coded by experts. That is a lengthy and costly process, which misses the opportunity to use ambiguous information pervasive within code.
+
+Towards broadening the applicability of such methods, and utilizing ambiguous information, deep learning-based bug detection methods are being investigated [22, 3, 13]. These methods have the potential to further improve the engineering of software we rely on every day. However, many challenges in the area remain open, such as creating robust bug detection and repair methods that cover a wide range of common bugs in the absence of large supervised training corpora. Existing work focuses on randomly inserted bugs [22, 13], Cloze test proxy tasks [3], corpora of small code edits that may contain bugs [9] or build errors [28]. All these approaches rely on datasets of very limited size or ones known not to be representative of the characteristics of bugs found in real code.
+
+In this work, we propose BUGLAB, a self-supervised approach that trains robust bug detectors by co-training a bug selector that learns to create hard-to-detect bugs (Sec. 2). For example, for a given code snippet with two well-named variables, a variable misuse bug may be easy to detect and repair, whereas an incorrect comparison operator might be significantly harder to identify. We propose a neural architecture for BUGLAB (Sec. 3) and implement it for Python (Sec. 4). Our implementation considers four broad classes of seemingly simple, yet hard-to-detect bugs and shows improved performance over training with randomly-inserted bugs on PYPIBUGS, a new, manually curated test set of 2374 real-life bugs (Sec. 5). Furthermore, we tested our trained models on popular open-source Python packages and identified 19 previously unreported bugs, though false positive rates of $\sim 9 8 \%$ remain impractical. We hope that creating machine learning methods that can detect these bugs early and assist developers will speed up software development and allow engineers to deliver more robust software. We release PyPIBugs and our code at https://github.com/ microsoft/neurips21-self-supervised-bug-detection-and-repair.
+
+# 2 Self-Supervised Bug Detection
+
+In this section, we first introduce the concept of code rewriting, and then use it to define BUGLAB as a framework for self-supervised learning of bug detection and repair.
+
+Code Rewriting Rewriting is common within compilers and their optimizations, test-driven searchbased bug repair tools, mutation testing, and refactoring tools. Rewrites can be semantics-preserving (e.g. renamings of local variables), or semantics-altering (e.g. replacing $> = \log ~ ! = )$ .
+
+Let $s$ denote the set of all syntax trees (not necessarily rooted in the start symbol of the language grammar). Syntax tree locations $\ell \in \{ \epsilon \} \cup \mathbb { N } ^ { * }$ in a syntax tree $\mathrm { s } \in { \mathcal { S } }$ are recursively defined, where $\mathrm { s } _ { \vert \epsilon } = \mathrm { s }$ and $\mathrm { s } _ { | \ell }$ for $\ell = \ell ^ { \prime } \circ i$ is the $i$ -th child of $\mathrm { s } _ { \vert \ell ^ { \prime } }$ (i.e. s|(2,3) denotes the third child of the second child of s). We define a rewrite rule $\rho = ( \mathrm { m } _ { \rho } , \mathrm { t } _ { \rho } )$ as a pair of a matching function $\operatorname { m } _ { \rho } : S  \{ t r u e , f a l s e \}$ and a transformation function $\mathrm { t } _ { \rho } : { \mathcal { S } }  { \mathcal { S } }$ . The matching function $\mathrm { m } _ { \rho } ( \mathrm { s } )$ yields true iff the rule $\rho$ is applicable at the root of a subtree s. The transformation function can be applied to obtain a transformed syntax tree. For convenience, we define $\mathrm { t } _ { \rho } ( \mathrm { s } ) = \mathrm { s }$ iff $\mathrm { m } _ { \rho } ( \mathrm { s } ) = f a l s e$ . We then write $\rho ( \mathrm { s } )$ to indicate the modification of a syntax tree s using $\rho$ when possible, and otherwise the identity function. For reversible rewrite rules $\rho$ , we denote the inverse rule as $\rho ^ { - 1 }$ such that $\rho ^ { - 1 } ( \rho ( \mathrm { s } ) ) = \mathbf { \dot { s } }$ holds. We discuss concrete rewrite rules $\rho$ in Sec. 4.
+
+Given a set of rewrite rules $\mathcal { R }$ we define the set of “potential rewrites” in a syntax tree s as $R _ { \mathrm { s } } ^ { \mathcal { R } } =$ $\{ \langle \ell , \rho \rangle \mid \rho \in { \mathcal { R } } , \ell$ location in s, $, \mathbf { m } _ { \rho } ( \mathbf { s } _ { | \ell } ) = t r u e \}$ . For each tuple $\langle \ell , \rho \rangle \in R _ { \mathrm { s } } ^ { \mathcal { R } }$ , we use $\mathrm { s } ^ { \prime } = \mathrm { s } [ \rho ] \varrho$ to denote the new syntax tree obtained by applying $\rho$ at location $\ell$ of s. In BUGLAB, we train models that use rewrites from $R _ { \mathrm { s } } ^ { \mathcal { R } }$ to insert and repair bugs. We will discuss such neural models in Sec. 3.
+
+BUGLAB In BUGLAB, we are interested in selfsupervised training of a robust bug detector model $D _ { \theta }$ with parameters $\theta$ on an unannotated codebase $C$ . Let $\mathcal { R }$ be a set of rewrite rules2 that allows to insert and repair bugs. We train $D _ { \theta }$ to be able to recognize the “hardest” possible rewrites that could be applied on our codebase $C$ For this, we consider the loss $\mathcal { L } _ { D _ { \theta } }$ of $D _ { \theta }$ on a rewritten code snippet $\mathrm { s } [ \rho ] _ { \ell }$ , for which the model needs to predict the repairing rewrite $\langle \ell , \rho ^ { - 1 } \rangle$ . Formally, we want to minimize the objective
+
+$$
+E _ { \mathrm { s } \sim C } \left[ \operatorname* { m a x } _ { \langle \ell , \rho \rangle \in R _ { \mathrm { s } } ^ { \mathcal { R } } } \mathcal { L } _ { D _ { \theta } } \left( \mathrm { s } [ \rho ] _ { \ell } , \left. \ell , \rho ^ { - 1 } \right. \right) \right] .
+$$
+
+![](images/6a90afa1a44c13ced3e725f045bc326e6741157b1e8e404cd0b3127444e41f05.jpg)  
+Figure 1: BUGLAB overview: a selector model $S _ { \phi }$ decides which (bugintroducing) rewrite to apply to an input code snippet. Then a bug detector $D _ { \theta }$ tries to locate and repair the inserted bug (if one was inserted).
+
+However, for any useful detector the set of rewrites $R _ { \mathrm { s } } ^ { \mathcal { R } }$ is commonly very large or unbounded and computing the maximum over all $\langle \bar { \ell , } \rho \rangle \in R _ { \mathrm { s } } ^ { \mathcal { R } }$ is practically intractable. To address this, BUGLAB introduces a bug selector model $S _ { \phi }$ (with parameters $\phi _ { , }$ ), whose goal is to approximate the intractable $\mathrm { m a x } _ { \langle \ell , \rho \rangle \in R _ { \mathrm { s } } ^ { \mathcal { R } } } \mathcal { L } _ { D _ { \theta } } \left( \cdot \right)$ . We can then sample rewrites from $S _ { \phi }$ instead of computing the maximum. We denote this as $\langle \ell , \rho \rangle \sim S _ { \phi } ( s )$ and the overall BUGLAB training objective can be written as a min-max optimization problem:
+
+$$
+\operatorname* { m a x } _ { \phi } \operatorname* { m i n } _ { \theta } E _ { \mathrm { s } \sim C } \left[ E _ { \langle \ell , \rho \rangle \sim S _ { \phi } ( \mathrm { s } ) } \left[ \mathcal { L } _ { D _ { \theta } } \left( \mathrm { s } [ \rho ] _ { \ell } , \langle \ell , \rho ^ { - 1 } \rangle \right) \right] \right] .
+$$
+
+The two models $S$ and $D$ in BUGLAB are “symmetric” in the sense that they both predict rewrites on code snippets, and only differ in their objectives — one aiming to introduce bugs and one aiming to repair them. In practice, we can and do use the same architecture to model both $S$ and $D$ , which we will discuss in the next section. At test time, we discard $S$ and only use the trained detector $D$ to locate and repair bugs.
+
+# 3 Neural Models
+
+In this section, we discuss how we represent code in BUGLAB and the neural models we use to learn how to rewrite code in the selector and detector models.
+
+Code Representation We consider source code as a set of entities $v _ { i } ~ \in ~ V$ which relate to each other with a set of typed relations $e _ { k } \in E$ , where a relation $e _ { k } = ( v _ { i } , r , v _ { j } )$ denotes a relationship between entities $v _ { i }$ and $v _ { j }$ with type $r$ . The entities and relations can be thought as a heterogeneous graph $G = ( V , E )$ . The choice of code entities and their relationships is a form of high-level feature extraction. We discuss concrete entities and relationships for Python in Sec. 4. We also define a projection function $\mathbb { P } _ { t o k }$ that accepts $V$ and $E$ and returns a sequence $V _ { t o k }$ of the token entities in $V$ with the nodes appearing in relations in $E$ deterministically mapped to elements of $V _ { t o k }$ , i.e. $E _ { t o k } = \{ ( p ( v _ { i } ) , r , p ( \hat { v _ { j } } ) ) \}$ , where $p$ maps the entities in $V$ to $V _ { t o k } . \mathbb { P } _ { t o k }$ will be used for relational transformer models.
+
+To learn a neural representation of the code entities $v _ { i }$ , first we define an embedding function $e ( v _ { i } )$ which maps the content of each entity to an initial $D$ -dimensional representation. Throughout this work — similar to Allamanis et al. [4] and other previous work — we deterministically split the string representation of each node into subtokens (e.g., fooBar is split into foo and bar), embed them through a learned embedding matrix, and use max pooling to get a single vector. We then “contextualize” the entity representations within $G$ using one of two models: a MLP-based GNN model with max message aggregation and the GREAT relational transformer of Hellendoorn et al. [13] over the token sequence and relations $V _ { t o k } , E _ { t o k } = \mathbb { P } _ { t o k } ( V , E )$ . GREAT uses both positional encodings and the projected relations in $E _ { t o k }$ . See Appx. A for detailed architecture descriptions. Other models to compute entity representations can be used, but were not explored in this work.
+
+We use $\mathbfit { \Delta } \mathbf { r } _ { \ell }$ to denote the computed vector representation of the entity at location $\ell$ , independent of the model used to produce it. We use these representations to define our code rewriting models.
+
+Probabilistic Code Rewriting Models Both bug selection and bug detection require to model the probability of applying a specific rewrite at a location in a code snippet s, either to introduce or repair a bug. For this, we factorize this task into localization and rewrite-given-location models, i.e.
+
+$$
+p \left( \langle \ell , \rho \rangle \mid \mathrm { s } , R _ { \mathrm { s } } ^ { \mathcal { R } } \right) = p _ { l o c } { \big ( } \ell \mid \mathrm { s } , R _ { \mathrm { s } } ^ { \mathcal { R } } { \big ) } p _ { r e w } { \big ( } \rho \mid \ell , \mathrm { s } , R _ { \mathrm { s } } ^ { \mathcal { R } } { \big ) } .
+$$
+
+We model $p _ { l o c }$ as a probability distribution over the relevant locations $\{ \ell \mid \langle \ell , \rho \rangle \in R _ { \mathrm { s } } ^ { \mathcal { R } } \} \cup \{ \mathrm { N o B U G } \}$ , where NoBug is a special location used to indicate that the code is not buggy. In practice, we implement this similar to a pointer net [19] using the representations $\mathbfit { \Delta } \mathbf { r } _ { \ell }$ (see Appx. A for details).
+
+To select rewrites, we use rewrite type-specific learnable rule score functions $w _ { \rho } \left( r _ { \ell } , \mathcal { M } _ { \rho } ( \mathrm { s } , \ell ) \right)$ . This function maps a vector representation of an entity $\mathbf { \Delta } _ { \mathbf { \lambda } ^ { \mathbf { r } } \ell }$ and potential additional metadata onto a scalar score. The rule-specific metadata $\mathcal { M } _ { \rho } ( \mathrm { s } , \ell )$ is defined for some rewrites, e.g. containing representations of other entities that could be used in the location $\ell$ . We will discuss three concrete rule score functions in Sec. 4. The rewrite probability distribution $p _ { r e w }$ is then modeled by a softmax over the scores of all applicable rewrites at a target location $\ell$ , i.e.
+
+$$
+p _ { r e w } \left( \rho \mid \ell , \mathbf { s } , R _ { \mathbf { s } } ^ { \mathcal { R } } \right) = \operatorname * { s o f t m a x } _ { \langle \ell , \rho ^ { \prime } \rangle \in R _ { \mathbf { s } } ^ { \mathcal { R } } } \left( w _ { \rho ^ { \prime } } \left( r _ { \ell } , \mathcal { M } _ { \rho ^ { \prime } } ( \mathbf { s } , \ell ) \right) \right) .
+$$
+
+# 4 A Python Implementation
+
+This section presents an implementation of BUGLAB for Python called PYBUGLAB. PYBUGLAB currently tackles a large subset of “stupid simple bugs” [16]. Fixing these bugs requires small changes to the code, but commonly has significant impact on code correctness. Such bugs may be thought as a form of a typographical mistake or a copy-paste error, and are often relatively hard to locate by humans but obvious after the fact. They are also quite common, as observed in the empirical statistics of Karampatsis and Sutton [16] and Just et al. [14]. Future work may focus on a broader set of rewrite rules or even learnable rewrites, but as we will observe in Sec. 5 more work is needed towards this. Almost all ideas in PYBUGLAB transfer straightforwardly to other programming languages other than Python, but would require some engineering effort to implement.
+
+PYBUGLAB Code Entities and Relations In this work, we follow related literature (see Sec. 6 for more) and extract entities and relationships that are readily available by tokenizers, parsers, existing simple program analyses, or other Python-specific program analysis tools. The complete list of entities and relationships can be found in Appx. B and include syntactic entities and relations, relations about the intraprocedural data and control flow, types, and documentation. Some notable entities include SyntaxNodes, Tokens, and Symbols (references to variables and functions). Fig. 4 in Appx. B shows a graph of the entities and relationships of the snippet in Fig. 2.
+
+![](images/6fa04aa00a25535c0128e4a64746beb8ef02776ba155a61e8b37f97000e3c308.jpg)  
+Figure 2: Code snippet and rewrites available to PYBUGLAB.
+
+# 4.1 Bug-Inducing PYBUGLAB Rewrite Rules
+
+PYBUGLAB focuses on four common kinds of bugs. Fig. 2 shows a code snippet and the rewrites allowed for each location, which number 63 even for this small example.
+
+Variable Misuse Originally defined by Allamanis et al. [3] as a Cloze test for source code, Vasic et al. [30] and Hellendoorn et al. [13] reformulated the task to localizing a variable misuse bug (if any) within a snippet and repairing it. PYBUGLAB uses the latter representation. Variable misuse bugs are common, with $1 2 . 8 \AA - 1 4 . 8 \%$ found in the ManySStuBs4J corpus [16] and about $6 \%$ of them caught during Java compilation in the Google build system [28]. To insert and repair variable misuse bugs, PYBUGLAB supports variable-swapping rewrites, such as in locations $l _ { 1 }$ , $l _ { 3 }$ and $l _ { 4 }$ (amongst others) in Fig. 2. To score a variable-swapping rewrite, we use the representation of the rewrite location $\mathbfit { \Delta } \mathbf { r } _ { \ell }$ along with the representation $\mathbf { \Delta } _ { r _ { \sigma } }$ of a variable Symbol $\sigma$ that could replace the current variable, i.e. is in-scope and has been defined before $\ell$ . The rule score function $w _ { \rho }$ for replacing the variable at $\ell$ with the symbol $\sigma$ is then computed as the inner product $\boldsymbol { r } _ { \ell } ^ { \top } \boldsymbol { r } _ { \sigma }$ .
+
+Argument Swapping (or Argument Selection) First coined by Rice et al. [26], it refers to swapping the arguments of a function invocation, e.g. in $l _ { 6 }$ of Fig. 2. Rice et al. [26] and DeepBugs [22] tackled this problem when all arguments are single identifiers. PYBUGLAB extends this to swapping arbitrary argument expressions. The rule score function $w _ { \rho }$ for an argument swapping rewrite is a two-layer MLP applied to the concatenation of the output representations of the representation of the parameter and the to-be-swapped arguments arg1, and arg2: MLP $\left( [ r _ { \mathrm { p a r a m s } } , r _ { \mathrm { a r g 1 } } , r _ { \mathrm { a r g 2 } } ] \right)$ .
+
+Wrong Operator Corrupting operators has a long history in mutation testing [14]. Detecting incorrect operators with deep learning was first tackled by DeepBugs [22] by using learnable embeddings of operators, operands and literals for arithmetic and comparison operators. DeepBugs focused only on binary operators. In PYBUGLAB we tackle all binary operators, including Boolean, arithmetic and comparison operators and two unary operators: logical and arithmetic negation. Locations $l _ { 1 1 }$ , $l _ { 1 4 }$ , $l _ { 1 6 }$ , and $l _ { 2 0 }$ in Fig. 2 are rewrites related to wrong operators. The rule score function $w _ { \rho }$ for an operator rewrite again uses an inner product, $\boldsymbol { r } _ { \ell } ^ { \top } \boldsymbol { r } _ { \mathtt { \diamond p } }$ , where $\pmb { r } _ { \tt o p }$ is a learned embedding for operator op. Note that we rewrite operators only to compatible operators (e.g. $<$ to $>$ but not $^ +$ ).
+
+Wrong Literal Corrupting operands, and specifically, literals appearing in the source code, is also a common strategy in mutation testing. As in mutation testing, PYBUGLAB handles a limited number of commonly used literals, allowing rewrites to replace integer literals within the set of $- 2 , - 1 , 0 , 1 , 2$ and swapping the Boolean literal True with False and vice versa. The scoring function is identical to the operator rewrite, using a learnable embedding ${ \bf { r } } _ { \mathrm { { 1 i t } } }$ for each literal lit.
+
+# 4.2 PYBUGLAB Rewrite Rules for Data Augmentation
+
+We additionally consider more rewrite rules that are not meant to change the program semantics, using them as a form of data augmentation. This is in spirit similar to ideas in computer vision where images are transformed (e.g. rotated, cropped) but maintain their original content. Such rewrites
+
+Require: Code dataset $C$ , initial detector/selector model parameters $\theta ^ { ( 0 ) }$ , $\phi ^ { ( 0 ) }$
+
+1: for meta-epoch $i = 0$ to $I$ do   
+2: // Create dataset of buggy programs:   
+3: $C _ { D } ^ { ( i ) } \gets \left\{ \left( \mathrm { s } [ \rho ] _ { \ell } , \left. \ell , \rho ^ { - 1 } \right. \right) \mid \mathrm { s } \in C , k \mathrm { \ s a m p l e s \ } \left. \ell , \rho \right. \sim S _ { \phi ^ { ( i ) } } ( \mathrm { s } ) \right\}$   
+4: $\theta ^ { ( i + 1 ) } $ update $\theta ^ { ( i ) }$ by training $D$ on $C _ { D } ^ { ( i ) }$   
+5: // Create dataset of hard-to-detect bugs:   
+6: $\begin{array} { r } { C _ { S } ^ { ( i ) } \gets \left\{ \left( \mathrm { s } , \mathrm { a r g } \operatorname* { m a x } _ { \langle \ell , \rho \rangle \in R _ { \mathrm { s } } ^ { \mathcal { R } } } \left( \mathcal { L } _ { D _ { \theta ^ { ( i + 1 ) } } } \left( \mathrm { s } [ \rho ] _ { \ell } , \langle \ell , \rho ^ { - 1 } \rangle \right) \right) \right) \mid \mathrm { s } \in C \right\} } \end{array}$   
+7: $\phi ^ { ( i + 1 ) } $ update $\phi ^ { ( i ) }$ by training $S$ on $C _ { S } ^ { ( i ) }$
+
+have been shown to yield adversarially robust models of code [23]. Although our goal is not to provide adversarial robustness, we believe that such rewrites can help generalization. PYBUGLAB implements the following rewrites for this purpose:
+
+• Variable Renaming renames a local variable to a random name not already in scope. • Comment Deletion removes code comments, including docstrings and inline comments. Such comments commonly contain natural language information that is useful for code comprehension, but usually do not affect program semantics. • Comparison Expression Mirroring swaps the two sides of a comparison operator and changes it appropriately. For example, $\mathtt { a } < \mathtt { b }$ is transformed to $\mathtt { b } > \mathtt { a }$ . Note that in cases such as $\mathbf { f } \circ \circ ( ) \ < \ \mathsf { b a r } ( )$ , this will change the order of execution of foo and bar, possibly altering program semantics. • If-Else Branch Swapping negates the test condition of an if-else statement or a ternary expressions using DeMorgan’s law and swaps the then body with the else body.
+
+# 4.3 Implementation Details
+
+To make the training computationally tractable we approximate Eq. 1. A simplified, sequential version of our training procedure is shown in Alg. 1. Intuitively, we alternate between training the two models, as the (discrete) sampling of rewrite rules in the selector models precludes direct endto-end training. We first use the current state of the selector model to generate “hard” samples and train the detector model on these samples (we always include the unmodified (i.e., NoBug case) as a sample). Then, we use the loss of the detector model to identify those generated samples that were hardest to detect and train the selector model to produce such samples.
+
+In practice, we implemented the training procedure as a system of asynchronously communi$C _ { D / S } ^ { ( 0 ) } , \bar { C } _ { D / S } ^ { ( 1 ) } , \dots$ , and all of the described steps happen in parallel. We do not use “generations”of datasets, but instead use two constantly updated “pools” of training data, one state of the corresponding data pool. We remove samples from the data pool once they have been sampled $\nu$ times for use in training, in spirit similar to replay buffers in reinforcement learning. In our experiments, $\nu$ was set to 4. We regularly (in separate, concurrent processes) take snapshots of the the current state of the $D$ and $S$ models to generate new elements that are updated to the data pools, matching the procedure described in Alg. 1. We approximate the arg max in line 6 by only considering the $k$ samples chosen in line 3 for each input program. During training of $S$ , we then mask out the unobserved choices before computing the loss.
+
+# 5 Evaluation
+
+We now discuss our new dataset and evaluate PYBUGLAB. We $\divideontimes$ . . . . . . . . . .highlight. . . . .key . . . . . . . .results.
+
+Datasets To train PYBUGLAB we retrieve the 4k most downloaded packages in the Python package index (PyPI) and take $3 . 4 \mathrm { k }$ of them as training packages, using the rest for test purposes. During training, PYBUGLAB installs each package along with all its dependencies. Installing all the dependencies is important for extracting the entities and the relations beyond local syntactic ones (e.g. type inference, method resolution). For each file, PYBUGLAB checks if it is a duplicate of a file that has already been seen in the training following the method of Allamanis [1] and runs all the relevant program analyses to extract the entities and relationships in each function. When we use additional rewrites for data augmentation, these are applied at the input of the PYBUGLAB pipeline as a form of pre-processing. Following Alg. 1, the bug selector $S$ selects $k = 5$ bugs to introduce, rewrites the source code text, and then the program analyses extract the new entities and relationships for the rewritten code snippets. The initial and rewritten code snippets are then used to create the training data for the detector and selector models.
+
+We use two testsets to measure performance. First, we create RANDOMBUGS, a testset of 761 445 snippets derived from functions from the $6 0 0 \mathrm { P y P I }$ test packages (not seen during training). For each function we find within these packages we add it to the dataset along with 9 rewritten functions with a randomly inserted bug. On average graphs have 260 nodes, 601 edges, 25 rewrite locations, and 130 possible rewrites. We also collect a testset of real bugs. Although we conjecture that, in practice, the vast majority of bugs like those discussed in Sec. 4.1 are fixed when developers locally test their software, a few of those slip and then are fixed across different revisions checked into a version control systems. We have crawled the accessible repositories of all $2 8 5 \mathrm { k }$ packages in the Python Package Index (PyPI), collected and manually filtered bugs captured by the rewrites from Sec. 4.1. $\divideontimes$ . . . . .This. . . . . .new . . . . . . . . .dataset, . . . . . . . . . . . . . . .PYPIBUGS,. . . . . . . . . .contains. . . . . . .2374 . . . . . . . . . . . . .real-world,. . . . . . .small . . . . . . .bugs. We describe the data collection process in detail in Appx. D. In addition, we consider PYPIBUGS-PostFix: the examples from PYPIBUGS after a bug was fixed - we believe these samples are very likely to not contain any bugs anymore. We publish the dataset at https://www.microsoft.com/en-us/download/103554 and include it in the supplementary material.
+
+# 5.1 Quantitative Evaluation
+
+Our first experiment aims to evaluate whether the BUGLAB training framework yields more precise bug detectors. We consider two model architectures, using either GNNs or the GREAT transformer to compute embeddings of code entities (architecture details and hyperparameter choices can be found in Appx. A). We use four different training strategies: “supervised” is training only a bug detector on a fixed dataset of 1 million functions from the $3 . 4 \mathrm { k }$ training packages with randomly inserted bugs. “Random Selector” refers to a variant of PYBUGLAB using a bug selector model that uniformly at random picks a rewrite to insert bugs. Finally, PYBUGLAB and PYBUGLAB $+ \mathrm { A u g }$ use our framework from Sec. 2, with the latter also using additional rewrites to augment our code corpus. For the fully supervised model, we train with early stopping over a validation set; the other models are trained for a fixed number of 300 epochs (with $2 0 0 \mathrm { k }$ training samples per epoch) for the bug detector3 and the last detector model is used for evaluation.
+
+Table 1: Accuracies $( \% )$ for different training strategies and model architectures on RANDOMBUGS.   
+
+<table><tr><td rowspan="3"></td><td colspan="6">RANDOMBUGS</td></tr><tr><td></td><td>GNN</td><td></td><td></td><td>GREAT</td><td></td></tr><tr><td>Joint</td><td>Loc</td><td>Repair</td><td>Joint</td><td>Loc</td><td>Repair</td></tr><tr><td>Supervised</td><td>62.4</td><td>73.6</td><td>81.2</td><td>51.0</td><td>61.9</td><td>76.3</td></tr><tr><td>Random Selector</td><td>69.4</td><td>79.6</td><td>84.0</td><td>63.9</td><td>73.6</td><td>82.0</td></tr><tr><td>PYBUGLAB</td><td>69.6</td><td>80.4</td><td>84.2</td><td>64.0</td><td>74.3</td><td>82.3</td></tr><tr><td>PYBUGLAB +Aug</td><td>70.3</td><td>81.1</td><td>84.5</td><td>65.3</td><td>75.3</td><td>82.5</td></tr></table>
+
+Effectiveness of BUGLAB Training We first consider the performance of different models on the synthetic RANDOMBUGS dataset. Tbl. 1 shows the accuracy of predicting a full bug repair correctly (“Joint”) and analogous to Eq. 2 break this up into a localization accuracy (“Loc”) of predicting the correct location (or NoBug for correct examples) and a repair accuracy (“Repair”) for selecting the correct rewrite given the buggy location.
+
+We observe that $\divideontimes$ . . . . . . . . . . . . . . . . . . . . .BUGLAB-training. . . . . . .leads. . . .to . . . . . . .more. . . . . . . .robust. . . . . .bug . . . . . . . . . . .detectors. . . . . . . . . . . . .compared. . .to. . . . . . . .other methods .......... for both GNNs and GREAT. Random selector models — a form of data augmentation — improve performance over supervised methods but mostly on in-distribution RANDOMBUGS samples. As expected, $\divideontimes$ . . . . . . . . . . . . .augmenting. . . . .the . . . . . .code. . . . . . . . .dataset. . . . . . .helps . . . . . . . . . . . . . . . . .generalization, but does not make a substantial difference. Expanding the kinds of rewrites used to augment the data and learning to select them may improve performance in the future.
+
+Table 2: Results for different training strategies and model architectures on PYPIBUGS.   
+
+<table><tr><td></td><td colspan="6">PYPIBUGS</td><td colspan="4">PYPIBUGS-PostFix</td></tr><tr><td></td><td colspan="3">GNN</td><td colspan="3">GREAT</td><td colspan="2">GNN</td><td colspan="2">GREAT</td></tr><tr><td></td><td>Joint</td><td>Loc</td><td>Repair</td><td>Joint</td><td>Loc</td><td>Repair</td><td>Loc</td><td>Joint AUC</td><td>Loc</td><td>Joint AUC</td></tr><tr><td>Supervised</td><td>20.0</td><td>28.4</td><td>61.8</td><td>16.8</td><td>25.8</td><td>58.6</td><td>17.8</td><td>0.087</td><td>20.7</td><td>0.044</td></tr><tr><td>Random Selector</td><td>21.2</td><td>27.0</td><td>69.2</td><td>20.6</td><td>26.8</td><td>67.2</td><td>47.5</td><td>0.108</td><td>52.5</td><td>0.117</td></tr><tr><td>PYBUGLAB</td><td>24.2</td><td>31.3</td><td>70.7</td><td>24.0</td><td>32.8</td><td>67.9</td><td>32.9</td><td>0.160</td><td>28.6</td><td>0.140</td></tr><tr><td>PYBUGLAB +Aug</td><td>26.4</td><td>33.5</td><td>72.0</td><td>23.2</td><td>29.7</td><td>68.8</td><td>32.6</td><td>0.187</td><td>48.2</td><td>0.129</td></tr></table>
+
+Table 3: Localization and Repair Accuracy $( \% )$ per bug kind for the PYBUGLAB +Aug model.   
+
+<table><tr><td rowspan="3">Bug Type</td><td colspan="4">RANDOMBUGS</td><td colspan="4">PYPIBUGS</td></tr><tr><td colspan="2">GNN</td><td colspan="2">GREAT</td><td colspan="2">GNN</td><td colspan="2">GREAT</td></tr><tr><td>Loc</td><td>Repair</td><td>Loc</td><td>Repair</td><td>Loc</td><td>Repair</td><td>Loc</td><td>Repair</td></tr><tr><td>Argument Swapping</td><td>85.0</td><td>57.3</td><td>65.5</td><td>57.2</td><td>33.2</td><td>73.9</td><td>24.3</td><td>72.7</td></tr><tr><td>Wrong Assign Op</td><td>96.1</td><td>99.1</td><td>94.5</td><td>98.6</td><td>20.0</td><td>68.9</td><td>14.0</td><td>58.1</td></tr><tr><td>Wrong Binary Op</td><td>83.0</td><td>85.2</td><td>77.3</td><td>81.4</td><td>27.2</td><td>54.3</td><td>36.6</td><td>43.7</td></tr><tr><td>Wrong Boolean Op</td><td>71.8</td><td>99.5</td><td>43.6</td><td>99.5</td><td>27.6</td><td>96.9</td><td>15.7</td><td>97.2</td></tr><tr><td>Wrong Comparison Op</td><td>83.9</td><td>79.3</td><td>80.0</td><td>76.4</td><td>33.7</td><td>66.1</td><td>31.1</td><td>53.5</td></tr><tr><td>Wrong Literal</td><td>71.7</td><td>74.7</td><td>66.6</td><td>71.6</td><td>21.6</td><td>78.4</td><td>17.9</td><td>79.5</td></tr><tr><td>Variable Misuse</td><td>84.9</td><td>88.4</td><td>78.2</td><td>86.3</td><td>35.3</td><td>70.5</td><td>34.0</td><td>69.4</td></tr><tr><td>NoBUG</td><td>53.8</td><td></td><td>62.5</td><td></td><td></td><td></td><td></td><td></td></tr></table>
+
+Furthermore, $\ast { \mathrm { l o u g } } .$ . . . . . . . . . . . . . .localization . . .is . . . . . . .much . . . . . . . .harder. . . . . .than . . . . . . . .repair . . .at . .a . . . . . . .given . . . . . . . . . .location. This is somewhat expected: there are many more candidate locations compared to potential repairs at a given location. However, this suggests that research should focus on the localization problem rather than repair.
+
+We now turn to the results on PYPIBUGS, shown in Tbl. 2, which also includes the accuracy of choosing the special NoBug location on the PYPIBUGS-PostFix dataset, as well as the area under the precision recall curve for the results on both PYPIBUGS and PYPIBUGS-PostFix.
+
+We find that $\divideontimes$ . . . . . . . . . .detecting. . . . .and. . . . . . . . . . . .repairing . . . . . . . . .real-life. . . . . . .bugs . .is. . . . . . . . . . . . . . .significantly. . . . . . . .harder. . . . . .than. . . . . . . . . . .handling . . . . . . . . . . . .randomly . . . . . . . . .inserted. . . . . .bugs. As PYBUGLAB models trained using a learned bug selector outperform those using a “Random Selector”, we speculate that the learned selector avoids generating easy-to-detect bugs, focusing the detector model on recognizing deeper semantic patterns. Despite this, improvements in RANDOMBUGS often correlate with improvements in PYPIBUGS. This is encouraging: collecting PYPIBUGS-like datasets is costly; corpora with random bugs can help measure relative improvements to some extent. Finally, we find that $\divideontimes$ . . . . . . . . . . . . . .recognizing . . . . . . . . . . . . .non-buggy . . . . . . . . . .samples. . .is . . . . . .very . . . . . .hard, and in particular, does not always profit from training in PYBUGLAB.
+
+In our qualitative analysis (Sec. 5.2), we observed that the models raised some confident but incorrect warnings at very “odd” locations. However, these warnings were different across models. We have tested an ensembling strategy averaging the output probabilities of five separately trained GNN models. This results in localization and repair accuracies of $8 3 . 0 \%$ and $8 5 . 4 \%$ on RANDOMBUGS (vs. $8 1 . 1 \%$ and $8 4 . 5 \%$ ) and $3 4 . 4 \%$ and $7 2 . 2 \%$ on PYPIBUGS (vs. $3 3 . 5 \%$ and $7 2 . 0 \%$ ). As we discuss in Sec. 5.2 finding the cause of the “spurious” warnings is important future work.
+
+Per-Bug Evaluation To better understand which bugs are hard to detect, we break down the results the best-performing PYBUGLAB $+ \mathrm { A u g }$ models on RANDOMBUGS by type of bug in Tbl. 3. We observe that incorrect literals are some of the hardest bugs to detect. Incorrect assignment operators $( e . g . = \mathrm { a n d } + = )$ ) are easy to detect in RANDOMBUGS, but significantly harder in PYPIBUGS. This may be attributed to class imbalance, with simple assignment $( = )$ being the majority class. $\divideontimes$ Detecting . . . . . . . . . . . . . .if .a. . . . . . . . .snippet. . . . .has . .a . . . . .bug . . .or . . . .not. . . . . . . .seems . . .to . . .be. . . .the. . . . . . . . .hardest. . . . . .task:. . . .no. . . . . . . .model . . . . . . . . . .achieves. . . . . . . . . . .accuracy. . . . . . . . .beyond. $6 3 \%$ .
+
+We note that in our experiments, GNNs-based models seem to often outperform GREAT, somewhat contradicting the results of Hellendoorn et al. [13]. We have performed substantial additional experiments to investigate and verify these results, cf. Sec. A.2. This may have to do with the performance of these models on long sequences or that the GNN has access to more fine-grained information, instead of relations over the projected token sequences. For example, this could be attributed to the lack of syntax and symbol nodes in the representation used in GREAT. Nevertheless, GREAT is noticeably better ( $6 2 . 5 \%$ vs. $5 3 . 8 \%$ ) at detecting NoBug and locating wrong binary operators in PYPIBUGS.
+
+Table 5: Bug distribution $( \% )$ in different datasets   
+
+<table><tr><td>Bug Kind</td><td>PYPIBUGS</td><td>RANDOMBUGS</td><td>Selector Samples</td></tr><tr><td>Argument Swapping</td><td>11.9</td><td>8.4</td><td>23.8</td></tr><tr><td>Wrong Assignment</td><td>1.9</td><td>8.5</td><td>5.3</td></tr><tr><td>Wrong Binary Operator</td><td>3.4</td><td>2.4</td><td>2.3</td></tr><tr><td>Wrong Boolean Operator</td><td>8.1</td><td>2.2</td><td>6.4</td></tr><tr><td>Wrong Comparison Operator</td><td>17.1</td><td>8.2</td><td>7.4</td></tr><tr><td>Wrong Literal</td><td>3.7</td><td>11.6</td><td>12.4</td></tr><tr><td>Variable Misuse</td><td>53.8</td><td>58.6</td><td>42.5</td></tr></table>
+
+Bug Selector Performance To understand how training of the bug selector proceeds, we perform two experiments. In our first experiment, we take a snapshot of the selector model during training of the PYBUGLAB $+ \mathrm { A u g }$ (GNN) model every 24 hours, after an initial burn-in phase of 12 hours. We then generate 10000 buggy samples using each of these snapshots and then test a fixed model on each of these snapshots. The results of this are shown in Tbl. 4, using a fully trained PYBUGLAB $+ \mathrm { A u g }$ (GNN) model from another training run as a fixed model. We conclude that . . . . . . . . . . . . . . . . . . . . . . . . .PYBUGLAB succeeds. . . .in . . . . . . . . . .learning . . .to . . . . . . . . . .generate. . . . . . . .harder. . .to find ..........bugs, though we can observe the selector model trading off “harder-to-localize” and “harder-tofix” properties. Tests on other models show similar trends, confirming the robustness of this result.
+
+Table 4: Development of Performance on Bug Selector Samples   
+
+<table><tr><td>Training&#x27; Time</td><td>Joint</td><td>Loc</td><td>Repair</td></tr><tr><td>0.5 days</td><td>64.2</td><td>83.8</td><td>72.1</td></tr><tr><td>1.5 days</td><td>62.5</td><td>80.7</td><td>72.9</td></tr><tr><td>2.5 days</td><td>62.0</td><td>83.0</td><td>69.8</td></tr><tr><td>3.5 days</td><td>61.7</td><td>82.5</td><td>69.8</td></tr><tr><td>4.5 days</td><td>61.9</td><td>83.0</td><td>69.5</td></tr><tr><td>5.5 days</td><td>61.1</td><td>83.0</td><td>68.6</td></tr><tr><td>6.5 days</td><td>60.5</td><td>78.7</td><td>72.4</td></tr></table>
+
+In a second experiment, we compare the distribution of different bug kinds in PYPIBUGS and RANDOMBUGS with the distribution of bugs sampled from the final snapshot of our selector model from above. The results are shown in Tbl. 5, where we can see that a number of bugs (argument swapping, use of wrong literals and of assignment operators) are substantially over-represented, whereas mistakes in comparison operators and variable misuse are under-represented. This indicates that . . . . . . . . . . . . . . . . . . . . . . . . . .PYBUGLAB generates. . . . . .hard . . .to . . . . . .find, . . . .but. . . .not. . . . . . . . . . . . . .necessarily . . . . . . . . . .realistic . . . . . .bugs.
+
+Comparison to CuBERT Finally, we compare our models to CuBERT [15], which uses a masked language modeling objective to pre-train a BERT-like model and then learns bug detectors specific to a class of bugs (e.g., wrong binary operators) on top of this pre-trained model. Note that CuBERT detects $i f$ a bug exists but does not localize it. For the comparison, we create two sub-datasets of PYPIBUGS: PYPIBUGS-WrongOp contains the 501 samples that involve the binary operators supported by CuBERT, and PYPIBUGS-VarMisuse, which contains the 1278 bugs that involve variable misuses. We complete both of these datasets with 501 (resp. 1278) random NoBug code samples from our RANDOMBUGS, to match the 1:1 buggy/non-buggy distribution used in CuBERT’s training. Since CuBERT classification models focus on a single bug type, to compare to PYBUGLAB we mask out all code locations that do not correspond to a bug that could be detected by the corresponding CuBERT model. We then treat the prediction of the NoBug location as a “non-buggy” prediction and all other locations as a “buggy” prediction. For example, for the snippet in Fig. 2, only the locations $l _ { 2 }$ , $l _ { 1 1 }$ , $l _ { 1 4 }$ , $l _ { 1 6 }$ , and $l _ { 2 0 }$ and their corresponding rewrites are considered by PYBUGLAB for the comparison on PYPIBUGS-WrongOp.
+
+Tbl. 6 shows the results of comparing the released CuBERT snapshots with the PYBUGLAB +Aug GNN model. We observe that $\divideontimes$ . . . .the . . . . . . . . . . . . . . . . . . . . . . . . .PYBUGLAB models
+
+Table 6: Comparison with CuBERT [15]   
+
+<table><tr><td rowspan="2"></td><td colspan="3">CuBERT</td><td colspan="3">PYBUGLAB (GNN)</td></tr><tr><td>Prec</td><td>Recall</td><td>F1</td><td>Prec</td><td>Recall</td><td>F1</td></tr><tr><td>PYPIBUGs-WrongOp</td><td>0.764</td><td>0.251</td><td>0.378</td><td>0.730</td><td>0.764</td><td>0.746</td></tr><tr><td>PYPIBUGS-VarMisuse</td><td>0.632</td><td>0.403</td><td>0.493</td><td>0.740</td><td>0.840</td><td>0.787</td></tr></table>
+
+. . . . .have. . . . . . . . . . . . . . . .substantially . . . . . . .better. . . . . . .recall. . . . . .than. . . . . . . . . . . . . . . . . . .CuBERT-based . . . . . . . . .models, even though they were trained to detect more bug types. When calibrating the CuBERT models to have a recall equal to PYBUGLAB, heir precision drops substantially. In particular, on PYPIBUGS-WrongOp, it is reduced to 0.609, and
+
+1 def make_id(name):   
+2 $\mathbf { r } \ =$ get_rand_string(12)   
+3 if len(name) <= 22:   
+4 name $=$ name[:22]   
+5 return name $\textrm { + } \textrm { -- } \textrm { + } \textrm { \pmb { r } }$ (a) A wrong comparison operator bug (red box) in PYPIBUGS detected and repaired by the GNN PYBUGLAB +Aug models.
+
+1 def update(self, roomId,   
+2 title, \*\*request_params):   
+3 check_type(roomId, basestring)   
+4 check_type(roomId, basestring)   
+5 [...]
+
+(b) A variable misuse (red box) caught in an open-source project. GNN PYBUGLAB $+ \mathrm { A u g }$ suggests to rewrite roomId to title. The fixing pull request is found here.
+
+Figure 3: Bugs found by PYBUGLAB. Snippets reformatted and abbreviated to fit figure.
+
+on PYPIBUGS-VarMisuse, it is reduced to 0.613; in both cases, PYBUGLAB outperforms CuBERT substantially.
+
+# 5.2 Qualitative Inspection of Raised Warnings
+
+We now take a qualitative look at the raised warnings raised by PYBUGLAB. As example, Fig. 3a shows a sample of PYPIBUGS where the developer used an incorrect comparison operator. Once pointed to it, it is clear to a human that the truncation statement in line 4 has no effect (under the reasonable assumption that name is a string), and that a different comparison operator $( > )$ is necessary.
+
+To gain an understanding of the performance of PYBUGLAB on realistic data, we performed an indepth analysis of the cases flagged as bugs by our best-performing model on the code found within the 4k top PyPI packages. We observed a mixture of false positives with few previously unseen real-life bugs, matching the quantitative results in Tbl. 3. First, we find that the majority of the false positives are “incorrect literal” detections. This suggests that learning to detect such bugs is a hard problem. Furthermore, many literals serve as default “configurations” (e.g. the number of retries for a network request) and different values are not bugs. We posit that a large percentage of literal replacements the selector learns to make fall in this category.
+
+We also found that some repairs suggested by the model actually produce semantically equivalent code. For example, the model lacks knowledge that two variables refer to the same object in memory (aliasing), and so attempts to “repair” variable misuse bugs by switching between these. Other examples includes checking the return values of standard functions such as Python’s str.find, which returns $^ { - 1 }$ if the query string is not found. In such cases, PYBUGLAB often suggested to rewrite an if $\mathbf { x } \lrcorner \mathbf { f i n d } ( \mathbf { y } ) \ \ll \ - 1$ to if $\mathbf { x } \lrcorner \mathbf { f i n d } ( \mathbf { y } ) \ = - 1$ , which makes no difference in practice. These false negatives can be attributed to the fact that the bug selector model considers such changes as introducing bugs, even though they are not actually changing behavior. This suggests that for better results, the rewrite rules need to ensure that the rewrites are not semantics-preserving and represent bugs.
+
+Finally, some reported issues were sufficiently complex that it took us (the human authors) a couple of minutes of thought to conclude that a warning is spurious. Simultaneously, there are some warnings that are “obviously” incorrect to us, but the reasons why the neural models raise them is unclear. This highlights the importance of research on explainability techniques along with better ways to calibrate model confidence. The fact that selectors may introduce spurious “bugs” may also be affecting how the detector model learns. Ideas that have appeared in reinforcement learning, such as the one of Dennis et al. [8], may allow models to improve their performance in spite of spurious bugs.
+
+Overall, $\yen 123,456,7$ . . .of. . . . .the . . . . . .1000. . . . . . . . . . .reported . . . . . . . . . . .warnings . . . . . .were. . . . . . . .found . . .to . . .be. . . . . . . . . .real-life. . . . . . .bugs. Of these 19, we reported 11 on GitHub (6 already merged, 5 pending approval). See Appx. G for details. 3 other bugs had already been fixed between the version PYBUGLAB processed and the current version or the project was deprecated, whereas another 5 bugs are minor and we decided not to report them. One of the detected bugs is shown in Fig. 3b. Overall, most of the detected bugs appear within unit tests, logging, or exception handling, possibly because bugs there do not impact the core functionality of a project. However, given the number of such bugs we collected in PYPIBUGS, we believe that such bugs arise equally often in other code, but that they are detected and fixed more quickly.
+
+Although our analysis only forms a lower bound on the precision of PYBUGLAB and related methods, it suggests that there is still ample room for future improvements towards making machine learningbased bug detection and repair practically useful.
+
+# 6 Related Work
+
+Detecting bugs in source code has been researched since the early days of computing. Traditionally, bug detection is tackled as a formal task, where any code that cannot be proved to satisfy some correctness property may contain a bug. This is essential for security- and safety-critical bugs, but not for other — equally common — bugs. In the last decade, software engineering and programming language research have increasingly realized ambiguous information within code (e.g. variable names, comments) contains valuable information and using this information can yield valuable results [2]. The main premise is that patterns in source code, such as patterns in names, control, and data flow can be informative. This information can also be exploited to detect some bugs. For example, Ray et al. [24] noted that even simple language models tend to assign lower probability to buggy code.
+
+Multiple static analysis methods have been researched that combine some form of data-oriented bug detection. This ranges from language model-based tools, such as the early work of Wang et al. [32] to specification-mining tools such as the work of Eberhardt et al. [10]. BUGLAB is related to DeepBugs [22] which uses an MLP over a limited window of code tokens and train separate models to detect wrong operators, operands, and argument swappings. BUGLAB opts for a more structured representation of code and a single model. Allamanis et al. [3], Vasic et al. [30], Hellendoorn et al. [13] tackle variable misuse bugs (one of the kinds of bugs included in PYBUGLAB) but either by randomly introducing the bugs in code or using a Cloze-like test. Instead, BUGLAB opts for a selfsupervised approach and tackles a broader range of bugs. Concurrently to this work, Patra and Pradel [21] showed an alternative method for learning to generate realistic bugs. Dinella et al. [9] learn a supervised sequential model that performs graph transformations that replicate small edits in code (refactoring, introducing functionality, bug fixing, etc.). Their model — Hoppity — could serve as a learnable rewrite operation in BUGLAB in future work. Dynamic analysis methods have also been researched with promising results [31], but collecting representative dynamic traces over a diverse set of programs at scale (e.g. from the top Python packages used in this work) is practically impossible.
+
+BUGLAB is related to ideas around self-supervised learning recently explored in deep learning, computer vision, and NLP. In our case, we aim to train a bug detection model without using training data from real-life bugs. BUGLAB resembles ELECTRA [6], with the important difference that the rewrites to the input code go beyond single token replacement that need to respect strict constraints of programming languages (syntax, variable scopes) and the model is directly used for bug detection, rather than for pre-training. The main BUGLAB objective Eq. 1 also resembles GANs [12] with the exception that the objective is non-differentiable (introducing a bug alters the discrete data representation), the selector is a structured probabilistic code rewriting model, and that we are mainly interested in the bug detector (analogous to the discriminator) rather than the selector.
+
+# 7 Discussion and Conclusions
+
+Learned program analyses offer the promise to improve how we develop software. They also offer a great opportunity to study machine learning models that combine formal and probabilistic reasoning. Towards achieving these we presented BUGLAB, a self-supervised approach for learning program analyses, that improves upon baseline methods and detects bugs in real-life code. We also empirically show the limitations of existing bug-detecting machine learning methods, which suffer from impractical false-positive rates. Importantly, we show the large gap of performance of existing methods on corpora of randomly inserted bugs — commonly used in prior work — and real-life bugs.
+
+# Acknowledgements
+
+We want to thank Sebastian Nowozin and Marwin Segler for helpful discussions, Marwin Segler for comments on a draft of this work, and the anonymous reviewers for useful questions and suggestions. Finally, we would like to thank the contributors to the following open-source tools used: PyTorch [20], PyDriller [27], MessagePack, LibCST, Jedi, Kubernetes, Helm.
+
+References   
+[1] M. Allamanis. The adverse effects of code duplication in machine learning models of code. In Proceedings of the 2019 ACM SIGPLAN International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software, pages 143–153, 2019.   
+[2] M. Allamanis, E. T. Barr, P. Devanbu, and C. Sutton. A survey of machine learning for big code and naturalness. ACM Computing Surveys (CSUR), 51(4):1–37, 2018.   
+[3] M. Allamanis, M. Brockschmidt, and M. Khademi. Learning to represent programs with graphs. In International Conference on Learning Representations (ICLR), 2018.   
+[4] M. Allamanis, E. Barr, S. Ducousso, and Z. Gao. Typilus: Neural type hints. In Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI), pages 91–105. Association for Computing Machinery (ACM), 2020.   
+[5] T. Bachlechner, B. P. Majumder, H. H. Mao, G. W. Cottrell, and J. McAuley. Rezero is all you need: Fast convergence at large depth. arXiv preprint arXiv:2003.04887, 2020.   
+[6] K. Clark, M.-T. Luong, Q. V. Le, and C. D. Manning. ELECTRA: Pre-training text encoders as discriminators rather than generators. arXiv preprint arXiv:2003.10555, 2020.   
+[7] M. Cvitkovic, B. Singh, and A. Anandkumar. Deep learning on code with an unbounded vocabulary. In Machine Learning 4 Programming, 2018.   
+[8] M. Dennis, N. Jaques, E. Vinitsky, A. Bayen, S. Russell, A. Critch, and S. Levine. Emergent complexity and zero-shot transfer via unsupervised environment design. arXiv preprint arXiv:2012.02096, 2020.   
+[9] E. Dinella, H. Dai, Z. Li, M. Naik, L. Song, and K. Wang. Hoppity: Learning graph transformations to detect and fix bugs in programs. In International Conference on Learning Representations, 2019.   
+[10] J. Eberhardt, S. Steffen, V. Raychev, and M. Vechev. Unsupervised learning of API aliasing specifications. In Proceedings of the 40th ACM SIGPLAN Conference on Programming Language Design and Implementation, pages 745–759, 2019.   
+[11] J. Gilmer, S. S. Schoenholz, P. F. Riley, O. Vinyals, and G. E. Dahl. Neural message passing for quantum chemistry. In International Conference on Machine Learning, pages 1263–1272, 2017.   
+[12] I. J. Goodfellow, J. Pouget-Abadie, M. Mirza, B. Xu, D. Warde-Farley, S. Ozair, A. Courville, and Y. Bengio. Generative adversarial networks. arXiv preprint arXiv:1406.2661, 2014.   
+[13] V. J. Hellendoorn, C. Sutton, R. Singh, P. Maniatis, and D. Bieber. Global relational models of source code. In International Conference on Learning Representations, 2020.   
+[14] R. Just, D. Jalali, L. Inozemtseva, M. D. Ernst, R. Holmes, and G. Fraser. Are mutants a valid substitute for real faults in software testing? In Proceedings of the 22nd ACM SIGSOFT International Symposium on Foundations of Software Engineering, pages 654–665, 2014.   
+[15] A. Kanade, P. Maniatis, G. Balakrishnan, and K. Shi. Learning and evaluating contextual embedding of source code. In International Conference on Machine Learning (ICML), 2020.   
+[16] R.-M. Karampatsis and C. Sutton. How often do single-statement bugs occur? the ManySStuBs4J dataset. In Proceedings of the 17th International Conference on Mining Software Repositories, pages 573–577, 2020.   
+[17] J. Katz. Libraries.io Open Source Repository and Dependency Metadata, Jan. 2020. URL https://doi.org/10.5281/zenodo.3626071.   
+[18] Y. Li, D. Tarlow, M. Brockschmidt, and R. Zemel. Gated graph sequence neural networks. In International Conference on Learning Representations (ICLR), 2016.
+
+[19] S. Merity, C. Xiong, J. Bradbury, and R. Socher. Pointer sentinel mixture models. In International Conference on Learning Representations (ICLR), 2017.
+
+[20] A. Paszke, S. Gross, S. Chintala, G. Chanan, E. Yang, Z. DeVito, Z. Lin, A. Desmaison, L. Antiga, and A. Lerer. Automatic differentiation in PyTorch. 2017.   
+[21] J. Patra and M. Pradel. Semantic bug seeding: a learning-based approach for creating realistic bugs. In Proceedings of the 29th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering, pages 906–918, 2021.   
+[22] M. Pradel and K. Sen. DeepBugs: A learning approach to name-based bug detection. Proceedings of the ACM on Programming Languages, 2(OOPSLA):1–25, 2018.   
+[23] G. Ramakrishnan, J. Henkel, Z. Wang, A. Albarghouthi, S. Jha, and T. Reps. Semantic robustness of models of source code. arXiv preprint arXiv:2002.03043, 2020.   
+[24] B. Ray, V. Hellendoorn, S. Godhane, Z. Tu, A. Bacchelli, and P. Devanbu. On the ”naturalness” of buggy code. In 2016 IEEE/ACM 38th International Conference on Software Engineering (ICSE), pages 428–439. IEEE, 2016.   
+[25] V. Raychev, M. Vechev, and A. Krause. Predicting program properties from Big Code. In Principles of Programming Languages (POPL), 2015.   
+[26] A. Rice, E. Aftandilian, C. Jaspan, E. Johnston, M. Pradel, and Y. Arroyo-Paredes. Detecting argument selection defects. Proceedings of the ACM on Programming Languages, 1(OOPSLA): 1–22, 2017.   
+[27] D. Spadini, M. Aniche, and A. Bacchelli. PyDriller: Python framework for mining software repositories. In Proceedings of the 2018 26th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering - ESEC/FSE 2018, pages 908–911, New York, New York, USA, 2018. ACM Press. ISBN 9781450355735. doi: 10.1145/3236024.3264598. URL http://dl.acm.org/citation. cfm?doid $\equiv$ 3236024.3264598.   
+[28] D. Tarlow, S. Moitra, A. Rice, Z. Chen, P.-A. Manzagol, C. Sutton, and E. Aftandilian. Learning to fix build errors with Graph2Diff neural networks. In Proceedings of the IEEE/ACM 42nd International Conference on Software Engineering Workshops, pages 19–20, 2020.   
+[29] H. Touvron, M. Cord, A. Sablayrolles, G. Synnaeve, and H. Jegou. Going deeper with image ´ transformers. arXiv preprint arXiv:2103.17239, 2021.   
+[30] M. Vasic, A. Kanade, P. Maniatis, D. Bieber, and R. Singh. Neural program repair by jointly learning to localize and repair. arXiv preprint arXiv:1904.01720, 2019.   
+[31] K. Wang and Z. Su. Blended, precise semantic program embeddings. In Proceedings of the 41st ACM SIGPLAN Conference on Programming Language Design and Implementation, pages 121–134, 2020.   
+[32] S. Wang, D. Chollak, D. Movshovitz-Attias, and L. Tan. Bugram: bug detection with n-gram language models. In Proceedings of the 31st IEEE/ACM International Conference on Automated Software Engineering, pages 708–719, 2016.   
+[33] J. Wei, M. Goyal, G. Durrett, and I. Dillig. LambdaNet: Probabilistic type inference using graph neural networks. arXiv preprint arXiv:2005.02161, 2020.

parse/train/EQbyD_KG6w-1h/EQbyD_KG6w-1h_content_list.json

@@ -0,0 +1,1185 @@
+[
+    {
+        "type": "text",
+        "text": "Self-Supervised Bug Detection and Repair ",
+        "text_level": 1,
+        "bbox": [
+            240,
+            122,
+            756,
+            148
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Miltiadis Allamanis, Henry Jackson-Flux∗, Marc Brockschmidt Microsoft Research, Cambridge, UK {miallama, mabrocks}@microsoft.com ",
+        "bbox": [
+            281,
+            200,
+            717,
+            243
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            279,
+            535,
+            295
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Machine learning-based program analyses have recently shown the promise of integrating formal and probabilistic reasoning towards aiding software development. However, in the absence of large annotated corpora, training these analyses is challenging. Towards addressing this, we present BUGLAB, an approach for selfsupervised learning of bug detection and repair. BUGLAB co-trains two models: (1) a detector model that learns to detect and repair bugs in code, (2) a selector model that learns to create buggy code for the detector to use as training data. A Python implementation of BUGLAB improves by up to $30 \\%$ upon baseline methods on a test dataset of 2374 real-life bugs and finds 19 previously unknown bugs in open-source software. ",
+        "bbox": [
+            233,
+            310,
+            767,
+            448
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            473,
+            310,
+            491
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Detecting and repairing bugs in source code requires strong reasoning skills over formal structures (e.g. data and control flow) and ambiguous information (e.g. identifier names, coding idioms, and comments). Traditional program analyses are able to detect critical bugs through formal reasoning and combinatorial search, but need to be manually coded by experts. That is a lengthy and costly process, which misses the opportunity to use ambiguous information pervasive within code. ",
+        "bbox": [
+            174,
+            505,
+            825,
+            574
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Towards broadening the applicability of such methods, and utilizing ambiguous information, deep learning-based bug detection methods are being investigated [22, 3, 13]. These methods have the potential to further improve the engineering of software we rely on every day. However, many challenges in the area remain open, such as creating robust bug detection and repair methods that cover a wide range of common bugs in the absence of large supervised training corpora. Existing work focuses on randomly inserted bugs [22, 13], Cloze test proxy tasks [3], corpora of small code edits that may contain bugs [9] or build errors [28]. All these approaches rely on datasets of very limited size or ones known not to be representative of the characteristics of bugs found in real code. ",
+        "bbox": [
+            174,
+            580,
+            825,
+            691
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work, we propose BUGLAB, a self-supervised approach that trains robust bug detectors by co-training a bug selector that learns to create hard-to-detect bugs (Sec. 2). For example, for a given code snippet with two well-named variables, a variable misuse bug may be easy to detect and repair, whereas an incorrect comparison operator might be significantly harder to identify. We propose a neural architecture for BUGLAB (Sec. 3) and implement it for Python (Sec. 4). Our implementation considers four broad classes of seemingly simple, yet hard-to-detect bugs and shows improved performance over training with randomly-inserted bugs on PYPIBUGS, a new, manually curated test set of 2374 real-life bugs (Sec. 5). Furthermore, we tested our trained models on popular open-source Python packages and identified 19 previously unreported bugs, though false positive rates of $\\sim 9 8 \\%$ remain impractical. We hope that creating machine learning methods that can detect these bugs early and assist developers will speed up software development and allow engineers to deliver more robust software. We release PyPIBugs and our code at https://github.com/ microsoft/neurips21-self-supervised-bug-detection-and-repair. ",
+        "bbox": [
+            174,
+            698,
+            825,
+            877
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "2 Self-Supervised Bug Detection ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            457,
+            107
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this section, we first introduce the concept of code rewriting, and then use it to define BUGLAB as a framework for self-supervised learning of bug detection and repair. ",
+        "bbox": [
+            174,
+            123,
+            825,
+            151
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Code Rewriting Rewriting is common within compilers and their optimizations, test-driven searchbased bug repair tools, mutation testing, and refactoring tools. Rewrites can be semantics-preserving (e.g. renamings of local variables), or semantics-altering (e.g. replacing $> = \\log ~ ! = )$ . ",
+        "bbox": [
+            174,
+            170,
+            826,
+            212
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Let $s$ denote the set of all syntax trees (not necessarily rooted in the start symbol of the language grammar). Syntax tree locations $\\ell \\in \\{ \\epsilon \\} \\cup \\mathbb { N } ^ { * }$ in a syntax tree $\\mathrm { s } \\in { \\mathcal { S } }$ are recursively defined, where $\\mathrm { s } _ { \\vert \\epsilon } = \\mathrm { s }$ and $\\mathrm { s } _ { | \\ell }$ for $\\ell = \\ell ^ { \\prime } \\circ i$ is the $i$ -th child of $\\mathrm { s } _ { \\vert \\ell ^ { \\prime } }$ (i.e. s|(2,3) denotes the third child of the second child of s). We define a rewrite rule $\\rho = ( \\mathrm { m } _ { \\rho } , \\mathrm { t } _ { \\rho } )$ as a pair of a matching function $\\operatorname { m } _ { \\rho } : S  \\{ t r u e , f a l s e \\}$ and a transformation function $\\mathrm { t } _ { \\rho } : { \\mathcal { S } }  { \\mathcal { S } }$ . The matching function $\\mathrm { m } _ { \\rho } ( \\mathrm { s } )$ yields true iff the rule $\\rho$ is applicable at the root of a subtree s. The transformation function can be applied to obtain a transformed syntax tree. For convenience, we define $\\mathrm { t } _ { \\rho } ( \\mathrm { s } ) = \\mathrm { s }$ iff $\\mathrm { m } _ { \\rho } ( \\mathrm { s } ) = f a l s e$ . We then write $\\rho ( \\mathrm { s } )$ to indicate the modification of a syntax tree s using $\\rho$ when possible, and otherwise the identity function. For reversible rewrite rules $\\rho$ , we denote the inverse rule as $\\rho ^ { - 1 }$ such that $\\rho ^ { - 1 } ( \\rho ( \\mathrm { s } ) ) = \\mathbf { \\dot { s } }$ holds. We discuss concrete rewrite rules $\\rho$ in Sec. 4. ",
+        "bbox": [
+            173,
+            218,
+            825,
+            358
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Given a set of rewrite rules $\\mathcal { R }$ we define the set of “potential rewrites” in a syntax tree s as $R _ { \\mathrm { s } } ^ { \\mathcal { R } } =$ $\\{ \\langle \\ell , \\rho \\rangle \\mid \\rho \\in { \\mathcal { R } } , \\ell$ location in s, $, \\mathbf { m } _ { \\rho } ( \\mathbf { s } _ { | \\ell } ) = t r u e \\}$ . For each tuple $\\langle \\ell , \\rho \\rangle \\in R _ { \\mathrm { s } } ^ { \\mathcal { R } }$ , we use $\\mathrm { s } ^ { \\prime } = \\mathrm { s } [ \\rho ] \\varrho$ to denote the new syntax tree obtained by applying $\\rho$ at location $\\ell$ of s. In BUGLAB, we train models that use rewrites from $R _ { \\mathrm { s } } ^ { \\mathcal { R } }$ to insert and repair bugs. We will discuss such neural models in Sec. 3. ",
+        "bbox": [
+            173,
+            364,
+            825,
+            422
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "BUGLAB In BUGLAB, we are interested in selfsupervised training of a robust bug detector model $D _ { \\theta }$ with parameters $\\theta$ on an unannotated codebase $C$ . Let $\\mathcal { R }$ be a set of rewrite rules2 that allows to insert and repair bugs. We train $D _ { \\theta }$ to be able to recognize the “hardest” possible rewrites that could be applied on our codebase $C$ For this, we consider the loss $\\mathcal { L } _ { D _ { \\theta } }$ of $D _ { \\theta }$ on a rewritten code snippet $\\mathrm { s } [ \\rho ] _ { \\ell }$ , for which the model needs to predict the repairing rewrite $\\langle \\ell , \\rho ^ { - 1 } \\rangle$ . Formally, we want to minimize the objective ",
+        "bbox": [
+            173,
+            440,
+            550,
+            580
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/597426b766af16b530c3086ca1c3bf9cfa4fa1541fefff8ff73eda53f624e93e.jpg",
+        "text": "$$\nE _ { \\mathrm { s } \\sim C } \\left[ \\operatorname* { m a x } _ { \\langle \\ell , \\rho \\rangle \\in R _ { \\mathrm { s } } ^ { \\mathcal { R } } } \\mathcal { L } _ { D _ { \\theta } } \\left( \\mathrm { s } [ \\rho ] _ { \\ell } , \\left. \\ell , \\rho ^ { - 1 } \\right. \\right) \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            228,
+            590,
+            495,
+            626
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/6a90afa1a44c13ced3e725f045bc326e6741157b1e8e404cd0b3127444e41f05.jpg",
+        "image_caption": [
+            "Figure 1: BUGLAB overview: a selector model $S _ { \\phi }$ decides which (bugintroducing) rewrite to apply to an input code snippet. Then a bug detector $D _ { \\theta }$ tries to locate and repair the inserted bug (if one was inserted). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            563,
+            434,
+            823,
+            618
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "However, for any useful detector the set of rewrites $R _ { \\mathrm { s } } ^ { \\mathcal { R } }$ is commonly very large or unbounded and computing the maximum over all $\\langle \\bar { \\ell , } \\rho \\rangle \\in R _ { \\mathrm { s } } ^ { \\mathcal { R } }$ is practically intractable. To address this, BUGLAB introduces a bug selector model $S _ { \\phi }$ (with parameters $\\phi _ { , }$ ), whose goal is to approximate the intractable $\\mathrm { m a x } _ { \\langle \\ell , \\rho \\rangle \\in R _ { \\mathrm { s } } ^ { \\mathcal { R } } } \\mathcal { L } _ { D _ { \\theta } } \\left( \\cdot \\right)$ . We can then sample rewrites from $S _ { \\phi }$ instead of computing the maximum. We denote this as $\\langle \\ell , \\rho \\rangle \\sim S _ { \\phi } ( s )$ and the overall BUGLAB training objective can be written as a min-max optimization problem: ",
+        "bbox": [
+            173,
+            645,
+            550,
+            714
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            714,
+            825,
+            757
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e53606b879b4d2a39b079f53ba9fb551d00be5442d4142c61a4ee1789a5f3c7d.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { \\phi } \\operatorname* { m i n } _ { \\theta } E _ { \\mathrm { s } \\sim C } \\left[ E _ { \\langle \\ell , \\rho \\rangle \\sim S _ { \\phi } ( \\mathrm { s } ) } \\left[ \\mathcal { L } _ { D _ { \\theta } } \\left( \\mathrm { s } [ \\rho ] _ { \\ell } , \\langle \\ell , \\rho ^ { - 1 } \\rangle \\right) \\right] \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            315,
+            767,
+            681,
+            792
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The two models $S$ and $D$ in BUGLAB are “symmetric” in the sense that they both predict rewrites on code snippets, and only differ in their objectives — one aiming to introduce bugs and one aiming to repair them. In practice, we can and do use the same architecture to model both $S$ and $D$ , which we will discuss in the next section. At test time, we discard $S$ and only use the trained detector $D$ to locate and repair bugs. ",
+        "bbox": [
+            174,
+            809,
+            825,
+            880
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 Neural Models ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            328,
+            106
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we discuss how we represent code in BUGLAB and the neural models we use to learn how to rewrite code in the selector and detector models. ",
+        "bbox": [
+            174,
+            121,
+            823,
+            148
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Code Representation We consider source code as a set of entities $v _ { i } ~ \\in ~ V$ which relate to each other with a set of typed relations $e _ { k } \\in E$ , where a relation $e _ { k } = ( v _ { i } , r , v _ { j } )$ denotes a relationship between entities $v _ { i }$ and $v _ { j }$ with type $r$ . The entities and relations can be thought as a heterogeneous graph $G = ( V , E )$ . The choice of code entities and their relationships is a form of high-level feature extraction. We discuss concrete entities and relationships for Python in Sec. 4. We also define a projection function $\\mathbb { P } _ { t o k }$ that accepts $V$ and $E$ and returns a sequence $V _ { t o k }$ of the token entities in $V$ with the nodes appearing in relations in $E$ deterministically mapped to elements of $V _ { t o k }$ , i.e. $E _ { t o k } = \\{ ( p ( v _ { i } ) , r , p ( \\hat { v _ { j } } ) ) \\}$ , where $p$ maps the entities in $V$ to $V _ { t o k } . \\mathbb { P } _ { t o k }$ will be used for relational transformer models. ",
+        "bbox": [
+            173,
+            154,
+            825,
+            280
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To learn a neural representation of the code entities $v _ { i }$ , first we define an embedding function $e ( v _ { i } )$ which maps the content of each entity to an initial $D$ -dimensional representation. Throughout this work — similar to Allamanis et al. [4] and other previous work — we deterministically split the string representation of each node into subtokens (e.g., fooBar is split into foo and bar), embed them through a learned embedding matrix, and use max pooling to get a single vector. We then “contextualize” the entity representations within $G$ using one of two models: a MLP-based GNN model with max message aggregation and the GREAT relational transformer of Hellendoorn et al. [13] over the token sequence and relations $V _ { t o k } , E _ { t o k } = \\mathbb { P } _ { t o k } ( V , E )$ . GREAT uses both positional encodings and the projected relations in $E _ { t o k }$ . See Appx. A for detailed architecture descriptions. Other models to compute entity representations can be used, but were not explored in this work. ",
+        "bbox": [
+            173,
+            285,
+            826,
+            424
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We use $\\mathbfit { \\Delta } \\mathbf { r } _ { \\ell }$ to denote the computed vector representation of the entity at location $\\ell$ , independent of the model used to produce it. We use these representations to define our code rewriting models. ",
+        "bbox": [
+            173,
+            430,
+            823,
+            458
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Probabilistic Code Rewriting Models Both bug selection and bug detection require to model the probability of applying a specific rewrite at a location in a code snippet s, either to introduce or repair a bug. For this, we factorize this task into localization and rewrite-given-location models, i.e. ",
+        "bbox": [
+            174,
+            464,
+            823,
+            507
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e13f1434c8e948af685abaf2f16c7854cbf7b41c33f14f6c15af31b5c452dc11.jpg",
+        "text": "$$\np \\left( \\langle \\ell , \\rho \\rangle \\mid \\mathrm { s } , R _ { \\mathrm { s } } ^ { \\mathcal { R } } \\right) = p _ { l o c } { \\big ( } \\ell \\mid \\mathrm { s } , R _ { \\mathrm { s } } ^ { \\mathcal { R } } { \\big ) } p _ { r e w } { \\big ( } \\rho \\mid \\ell , \\mathrm { s } , R _ { \\mathrm { s } } ^ { \\mathcal { R } } { \\big ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            315,
+            512,
+            681,
+            532
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We model $p _ { l o c }$ as a probability distribution over the relevant locations $\\{ \\ell \\mid \\langle \\ell , \\rho \\rangle \\in R _ { \\mathrm { s } } ^ { \\mathcal { R } } \\} \\cup \\{ \\mathrm { N o B U G } \\}$ , where NoBug is a special location used to indicate that the code is not buggy. In practice, we implement this similar to a pointer net [19] using the representations $\\mathbfit { \\Delta } \\mathbf { r } _ { \\ell }$ (see Appx. A for details). ",
+        "bbox": [
+            173,
+            540,
+            828,
+            583
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To select rewrites, we use rewrite type-specific learnable rule score functions $w _ { \\rho } \\left( r _ { \\ell } , \\mathcal { M } _ { \\rho } ( \\mathrm { s } , \\ell ) \\right)$ . This function maps a vector representation of an entity $\\mathbf { \\Delta } _ { \\mathbf { \\lambda } ^ { \\mathbf { r } } \\ell }$ and potential additional metadata onto a scalar score. The rule-specific metadata $\\mathcal { M } _ { \\rho } ( \\mathrm { s } , \\ell )$ is defined for some rewrites, e.g. containing representations of other entities that could be used in the location $\\ell$ . We will discuss three concrete rule score functions in Sec. 4. The rewrite probability distribution $p _ { r e w }$ is then modeled by a softmax over the scores of all applicable rewrites at a target location $\\ell$ , i.e. ",
+        "bbox": [
+            173,
+            588,
+            826,
+            671
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/20ddd4085466fb2b98456820b56190ab15c90e6176666923f57291d6acdddecb.jpg",
+        "text": "$$\np _ { r e w } \\left( \\rho \\mid \\ell , \\mathbf { s } , R _ { \\mathbf { s } } ^ { \\mathcal { R } } \\right) = \\operatorname * { s o f t m a x } _ { \\langle \\ell , \\rho ^ { \\prime } \\rangle \\in R _ { \\mathbf { s } } ^ { \\mathcal { R } } } \\left( w _ { \\rho ^ { \\prime } } \\left( r _ { \\ell } , \\mathcal { M } _ { \\rho ^ { \\prime } } ( \\mathbf { s } , \\ell ) \\right) \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            320,
+            678,
+            678,
+            704
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4 A Python Implementation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            720,
+            423,
+            738
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "This section presents an implementation of BUGLAB for Python called PYBUGLAB. PYBUGLAB currently tackles a large subset of “stupid simple bugs” [16]. Fixing these bugs requires small changes to the code, but commonly has significant impact on code correctness. Such bugs may be thought as a form of a typographical mistake or a copy-paste error, and are often relatively hard to locate by humans but obvious after the fact. They are also quite common, as observed in the empirical statistics of Karampatsis and Sutton [16] and Just et al. [14]. Future work may focus on a broader set of rewrite rules or even learnable rewrites, but as we will observe in Sec. 5 more work is needed towards this. Almost all ideas in PYBUGLAB transfer straightforwardly to other programming languages other than Python, but would require some engineering effort to implement. ",
+        "bbox": [
+            173,
+            751,
+            825,
+            877
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "PYBUGLAB Code Entities and Relations In this work, we follow related literature (see Sec. 6 for more) and extract entities and relationships that are readily available by tokenizers, parsers, existing simple program analyses, or other Python-specific program analysis tools. The complete list of entities and relationships can be found in Appx. B and include syntactic entities and relations, relations about the intraprocedural data and control flow, types, and documentation. Some notable entities include SyntaxNodes, Tokens, and Symbols (references to variables and functions). Fig. 4 in Appx. B shows a graph of the entities and relationships of the snippet in Fig. 2. ",
+        "bbox": [
+            173,
+            882,
+            821,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/6fa04aa00a25535c0128e4a64746beb8ef02776ba155a61e8b37f97000e3c308.jpg",
+        "image_caption": [
+            "Figure 2: Code snippet and rewrites available to PYBUGLAB. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            158,
+            94,
+            831,
+            212
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            258,
+            825,
+            328
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 Bug-Inducing PYBUGLAB Rewrite Rules ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            343,
+            501,
+            358
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "PYBUGLAB focuses on four common kinds of bugs. Fig. 2 shows a code snippet and the rewrites allowed for each location, which number 63 even for this small example. ",
+        "bbox": [
+            174,
+            369,
+            823,
+            397
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Variable Misuse Originally defined by Allamanis et al. [3] as a Cloze test for source code, Vasic et al. [30] and Hellendoorn et al. [13] reformulated the task to localizing a variable misuse bug (if any) within a snippet and repairing it. PYBUGLAB uses the latter representation. Variable misuse bugs are common, with $1 2 . 8 \\AA - 1 4 . 8 \\%$ found in the ManySStuBs4J corpus [16] and about $6 \\%$ of them caught during Java compilation in the Google build system [28]. To insert and repair variable misuse bugs, PYBUGLAB supports variable-swapping rewrites, such as in locations $l _ { 1 }$ , $l _ { 3 }$ and $l _ { 4 }$ (amongst others) in Fig. 2. To score a variable-swapping rewrite, we use the representation of the rewrite location $\\mathbfit { \\Delta } \\mathbf { r } _ { \\ell }$ along with the representation $\\mathbf { \\Delta } _ { r _ { \\sigma } }$ of a variable Symbol $\\sigma$ that could replace the current variable, i.e. is in-scope and has been defined before $\\ell$ . The rule score function $w _ { \\rho }$ for replacing the variable at $\\ell$ with the symbol $\\sigma$ is then computed as the inner product $\\boldsymbol { r } _ { \\ell } ^ { \\top } \\boldsymbol { r } _ { \\sigma }$ . ",
+        "bbox": [
+            173,
+            404,
+            826,
+            544
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Argument Swapping (or Argument Selection) First coined by Rice et al. [26], it refers to swapping the arguments of a function invocation, e.g. in $l _ { 6 }$ of Fig. 2. Rice et al. [26] and DeepBugs [22] tackled this problem when all arguments are single identifiers. PYBUGLAB extends this to swapping arbitrary argument expressions. The rule score function $w _ { \\rho }$ for an argument swapping rewrite is a two-layer MLP applied to the concatenation of the output representations of the representation of the parameter and the to-be-swapped arguments arg1, and arg2: MLP $\\left( [ r _ { \\mathrm { p a r a m s } } , r _ { \\mathrm { a r g 1 } } , r _ { \\mathrm { a r g 2 } } ] \\right)$ . ",
+        "bbox": [
+            173,
+            550,
+            825,
+            635
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Wrong Operator Corrupting operators has a long history in mutation testing [14]. Detecting incorrect operators with deep learning was first tackled by DeepBugs [22] by using learnable embeddings of operators, operands and literals for arithmetic and comparison operators. DeepBugs focused only on binary operators. In PYBUGLAB we tackle all binary operators, including Boolean, arithmetic and comparison operators and two unary operators: logical and arithmetic negation. Locations $l _ { 1 1 }$ , $l _ { 1 4 }$ , $l _ { 1 6 }$ , and $l _ { 2 0 }$ in Fig. 2 are rewrites related to wrong operators. The rule score function $w _ { \\rho }$ for an operator rewrite again uses an inner product, $\\boldsymbol { r } _ { \\ell } ^ { \\top } \\boldsymbol { r } _ { \\mathtt { \\diamond p } }$ , where $\\pmb { r } _ { \\tt o p }$ is a learned embedding for operator op. Note that we rewrite operators only to compatible operators (e.g. $<$ to $>$ but not $^ +$ ). ",
+        "bbox": [
+            173,
+            640,
+            825,
+            752
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Wrong Literal Corrupting operands, and specifically, literals appearing in the source code, is also a common strategy in mutation testing. As in mutation testing, PYBUGLAB handles a limited number of commonly used literals, allowing rewrites to replace integer literals within the set of $- 2 , - 1 , 0 , 1 , 2$ and swapping the Boolean literal True with False and vice versa. The scoring function is identical to the operator rewrite, using a learnable embedding ${ \\bf { r } } _ { \\mathrm { { 1 i t } } }$ for each literal lit. ",
+        "bbox": [
+            174,
+            758,
+            825,
+            828
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.2 PYBUGLAB Rewrite Rules for Data Augmentation ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            843,
+            565,
+            858
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We additionally consider more rewrite rules that are not meant to change the program semantics, using them as a form of data augmentation. This is in spirit similar to ideas in computer vision where images are transformed (e.g. rotated, cropped) but maintain their original content. Such rewrites ",
+        "bbox": [
+            174,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Require: Code dataset $C$ , initial detector/selector model parameters $\\theta ^ { ( 0 ) }$ , $\\phi ^ { ( 0 ) }$ ",
+        "bbox": [
+            173,
+            112,
+            686,
+            127
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "1: for meta-epoch $i = 0$ to $I$ do   \n2: // Create dataset of buggy programs:   \n3: $C _ { D } ^ { ( i ) } \\gets \\left\\{ \\left( \\mathrm { s } [ \\rho ] _ { \\ell } , \\left. \\ell , \\rho ^ { - 1 } \\right. \\right) \\mid \\mathrm { s } \\in C , k \\mathrm { \\ s a m p l e s \\ } \\left. \\ell , \\rho \\right. \\sim S _ { \\phi ^ { ( i ) } } ( \\mathrm { s } ) \\right\\}$   \n4: $\\theta ^ { ( i + 1 ) } $ update $\\theta ^ { ( i ) }$ by training $D$ on $C _ { D } ^ { ( i ) }$   \n5: // Create dataset of hard-to-detect bugs:   \n6: $\\begin{array} { r } { C _ { S } ^ { ( i ) } \\gets \\left\\{ \\left( \\mathrm { s } , \\mathrm { a r g } \\operatorname* { m a x } _ { \\langle \\ell , \\rho \\rangle \\in R _ { \\mathrm { s } } ^ { \\mathcal { R } } } \\left( \\mathcal { L } _ { D _ { \\theta ^ { ( i + 1 ) } } } \\left( \\mathrm { s } [ \\rho ] _ { \\ell } , \\langle \\ell , \\rho ^ { - 1 } \\rangle \\right) \\right) \\right) \\mid \\mathrm { s } \\in C \\right\\} } \\end{array}$   \n7: $\\phi ^ { ( i + 1 ) } $ update $\\phi ^ { ( i ) }$ by training $S$ on $C _ { S } ^ { ( i ) }$ ",
+        "bbox": [
+            178,
+            118,
+            686,
+            251
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "have been shown to yield adversarially robust models of code [23]. Although our goal is not to provide adversarial robustness, we believe that such rewrites can help generalization. PYBUGLAB implements the following rewrites for this purpose: ",
+        "bbox": [
+            174,
+            279,
+            825,
+            321
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "• Variable Renaming renames a local variable to a random name not already in scope. • Comment Deletion removes code comments, including docstrings and inline comments. Such comments commonly contain natural language information that is useful for code comprehension, but usually do not affect program semantics. • Comparison Expression Mirroring swaps the two sides of a comparison operator and changes it appropriately. For example, $\\mathtt { a } < \\mathtt { b }$ is transformed to $\\mathtt { b } > \\mathtt { a }$ . Note that in cases such as $\\mathbf { f } \\circ \\circ ( ) \\ < \\ \\mathsf { b a r } ( )$ , this will change the order of execution of foo and bar, possibly altering program semantics. • If-Else Branch Swapping negates the test condition of an if-else statement or a ternary expressions using DeMorgan’s law and swaps the then body with the else body. ",
+        "bbox": [
+            173,
+            332,
+            828,
+            473
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.3 Implementation Details ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            494,
+            377,
+            510
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To make the training computationally tractable we approximate Eq. 1. A simplified, sequential version of our training procedure is shown in Alg. 1. Intuitively, we alternate between training the two models, as the (discrete) sampling of rewrite rules in the selector models precludes direct endto-end training. We first use the current state of the selector model to generate “hard” samples and train the detector model on these samples (we always include the unmodified (i.e., NoBug case) as a sample). Then, we use the loss of the detector model to identify those generated samples that were hardest to detect and train the selector model to produce such samples. ",
+        "bbox": [
+            174,
+            520,
+            825,
+            617
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In practice, we implemented the training procedure as a system of asynchronously communi$C _ { D / S } ^ { ( 0 ) } , \\bar { C } _ { D / S } ^ { ( 1 ) } , \\dots$ , and all of the described steps happen in parallel. We do not use “generations”of datasets, but instead use two constantly updated “pools” of training data, one state of the corresponding data pool. We remove samples from the data pool once they have been sampled $\\nu$ times for use in training, in spirit similar to replay buffers in reinforcement learning. In our experiments, $\\nu$ was set to 4. We regularly (in separate, concurrent processes) take snapshots of the the current state of the $D$ and $S$ models to generate new elements that are updated to the data pools, matching the procedure described in Alg. 1. We approximate the arg max in line 6 by only considering the $k$ samples chosen in line 3 for each input program. During training of $S$ , we then mask out the unobserved choices before computing the loss. ",
+        "bbox": [
+            174,
+            623,
+            826,
+            782
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5 Evaluation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            801,
+            295,
+            819
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We now discuss our new dataset and evaluate PYBUGLAB. We $\\divideontimes$ . . . . . . . . . .highlight. . . . .key . . . . . . . .results. ",
+        "bbox": [
+            174,
+            833,
+            738,
+            849
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Datasets To train PYBUGLAB we retrieve the 4k most downloaded packages in the Python package index (PyPI) and take $3 . 4 \\mathrm { k }$ of them as training packages, using the rest for test purposes. During training, PYBUGLAB installs each package along with all its dependencies. Installing all the dependencies is important for extracting the entities and the relations beyond local syntactic ones (e.g. type inference, method resolution). For each file, PYBUGLAB checks if it is a duplicate of a file that has already been seen in the training following the method of Allamanis [1] and runs all the relevant program analyses to extract the entities and relationships in each function. When we use additional rewrites for data augmentation, these are applied at the input of the PYBUGLAB pipeline as a form of pre-processing. Following Alg. 1, the bug selector $S$ selects $k = 5$ bugs to introduce, rewrites the source code text, and then the program analyses extract the new entities and relationships for the rewritten code snippets. The initial and rewritten code snippets are then used to create the training data for the detector and selector models. ",
+        "bbox": [
+            174,
+            856,
+            825,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            202
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We use two testsets to measure performance. First, we create RANDOMBUGS, a testset of 761 445 snippets derived from functions from the $6 0 0 \\mathrm { P y P I }$ test packages (not seen during training). For each function we find within these packages we add it to the dataset along with 9 rewritten functions with a randomly inserted bug. On average graphs have 260 nodes, 601 edges, 25 rewrite locations, and 130 possible rewrites. We also collect a testset of real bugs. Although we conjecture that, in practice, the vast majority of bugs like those discussed in Sec. 4.1 are fixed when developers locally test their software, a few of those slip and then are fixed across different revisions checked into a version control systems. We have crawled the accessible repositories of all $2 8 5 \\mathrm { k }$ packages in the Python Package Index (PyPI), collected and manually filtered bugs captured by the rewrites from Sec. 4.1. $\\divideontimes$ . . . . .This. . . . . .new . . . . . . . . .dataset, . . . . . . . . . . . . . . .PYPIBUGS,. . . . . . . . . .contains. . . . . . .2374 . . . . . . . . . . . . .real-world,. . . . . . .small . . . . . . .bugs. We describe the data collection process in detail in Appx. D. In addition, we consider PYPIBUGS-PostFix: the examples from PYPIBUGS after a bug was fixed - we believe these samples are very likely to not contain any bugs anymore. We publish the dataset at https://www.microsoft.com/en-us/download/103554 and include it in the supplementary material. ",
+        "bbox": [
+            173,
+            208,
+            825,
+            402
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.1 Quantitative Evaluation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            428,
+            380,
+            443
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Our first experiment aims to evaluate whether the BUGLAB training framework yields more precise bug detectors. We consider two model architectures, using either GNNs or the GREAT transformer to compute embeddings of code entities (architecture details and hyperparameter choices can be found in Appx. A). We use four different training strategies: “supervised” is training only a bug detector on a fixed dataset of 1 million functions from the $3 . 4 \\mathrm { k }$ training packages with randomly inserted bugs. “Random Selector” refers to a variant of PYBUGLAB using a bug selector model that uniformly at random picks a rewrite to insert bugs. Finally, PYBUGLAB and PYBUGLAB $+ \\mathrm { A u g }$ use our framework from Sec. 2, with the latter also using additional rewrites to augment our code corpus. For the fully supervised model, we train with early stopping over a validation set; the other models are trained for a fixed number of 300 epochs (with $2 0 0 \\mathrm { k }$ training samples per epoch) for the bug detector3 and the last detector model is used for evaluation. ",
+        "bbox": [
+            174,
+            457,
+            825,
+            608
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/9a6ef7f5e2c7b5670ec7841f26aeaf6731accd922bc485b255de9a3c978fbd12.jpg",
+        "table_caption": [
+            "Table 1: Accuracies $( \\% )$ for different training strategies and model architectures on RANDOMBUGS. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"3\"></td><td colspan=\"6\">RANDOMBUGS</td></tr><tr><td></td><td>GNN</td><td></td><td></td><td>GREAT</td><td></td></tr><tr><td>Joint</td><td>Loc</td><td>Repair</td><td>Joint</td><td>Loc</td><td>Repair</td></tr><tr><td>Supervised</td><td>62.4</td><td>73.6</td><td>81.2</td><td>51.0</td><td>61.9</td><td>76.3</td></tr><tr><td>Random Selector</td><td>69.4</td><td>79.6</td><td>84.0</td><td>63.9</td><td>73.6</td><td>82.0</td></tr><tr><td>PYBUGLAB</td><td>69.6</td><td>80.4</td><td>84.2</td><td>64.0</td><td>74.3</td><td>82.3</td></tr><tr><td>PYBUGLAB +Aug</td><td>70.3</td><td>81.1</td><td>84.5</td><td>65.3</td><td>75.3</td><td>82.5</td></tr></table>",
+        "bbox": [
+            433,
+            646,
+            821,
+            751
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Effectiveness of BUGLAB Training We first consider the performance of different models on the synthetic RANDOMBUGS dataset. Tbl. 1 shows the accuracy of predicting a full bug repair correctly (“Joint”) and analogous to Eq. 2 break this up into a localization accuracy (“Loc”) of predicting the correct location (or NoBug for correct examples) and a repair accuracy (“Repair”) for selecting the correct rewrite given the buggy location. ",
+        "bbox": [
+            174,
+            616,
+            419,
+            753
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            179,
+            753,
+            617,
+            767
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We observe that $\\divideontimes$ . . . . . . . . . . . . . . . . . . . . .BUGLAB-training. . . . . . .leads. . . .to . . . . . . .more. . . . . . . .robust. . . . . .bug . . . . . . . . . . .detectors. . . . . . . . . . . . .compared. . .to. . . . . . . .other methods .......... for both GNNs and GREAT. Random selector models — a form of data augmentation — improve performance over supervised methods but mostly on in-distribution RANDOMBUGS samples. As expected, $\\divideontimes$ . . . . . . . . . . . . .augmenting. . . . .the . . . . . .code. . . . . . . . .dataset. . . . . . .helps . . . . . . . . . . . . . . . . .generalization, but does not make a substantial difference. Expanding the kinds of rewrites used to augment the data and learning to select them may improve performance in the future. ",
+        "bbox": [
+            173,
+            773,
+            825,
+            859
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/45931fde220989a07d0269fc66c433e7865bbe57c0647970de9be2941d785c74.jpg",
+        "table_caption": [
+            "Table 2: Results for different training strategies and model architectures on PYPIBUGS. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"6\">PYPIBUGS</td><td colspan=\"4\">PYPIBUGS-PostFix</td></tr><tr><td></td><td colspan=\"3\">GNN</td><td colspan=\"3\">GREAT</td><td colspan=\"2\">GNN</td><td colspan=\"2\">GREAT</td></tr><tr><td></td><td>Joint</td><td>Loc</td><td>Repair</td><td>Joint</td><td>Loc</td><td>Repair</td><td>Loc</td><td>Joint AUC</td><td>Loc</td><td>Joint AUC</td></tr><tr><td>Supervised</td><td>20.0</td><td>28.4</td><td>61.8</td><td>16.8</td><td>25.8</td><td>58.6</td><td>17.8</td><td>0.087</td><td>20.7</td><td>0.044</td></tr><tr><td>Random Selector</td><td>21.2</td><td>27.0</td><td>69.2</td><td>20.6</td><td>26.8</td><td>67.2</td><td>47.5</td><td>0.108</td><td>52.5</td><td>0.117</td></tr><tr><td>PYBUGLAB</td><td>24.2</td><td>31.3</td><td>70.7</td><td>24.0</td><td>32.8</td><td>67.9</td><td>32.9</td><td>0.160</td><td>28.6</td><td>0.140</td></tr><tr><td>PYBUGLAB +Aug</td><td>26.4</td><td>33.5</td><td>72.0</td><td>23.2</td><td>29.7</td><td>68.8</td><td>32.6</td><td>0.187</td><td>48.2</td><td>0.129</td></tr></table>",
+        "bbox": [
+            173,
+            103,
+            820,
+            205
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/bd939f82906d67d424796b5296bcfff95df172b83ccdaf77a3cbb3c270dc7c2c.jpg",
+        "table_caption": [
+            "Table 3: Localization and Repair Accuracy $( \\% )$ per bug kind for the PYBUGLAB +Aug model. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"3\">Bug Type</td><td colspan=\"4\">RANDOMBUGS</td><td colspan=\"4\">PYPIBUGS</td></tr><tr><td colspan=\"2\">GNN</td><td colspan=\"2\">GREAT</td><td colspan=\"2\">GNN</td><td colspan=\"2\">GREAT</td></tr><tr><td>Loc</td><td>Repair</td><td>Loc</td><td>Repair</td><td>Loc</td><td>Repair</td><td>Loc</td><td>Repair</td></tr><tr><td>Argument Swapping</td><td>85.0</td><td>57.3</td><td>65.5</td><td>57.2</td><td>33.2</td><td>73.9</td><td>24.3</td><td>72.7</td></tr><tr><td>Wrong Assign Op</td><td>96.1</td><td>99.1</td><td>94.5</td><td>98.6</td><td>20.0</td><td>68.9</td><td>14.0</td><td>58.1</td></tr><tr><td>Wrong Binary Op</td><td>83.0</td><td>85.2</td><td>77.3</td><td>81.4</td><td>27.2</td><td>54.3</td><td>36.6</td><td>43.7</td></tr><tr><td>Wrong Boolean Op</td><td>71.8</td><td>99.5</td><td>43.6</td><td>99.5</td><td>27.6</td><td>96.9</td><td>15.7</td><td>97.2</td></tr><tr><td>Wrong Comparison Op</td><td>83.9</td><td>79.3</td><td>80.0</td><td>76.4</td><td>33.7</td><td>66.1</td><td>31.1</td><td>53.5</td></tr><tr><td>Wrong Literal</td><td>71.7</td><td>74.7</td><td>66.6</td><td>71.6</td><td>21.6</td><td>78.4</td><td>17.9</td><td>79.5</td></tr><tr><td>Variable Misuse</td><td>84.9</td><td>88.4</td><td>78.2</td><td>86.3</td><td>35.3</td><td>70.5</td><td>34.0</td><td>69.4</td></tr><tr><td>NoBUG</td><td>53.8</td><td></td><td>62.5</td><td></td><td></td><td></td><td></td><td></td></tr></table>",
+        "bbox": [
+            173,
+            234,
+            823,
+            404
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Furthermore, $\\ast { \\mathrm { l o u g } } .$ . . . . . . . . . . . . . .localization . . .is . . . . . . .much . . . . . . . .harder. . . . . .than . . . . . . . .repair . . .at . .a . . . . . . .given . . . . . . . . . .location. This is somewhat expected: there are many more candidate locations compared to potential repairs at a given location. However, this suggests that research should focus on the localization problem rather than repair. ",
+        "bbox": [
+            174,
+            429,
+            825,
+            473
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We now turn to the results on PYPIBUGS, shown in Tbl. 2, which also includes the accuracy of choosing the special NoBug location on the PYPIBUGS-PostFix dataset, as well as the area under the precision recall curve for the results on both PYPIBUGS and PYPIBUGS-PostFix. ",
+        "bbox": [
+            176,
+            478,
+            821,
+            521
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We find that $\\divideontimes$ . . . . . . . . . .detecting. . . . .and. . . . . . . . . . . .repairing . . . . . . . . .real-life. . . . . . .bugs . .is. . . . . . . . . . . . . . .significantly. . . . . . . .harder. . . . . .than. . . . . . . . . . .handling . . . . . . . . . . . .randomly . . . . . . . . .inserted. . . . . .bugs. As PYBUGLAB models trained using a learned bug selector outperform those using a “Random Selector”, we speculate that the learned selector avoids generating easy-to-detect bugs, focusing the detector model on recognizing deeper semantic patterns. Despite this, improvements in RANDOMBUGS often correlate with improvements in PYPIBUGS. This is encouraging: collecting PYPIBUGS-like datasets is costly; corpora with random bugs can help measure relative improvements to some extent. Finally, we find that $\\divideontimes$ . . . . . . . . . . . . . .recognizing . . . . . . . . . . . . .non-buggy . . . . . . . . . .samples. . .is . . . . . .very . . . . . .hard, and in particular, does not always profit from training in PYBUGLAB. ",
+        "bbox": [
+            173,
+            526,
+            826,
+            641
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In our qualitative analysis (Sec. 5.2), we observed that the models raised some confident but incorrect warnings at very “odd” locations. However, these warnings were different across models. We have tested an ensembling strategy averaging the output probabilities of five separately trained GNN models. This results in localization and repair accuracies of $8 3 . 0 \\%$ and $8 5 . 4 \\%$ on RANDOMBUGS (vs. $8 1 . 1 \\%$ and $8 4 . 5 \\%$ ) and $3 4 . 4 \\%$ and $7 2 . 2 \\%$ on PYPIBUGS (vs. $3 3 . 5 \\%$ and $7 2 . 0 \\%$ ). As we discuss in Sec. 5.2 finding the cause of the “spurious” warnings is important future work. ",
+        "bbox": [
+            174,
+            647,
+            825,
+            731
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Per-Bug Evaluation To better understand which bugs are hard to detect, we break down the results the best-performing PYBUGLAB $+ \\mathrm { A u g }$ models on RANDOMBUGS by type of bug in Tbl. 3. We observe that incorrect literals are some of the hardest bugs to detect. Incorrect assignment operators $( e . g . = \\mathrm { a n d } + = )$ ) are easy to detect in RANDOMBUGS, but significantly harder in PYPIBUGS. This may be attributed to class imbalance, with simple assignment $( = )$ being the majority class. $\\divideontimes$ Detecting . . . . . . . . . . . . . .if .a. . . . . . . . .snippet. . . . .has . .a . . . . .bug . . .or . . . .not. . . . . . . .seems . . .to . . .be. . . .the. . . . . . . . .hardest. . . . . .task:. . . .no. . . . . . . .model . . . . . . . . . .achieves. . . . . . . . . . .accuracy. . . . . . . . .beyond. $6 3 \\%$ . ",
+        "bbox": [
+            173,
+            737,
+            825,
+            824
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We note that in our experiments, GNNs-based models seem to often outperform GREAT, somewhat contradicting the results of Hellendoorn et al. [13]. We have performed substantial additional experiments to investigate and verify these results, cf. Sec. A.2. This may have to do with the performance of these models on long sequences or that the GNN has access to more fine-grained information, instead of relations over the projected token sequences. For example, this could be attributed to the lack of syntax and symbol nodes in the representation used in GREAT. Nevertheless, GREAT is noticeably better ( $6 2 . 5 \\%$ vs. $5 3 . 8 \\%$ ) at detecting NoBug and locating wrong binary operators in PYPIBUGS. ",
+        "bbox": [
+            174,
+            827,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/8037918e569bcf21bec36b8e0c64c703d98d376bc99408953d5a9a1d383a3d17.jpg",
+        "table_caption": [
+            "Table 5: Bug distribution $( \\% )$ in different datasets "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Bug Kind</td><td>PYPIBUGS</td><td>RANDOMBUGS</td><td>Selector Samples</td></tr><tr><td>Argument Swapping</td><td>11.9</td><td>8.4</td><td>23.8</td></tr><tr><td>Wrong Assignment</td><td>1.9</td><td>8.5</td><td>5.3</td></tr><tr><td>Wrong Binary Operator</td><td>3.4</td><td>2.4</td><td>2.3</td></tr><tr><td>Wrong Boolean Operator</td><td>8.1</td><td>2.2</td><td>6.4</td></tr><tr><td>Wrong Comparison Operator</td><td>17.1</td><td>8.2</td><td>7.4</td></tr><tr><td>Wrong Literal</td><td>3.7</td><td>11.6</td><td>12.4</td></tr><tr><td>Variable Misuse</td><td>53.8</td><td>58.6</td><td>42.5</td></tr></table>",
+        "bbox": [
+            215,
+            103,
+            782,
+            229
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            272,
+            823,
+            300
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Bug Selector Performance To understand how training of the bug selector proceeds, we perform two experiments. In our first experiment, we take a snapshot of the selector model during training of the PYBUGLAB $+ \\mathrm { A u g }$ (GNN) model every 24 hours, after an initial burn-in phase of 12 hours. We then generate 10000 buggy samples using each of these snapshots and then test a fixed model on each of these snapshots. The results of this are shown in Tbl. 4, using a fully trained PYBUGLAB $+ \\mathrm { A u g }$ (GNN) model from another training run as a fixed model. We conclude that . . . . . . . . . . . . . . . . . . . . . . . . .PYBUGLAB succeeds. . . .in . . . . . . . . . .learning . . .to . . . . . . . . . .generate. . . . . . . .harder. . .to find ..........bugs, though we can observe the selector model trading off “harder-to-localize” and “harder-tofix” properties. Tests on other models show similar trends, confirming the robustness of this result. ",
+        "bbox": [
+            174,
+            306,
+            549,
+            460
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            462,
+            825,
+            488
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/c3149cb1f9f5d33fffe426f0377edd65043e8b7a01d9e6d5a8af81a8671b2daa.jpg",
+        "table_caption": [
+            "Table 4: Development of Performance on Bug Selector Samples "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Training&#x27; Time</td><td>Joint</td><td>Loc</td><td>Repair</td></tr><tr><td>0.5 days</td><td>64.2</td><td>83.8</td><td>72.1</td></tr><tr><td>1.5 days</td><td>62.5</td><td>80.7</td><td>72.9</td></tr><tr><td>2.5 days</td><td>62.0</td><td>83.0</td><td>69.8</td></tr><tr><td>3.5 days</td><td>61.7</td><td>82.5</td><td>69.8</td></tr><tr><td>4.5 days</td><td>61.9</td><td>83.0</td><td>69.5</td></tr><tr><td>5.5 days</td><td>61.1</td><td>83.0</td><td>68.6</td></tr><tr><td>6.5 days</td><td>60.5</td><td>78.7</td><td>72.4</td></tr></table>",
+        "bbox": [
+            560,
+            332,
+            823,
+            459
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In a second experiment, we compare the distribution of different bug kinds in PYPIBUGS and RANDOMBUGS with the distribution of bugs sampled from the final snapshot of our selector model from above. The results are shown in Tbl. 5, where we can see that a number of bugs (argument swapping, use of wrong literals and of assignment operators) are substantially over-represented, whereas mistakes in comparison operators and variable misuse are under-represented. This indicates that . . . . . . . . . . . . . . . . . . . . . . . . . .PYBUGLAB generates. . . . . .hard . . .to . . . . . .find, . . . .but. . . .not. . . . . . . . . . . . . .necessarily . . . . . . . . . .realistic . . . . . .bugs. ",
+        "bbox": [
+            174,
+            494,
+            826,
+            579
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Comparison to CuBERT Finally, we compare our models to CuBERT [15], which uses a masked language modeling objective to pre-train a BERT-like model and then learns bug detectors specific to a class of bugs (e.g., wrong binary operators) on top of this pre-trained model. Note that CuBERT detects $i f$ a bug exists but does not localize it. For the comparison, we create two sub-datasets of PYPIBUGS: PYPIBUGS-WrongOp contains the 501 samples that involve the binary operators supported by CuBERT, and PYPIBUGS-VarMisuse, which contains the 1278 bugs that involve variable misuses. We complete both of these datasets with 501 (resp. 1278) random NoBug code samples from our RANDOMBUGS, to match the 1:1 buggy/non-buggy distribution used in CuBERT’s training. Since CuBERT classification models focus on a single bug type, to compare to PYBUGLAB we mask out all code locations that do not correspond to a bug that could be detected by the corresponding CuBERT model. We then treat the prediction of the NoBug location as a “non-buggy” prediction and all other locations as a “buggy” prediction. For example, for the snippet in Fig. 2, only the locations $l _ { 2 }$ , $l _ { 1 1 }$ , $l _ { 1 4 }$ , $l _ { 1 6 }$ , and $l _ { 2 0 }$ and their corresponding rewrites are considered by PYBUGLAB for the comparison on PYPIBUGS-WrongOp. ",
+        "bbox": [
+            173,
+            585,
+            826,
+            779
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Tbl. 6 shows the results of comparing the released CuBERT snapshots with the PYBUGLAB +Aug GNN model. We observe that $\\divideontimes$ . . . .the . . . . . . . . . . . . . . . . . . . . . . . . .PYBUGLAB models ",
+        "bbox": [
+            173,
+            785,
+            356,
+            871
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/55b3364d400dfb104c428ee8540f8da946936e41c3e3c9c9a4e40abf08959203.jpg",
+        "table_caption": [
+            "Table 6: Comparison with CuBERT [15] "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td colspan=\"3\">CuBERT</td><td colspan=\"3\">PYBUGLAB (GNN)</td></tr><tr><td>Prec</td><td>Recall</td><td>F1</td><td>Prec</td><td>Recall</td><td>F1</td></tr><tr><td>PYPIBUGs-WrongOp</td><td>0.764</td><td>0.251</td><td>0.378</td><td>0.730</td><td>0.764</td><td>0.746</td></tr><tr><td>PYPIBUGS-VarMisuse</td><td>0.632</td><td>0.403</td><td>0.493</td><td>0.740</td><td>0.840</td><td>0.787</td></tr></table>",
+        "bbox": [
+            364,
+            796,
+            823,
+            864
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": ". . . . .have. . . . . . . . . . . . . . . .substantially . . . . . . .better. . . . . . .recall. . . . . .than. . . . . . . . . . . . . . . . . . .CuBERT-based . . . . . . . . .models, even though they were trained to detect more bug types. When calibrating the CuBERT models to have a recall equal to PYBUGLAB, heir precision drops substantially. In particular, on PYPIBUGS-WrongOp, it is reduced to 0.609, and ",
+        "bbox": [
+            181,
+            869,
+            826,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "1 def make_id(name):   \n2 $\\mathbf { r } \\ =$ get_rand_string(12)   \n3 if len(name) <= 22:   \n4 name $=$ name[:22]   \n5 return name $\\textrm { + } \\textrm { -- } \\textrm { + } \\textrm { \\pmb { r } }$ (a) A wrong comparison operator bug (red box) in PYPIBUGS detected and repaired by the GNN PYBUGLAB +Aug models. ",
+        "bbox": [
+            163,
+            108,
+            468,
+            213
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "1 def update(self, roomId,   \n2 title, \\*\\*request_params):   \n3 check_type(roomId, basestring)   \n4 check_type(roomId, basestring)   \n5 [...] ",
+        "bbox": [
+            486,
+            97,
+            774,
+            160
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "(b) A variable misuse (red box) caught in an open-source project. GNN PYBUGLAB $+ \\mathrm { A u g }$ suggests to rewrite roomId to title. The fixing pull request is found here. ",
+        "bbox": [
+            496,
+            174,
+            825,
+            213
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Figure 3: Bugs found by PYBUGLAB. Snippets reformatted and abbreviated to fit figure. ",
+        "bbox": [
+            207,
+            220,
+            789,
+            236
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "on PYPIBUGS-VarMisuse, it is reduced to 0.613; in both cases, PYBUGLAB outperforms CuBERT substantially. ",
+        "bbox": [
+            173,
+            277,
+            825,
+            306
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.2 Qualitative Inspection of Raised Warnings ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            338,
+            508,
+            354
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We now take a qualitative look at the raised warnings raised by PYBUGLAB. As example, Fig. 3a shows a sample of PYPIBUGS where the developer used an incorrect comparison operator. Once pointed to it, it is clear to a human that the truncation statement in line 4 has no effect (under the reasonable assumption that name is a string), and that a different comparison operator $( > )$ is necessary. ",
+        "bbox": [
+            174,
+            372,
+            825,
+            428
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "To gain an understanding of the performance of PYBUGLAB on realistic data, we performed an indepth analysis of the cases flagged as bugs by our best-performing model on the code found within the 4k top PyPI packages. We observed a mixture of false positives with few previously unseen real-life bugs, matching the quantitative results in Tbl. 3. First, we find that the majority of the false positives are “incorrect literal” detections. This suggests that learning to detect such bugs is a hard problem. Furthermore, many literals serve as default “configurations” (e.g. the number of retries for a network request) and different values are not bugs. We posit that a large percentage of literal replacements the selector learns to make fall in this category. ",
+        "bbox": [
+            174,
+            434,
+            825,
+            545
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We also found that some repairs suggested by the model actually produce semantically equivalent code. For example, the model lacks knowledge that two variables refer to the same object in memory (aliasing), and so attempts to “repair” variable misuse bugs by switching between these. Other examples includes checking the return values of standard functions such as Python’s str.find, which returns $^ { - 1 }$ if the query string is not found. In such cases, PYBUGLAB often suggested to rewrite an if $\\mathbf { x } \\lrcorner \\mathbf { f i n d } ( \\mathbf { y } ) \\ \\ll \\ - 1$ to if $\\mathbf { x } \\lrcorner \\mathbf { f i n d } ( \\mathbf { y } ) \\ = - 1$ , which makes no difference in practice. These false negatives can be attributed to the fact that the bug selector model considers such changes as introducing bugs, even though they are not actually changing behavior. This suggests that for better results, the rewrite rules need to ensure that the rewrites are not semantics-preserving and represent bugs. ",
+        "bbox": [
+            173,
+            551,
+            825,
+            689
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Finally, some reported issues were sufficiently complex that it took us (the human authors) a couple of minutes of thought to conclude that a warning is spurious. Simultaneously, there are some warnings that are “obviously” incorrect to us, but the reasons why the neural models raise them is unclear. This highlights the importance of research on explainability techniques along with better ways to calibrate model confidence. The fact that selectors may introduce spurious “bugs” may also be affecting how the detector model learns. Ideas that have appeared in reinforcement learning, such as the one of Dennis et al. [8], may allow models to improve their performance in spite of spurious bugs. ",
+        "bbox": [
+            174,
+            695,
+            825,
+            792
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Overall, $\\yen 123,456,7$ . . .of. . . . .the . . . . . .1000. . . . . . . . . . .reported . . . . . . . . . . .warnings . . . . . .were. . . . . . . .found . . .to . . .be. . . . . . . . . .real-life. . . . . . .bugs. Of these 19, we reported 11 on GitHub (6 already merged, 5 pending approval). See Appx. G for details. 3 other bugs had already been fixed between the version PYBUGLAB processed and the current version or the project was deprecated, whereas another 5 bugs are minor and we decided not to report them. One of the detected bugs is shown in Fig. 3b. Overall, most of the detected bugs appear within unit tests, logging, or exception handling, possibly because bugs there do not impact the core functionality of a project. However, given the number of such bugs we collected in PYPIBUGS, we believe that such bugs arise equally often in other code, but that they are detected and fixed more quickly. ",
+        "bbox": [
+            174,
+            799,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Although our analysis only forms a lower bound on the precision of PYBUGLAB and related methods, it suggests that there is still ample room for future improvements towards making machine learningbased bug detection and repair practically useful. ",
+        "bbox": [
+            174,
+            90,
+            825,
+            133
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            152,
+            321,
+            170
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Detecting bugs in source code has been researched since the early days of computing. Traditionally, bug detection is tackled as a formal task, where any code that cannot be proved to satisfy some correctness property may contain a bug. This is essential for security- and safety-critical bugs, but not for other — equally common — bugs. In the last decade, software engineering and programming language research have increasingly realized ambiguous information within code (e.g. variable names, comments) contains valuable information and using this information can yield valuable results [2]. The main premise is that patterns in source code, such as patterns in names, control, and data flow can be informative. This information can also be exploited to detect some bugs. For example, Ray et al. [24] noted that even simple language models tend to assign lower probability to buggy code. ",
+        "bbox": [
+            174,
+            185,
+            825,
+            310
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Multiple static analysis methods have been researched that combine some form of data-oriented bug detection. This ranges from language model-based tools, such as the early work of Wang et al. [32] to specification-mining tools such as the work of Eberhardt et al. [10]. BUGLAB is related to DeepBugs [22] which uses an MLP over a limited window of code tokens and train separate models to detect wrong operators, operands, and argument swappings. BUGLAB opts for a more structured representation of code and a single model. Allamanis et al. [3], Vasic et al. [30], Hellendoorn et al. [13] tackle variable misuse bugs (one of the kinds of bugs included in PYBUGLAB) but either by randomly introducing the bugs in code or using a Cloze-like test. Instead, BUGLAB opts for a selfsupervised approach and tackles a broader range of bugs. Concurrently to this work, Patra and Pradel [21] showed an alternative method for learning to generate realistic bugs. Dinella et al. [9] learn a supervised sequential model that performs graph transformations that replicate small edits in code (refactoring, introducing functionality, bug fixing, etc.). Their model — Hoppity — could serve as a learnable rewrite operation in BUGLAB in future work. Dynamic analysis methods have also been researched with promising results [31], but collecting representative dynamic traces over a diverse set of programs at scale (e.g. from the top Python packages used in this work) is practically impossible. ",
+        "bbox": [
+            174,
+            316,
+            826,
+            523
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "BUGLAB is related to ideas around self-supervised learning recently explored in deep learning, computer vision, and NLP. In our case, we aim to train a bug detection model without using training data from real-life bugs. BUGLAB resembles ELECTRA [6], with the important difference that the rewrites to the input code go beyond single token replacement that need to respect strict constraints of programming languages (syntax, variable scopes) and the model is directly used for bug detection, rather than for pre-training. The main BUGLAB objective Eq. 1 also resembles GANs [12] with the exception that the objective is non-differentiable (introducing a bug alters the discrete data representation), the selector is a structured probabilistic code rewriting model, and that we are mainly interested in the bug detector (analogous to the discriminator) rather than the selector. ",
+        "bbox": [
+            174,
+            529,
+            825,
+            655
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "7 Discussion and Conclusions ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            674,
+            434,
+            691
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Learned program analyses offer the promise to improve how we develop software. They also offer a great opportunity to study machine learning models that combine formal and probabilistic reasoning. Towards achieving these we presented BUGLAB, a self-supervised approach for learning program analyses, that improves upon baseline methods and detects bugs in real-life code. We also empirically show the limitations of existing bug-detecting machine learning methods, which suffer from impractical false-positive rates. Importantly, we show the large gap of performance of existing methods on corpora of randomly inserted bugs — commonly used in prior work — and real-life bugs. ",
+        "bbox": [
+            174,
+            705,
+            826,
+            804
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgements ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            824,
+            338,
+            840
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We want to thank Sebastian Nowozin and Marwin Segler for helpful discussions, Marwin Segler for comments on a draft of this work, and the anonymous reviewers for useful questions and suggestions. Finally, we would like to thank the contributors to the following open-source tools used: PyTorch [20], PyDriller [27], MessagePack, LibCST, Jedi, Kubernetes, Helm. ",
+        "bbox": [
+            176,
+            856,
+            826,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References   \n[1] M. Allamanis. The adverse effects of code duplication in machine learning models of code. In Proceedings of the 2019 ACM SIGPLAN International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software, pages 143–153, 2019.   \n[2] M. Allamanis, E. T. Barr, P. Devanbu, and C. Sutton. A survey of machine learning for big code and naturalness. ACM Computing Surveys (CSUR), 51(4):1–37, 2018.   \n[3] M. Allamanis, M. Brockschmidt, and M. Khademi. Learning to represent programs with graphs. In International Conference on Learning Representations (ICLR), 2018.   \n[4] M. Allamanis, E. Barr, S. Ducousso, and Z. Gao. Typilus: Neural type hints. In Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI), pages 91–105. Association for Computing Machinery (ACM), 2020.   \n[5] T. Bachlechner, B. P. Majumder, H. H. Mao, G. W. Cottrell, and J. McAuley. Rezero is all you need: Fast convergence at large depth. arXiv preprint arXiv:2003.04887, 2020.   \n[6] K. Clark, M.-T. Luong, Q. V. Le, and C. D. Manning. ELECTRA: Pre-training text encoders as discriminators rather than generators. arXiv preprint arXiv:2003.10555, 2020.   \n[7] M. Cvitkovic, B. Singh, and A. Anandkumar. Deep learning on code with an unbounded vocabulary. In Machine Learning 4 Programming, 2018.   \n[8] M. Dennis, N. Jaques, E. Vinitsky, A. Bayen, S. Russell, A. Critch, and S. Levine. Emergent complexity and zero-shot transfer via unsupervised environment design. arXiv preprint arXiv:2012.02096, 2020.   \n[9] E. Dinella, H. Dai, Z. Li, M. Naik, L. Song, and K. Wang. Hoppity: Learning graph transformations to detect and fix bugs in programs. In International Conference on Learning Representations, 2019.   \n[10] J. Eberhardt, S. Steffen, V. Raychev, and M. Vechev. Unsupervised learning of API aliasing specifications. In Proceedings of the 40th ACM SIGPLAN Conference on Programming Language Design and Implementation, pages 745–759, 2019.   \n[11] J. Gilmer, S. S. Schoenholz, P. F. Riley, O. Vinyals, and G. E. Dahl. Neural message passing for quantum chemistry. In International Conference on Machine Learning, pages 1263–1272, 2017.   \n[12] I. J. Goodfellow, J. Pouget-Abadie, M. Mirza, B. Xu, D. Warde-Farley, S. Ozair, A. Courville, and Y. Bengio. Generative adversarial networks. arXiv preprint arXiv:1406.2661, 2014.   \n[13] V. J. Hellendoorn, C. Sutton, R. Singh, P. Maniatis, and D. Bieber. Global relational models of source code. In International Conference on Learning Representations, 2020.   \n[14] R. Just, D. Jalali, L. Inozemtseva, M. D. Ernst, R. Holmes, and G. Fraser. Are mutants a valid substitute for real faults in software testing? In Proceedings of the 22nd ACM SIGSOFT International Symposium on Foundations of Software Engineering, pages 654–665, 2014.   \n[15] A. Kanade, P. Maniatis, G. Balakrishnan, and K. Shi. Learning and evaluating contextual embedding of source code. In International Conference on Machine Learning (ICML), 2020.   \n[16] R.-M. Karampatsis and C. Sutton. How often do single-statement bugs occur? the ManySStuBs4J dataset. In Proceedings of the 17th International Conference on Mining Software Repositories, pages 573–577, 2020.   \n[17] J. Katz. Libraries.io Open Source Repository and Dependency Metadata, Jan. 2020. URL https://doi.org/10.5281/zenodo.3626071.   \n[18] Y. Li, D. Tarlow, M. Brockschmidt, and R. Zemel. Gated graph sequence neural networks. In International Conference on Learning Representations (ICLR), 2016. ",
+        "bbox": [
+            171,
+            87,
+            830,
+            922
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[19] S. Merity, C. Xiong, J. Bradbury, and R. Socher. Pointer sentinel mixture models. In International Conference on Learning Representations (ICLR), 2017. ",
+        "bbox": [
+            171,
+            90,
+            826,
+            121
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[20] A. Paszke, S. Gross, S. Chintala, G. Chanan, E. Yang, Z. DeVito, Z. Lin, A. Desmaison, L. Antiga, and A. Lerer. Automatic differentiation in PyTorch. 2017.   \n[21] J. Patra and M. Pradel. Semantic bug seeding: a learning-based approach for creating realistic bugs. In Proceedings of the 29th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering, pages 906–918, 2021.   \n[22] M. Pradel and K. Sen. DeepBugs: A learning approach to name-based bug detection. Proceedings of the ACM on Programming Languages, 2(OOPSLA):1–25, 2018.   \n[23] G. Ramakrishnan, J. Henkel, Z. Wang, A. Albarghouthi, S. Jha, and T. Reps. Semantic robustness of models of source code. arXiv preprint arXiv:2002.03043, 2020.   \n[24] B. Ray, V. Hellendoorn, S. Godhane, Z. Tu, A. Bacchelli, and P. Devanbu. On the ”naturalness” of buggy code. In 2016 IEEE/ACM 38th International Conference on Software Engineering (ICSE), pages 428–439. IEEE, 2016.   \n[25] V. Raychev, M. Vechev, and A. Krause. Predicting program properties from Big Code. In Principles of Programming Languages (POPL), 2015.   \n[26] A. Rice, E. Aftandilian, C. Jaspan, E. Johnston, M. Pradel, and Y. Arroyo-Paredes. Detecting argument selection defects. Proceedings of the ACM on Programming Languages, 1(OOPSLA): 1–22, 2017.   \n[27] D. Spadini, M. Aniche, and A. Bacchelli. PyDriller: Python framework for mining software repositories. In Proceedings of the 2018 26th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering - ESEC/FSE 2018, pages 908–911, New York, New York, USA, 2018. ACM Press. ISBN 9781450355735. doi: 10.1145/3236024.3264598. URL http://dl.acm.org/citation. cfm?doid $\\equiv$ 3236024.3264598.   \n[28] D. Tarlow, S. Moitra, A. Rice, Z. Chen, P.-A. Manzagol, C. Sutton, and E. Aftandilian. Learning to fix build errors with Graph2Diff neural networks. In Proceedings of the IEEE/ACM 42nd International Conference on Software Engineering Workshops, pages 19–20, 2020.   \n[29] H. Touvron, M. Cord, A. Sablayrolles, G. Synnaeve, and H. Jegou. Going deeper with image ´ transformers. arXiv preprint arXiv:2103.17239, 2021.   \n[30] M. Vasic, A. Kanade, P. Maniatis, D. Bieber, and R. Singh. Neural program repair by jointly learning to localize and repair. arXiv preprint arXiv:1904.01720, 2019.   \n[31] K. Wang and Z. Su. Blended, precise semantic program embeddings. In Proceedings of the 41st ACM SIGPLAN Conference on Programming Language Design and Implementation, pages 121–134, 2020.   \n[32] S. Wang, D. Chollak, D. Movshovitz-Attias, and L. Tan. Bugram: bug detection with n-gram language models. In Proceedings of the 31st IEEE/ACM International Conference on Automated Software Engineering, pages 708–719, 2016.   \n[33] J. Wei, M. Goyal, G. Durrett, and I. Dillig. LambdaNet: Probabilistic type inference using graph neural networks. arXiv preprint arXiv:2005.02161, 2020. ",
+        "bbox": [
+            169,
+            98,
+            828,
+            785
+        ],
+        "page_idx": 11
+    }
+]

parse/train/Hk91SGWR-/Hk91SGWR-.md

@@ -0,0 +1,200 @@
+# INVESTIGATING HUMAN PRIORS FOR PLAYING VIDEO GAMES
+
+Rachit Dubey, Pulkit Agrawal, Deepak Pathak, Thomas L. Griffiths, and Alexei A. Efros
+
+University of California, Berkeley
+
+# ABSTRACT
+
+What makes humans so good at solving seemingly complex video games? Unlike computers, humans bring in a great deal of prior knowledge about the world, enabling efficient decision making. This paper investigates the role of human priors for solving video games. Given a sample game, we conduct a series of ablation studies to quantify the importance of various priors. We do this by modifying the video game environment to systematically mask different types of visual information that could be used by humans as priors. We find that removal of some prior knowledge causes a drastic degradation in the speed with which human players solve the game, e.g. from 2 minutes to over 20 minutes. Furthermore, our results indicate that general priors, such as the importance of objects and visual consistency, are critical for efficient game-play.
+
+# 1 INTRODUCTION
+
+While deep Reinforcement Learning (RL) methods have shown impressive performance on a variety of video games (Mnih et al., 2015), they remain woefully inefficient compared to human players, taking millions of action inputs to solve even the simplest Atari games. Much research is currently focused on improving sample efficiency of RL algorithms (Oh et al., 2017; Gu et al., 2016). However, there is an orthogonal issue that is often overlooked: RL agents attack each problem tabula rasa, whereas humans come in with a wealth of prior knowledge about the world, from physics to semantics to affordances.
+
+Consider the following motivating example: you are tasked with playing an unfamiliar computer game shown in Figure 1(a). No manual or instructions are provided; you don’t even know which game sprite is controlled by you. Indeed, the only feedback you are ever given is “terminal”, i.e. once you successfully finish the game. Would you be able to successfully finish this game? How long would it take? We recruited forty human subjects to play this game and found that subjects finished it quite easily, taking just under 1 minute of game-play or 3000 action inputs. This is not overly surprising as one could easily guess that the game’s goal is to move the robot sprite towards the princess by stepping on the brick-like objects and using ladders to reach the higher platforms while avoiding the angry pink and the fire objects.
+
+Now consider a second scenario in which this same simple game is re-rendered with new textures, getting rid of semantic and affordance (Gibson, 2014) cues, as shown in Figure 1(b). How would human performance change? We recruited another forty subjects to play this game and found that, on average, it took the players more than twice the time (2 minutes) and action inputs ( 6500) to complete the game. The second game is clearly much harder for humans, likely because it is now more difficult to guess the game structure and goal, as well as to spot obstacles.
+
+For comparison, we can also examine how modern RL algorithms perform on these games. This is not so simple, as most standard RL approaches expect very dense rewards (e.g. continuously updated game-score (Mnih et al., 2015)), whereas we provide only a terminal reward, to mimic how most humans play video games. In such sparse reward scenarios, standard methods like A3C (Mnih et al., 2016) are too sample-inefficient and were too slow to finish the games. Hence, we used a curiosity-based RL algorithm specifically tailored to sparse-reward settings (Pathak et al., 2017), which was able to solve both games. Unlike humans, RL did not show much difference between the two games, taking about 4 million action inputs to solve each one. This should not be surprising: since RL did not have any prior knowledge about the world, both these games carried roughly the same amount of information from the perspective of the agent.
+
+![](images/c37716b0322148eb37283fbdf8219c7d957917a639ec67d4635058d95679c3ed.jpg)  
+Figure 1: Motivating example. (a) A simple platformer game. (b) The same game modified by re-rendering the textures. Despite the two games being structurally the same, human players took twice as long to finish the second game as the first one. In comparison, the performance of an RL agent was approximately the same for the two games.
+
+This simple motivating experiment highlights the importance of prior knowledge that humans draw upon to quickly solve tasks given to them (Lake et al., 2016; Tsividis et al., 2017). Developmental psychologists have begun documenting the prior knowledge that children draw upon in learning about the world (Spelke & Kinzler, 2007; Carey, 2009). However, these studies have not explicitly quantified the relative importance of the various priors for problem-solving.
+
+In this work, we systematically quantify the importance of different types of priors humans bring to bear while solving one particular kind of problem – video games. We chose video games as the task for our investigation because it is relatively easy to methodically change the game to include or mask different kinds of knowledge and run large-scale human studies. Furthermore, video games, such as ATARI, are a popular choice in the reinforcement learning community.
+
+The paper consists of a series of ablation studies on a specially-designed game environment, systematically masking out various types of visual information that could be used by humans as priors. The full game (unlike the motivating example above) was designed to be sufficiently complex and difficult for humans to easily measure changes in performance between different testing conditions.
+
+We find that removal of some prior knowledge causes a drastic degradation in the performance of human players from 1 minute to over 20 minutes. Another key finding of our investigation is that while specific knowledge, such as “ladders are to be climbed”, “keys are used to open doors”, “jumping on spikes is dangerous”, is important for humans to quickly solve games, more general priors about the importance of objects and visual consistency are even more critical.
+
+# 2 METHOD
+
+To investigate the aspects of visual information that enable humans to efficiently solve video games, we designed a browser-based platform game consisting of an agent sprite, platforms, ladders, angry pink object that kills the agent, spikes that are dangerous to jump on, a key, and a door (see Figure 2 (a)). The agent sprite can be moved with the help of arrow keys. A terminal reward of $+ 1$ is provided when the agent reaches the door after having to taken the key, thereby terminating the game. The game is reset whenever the agent touches the enemy, jumps on the spike, or falls below the lowest platform. We made this game to resemble the exploration problems faced in the classic ATARI game of Montezuma’s Revenge that has proven to be very challenging for deep reinforcement learning techniques (Bellemare et al., 2016; Mnih et al., 2015). Unlike the motivating example, this game is too large-scale to be solved by RL agents, but provides the complexity we need to run a wide range of human experiments.
+
+We created different versions of the video game by re-rendering various entities such as ladders, enemies, keys, platforms etc. using alternate textures (Figure 2). These textures were chosen to mask various forms of prior knowledge that are described in the experiments section. We also changed various physical properties of the game, such as the effect of gravity, and the way the agent interacts with its environment. Note that all the games were exactly the same in their underlying structure and reward, as well as the shortest path to reach the goal, thereby ensuring that the change in human performance (if any) is only due to masking of the priors.
+
+![](images/0edfda630ee4b64a7d02dba3086235177d1ca7f3981e18e046692df1d3a36ac7.jpg)  
+Figure 2: Various game manipulations. (a) Original version of the game. (b) Game with masked objects to ablate semantics prior. (c) Game with reversed associations as an alternate way to ablate semantics prior. (d) Game with masked objects and distractor objects to ablate the concept of object. (e) Game with background textures to ablate affordance prior. (f) Game with background textures and different colors for all platforms to ablate similarity prior. (g) Game with modified ladder to hinder participant’s prior about ladder interactions. (h) Rotated game to change participant’s prior about gravity.
+
+We quantified human performance on each version of the game by recruiting 120 participants from Amazon Mechanical Turk. Each participant was instructed to finish the game as quickly as possible using the arrow keys as controls, but no information about the goals or the reward structure of the game was communicated. Each participant was paid $\$ 1$ for successfully completing the game. The maximum time allowed for playing the game was set to 30 minutes. For each participant, we recorded the $( x , y )$ position of the player at every step of the game, the total time taken by the participant to finish the game and the total number of deaths before finishing the game. We used this data to quantify the performance of each participant. Note that each participant was only allowed to complete a game once, and could not participate again (i.e. different 120 participants played each version of the game).
+
+# 3 QUANTIFYING THE IMPORTANCE OF OBJECT PRIORS
+
+The original game (available to play at this link) is shown in Figure 2(a). A single glance at this game is enough to inform human players that the agent sprite has to reach the key to open the door while avoiding the dangerous objects like spikes and angry pink slime. Unsurprisingly, humans quickly solve this game. Figure 3(a) shows that the average time taken to complete the game is 1.8 minutes (blue bar) and the average number of deaths (3.3, orange bar) and unique game states visited (3011, yellow bar) are all quite small.
+
+# 3.1 SEMANTICS
+
+To study the importance of prior knowledge about object semantics, we rendered objects and ladders with blocks of uniform color as shown in Figure 2(b). This game can be played at this link. In this version, the visual appearance of objects conveys no information about their semantics. Results in Figure 3(b) show that human players take more than twice the time (4.3 minutes), have higher number of deaths (11.1), and explore significantly larger number of states (7205) as compared to the original game (p-value: $p < 0 . 0 1 $ ). This clearly demonstrates that masking semantics hurts human performance.
+
+A natural question is how do humans make use of semantic information? One hypothesis is that knowledge of semantics enables humans to infer the latent reward structure of the game. If this indeed is the case, then in the original game, where the key and the door are both visible, players should first visit the key and then go to the door, while in the version of the game without semantics, players should not exhibit such bias. We found that in the original game, nearly all participants reached the key first, while in the version with masked semantics only 42 out of 120 participants reached the key before the door (see Figure 4(a)). Moreover, human players took significantly longer to reach the door after taking the key as compared to the original game (see Figure 4(b)). This result provides further evidence that in the absence of semantics, humans are unable to infer the reward structure and consequently significantly increase their exploration. To rule out the possibility that increase in time is simply due to the fact players take longer to finish the game without semantics, the time to reach the door after taking the key was normalized by the total amount of time spent by the player to complete the game.
+
+![](images/b7b5614824f7092dba875b8d09480f3580dd53a369b9377a42930d1fd7f689b1.jpg)  
+Figure 3: Quantifying the influence of various object priors. The blue bar shows average time taken by humans (in minutes), orange bar shows the average number of deaths, and yellow bar shows the number of unique states visited by players to solve the various games. For visualization purposes, the number of deaths is divided by 2, and the number of states is divided by 1000 respectively.
+
+To further quantify the importance of semantics, instead of simply masking, we manipulated the semantic prior by swapping the semantics between different entities. As seen on Figure 4(c), we replaced the pink enemy and spikes by coins and ice-cream objects respectively which have a positive connotation; the ladder by fire, the key and the door by spikes and enemies which have negative connotations (see game link). As shown in Figure 3(c), the participants took longer to solve this game (6.1 minutes, $p < 0 . 0 1 $ ). The average number of deaths (13.7) was also significantly more and the participants explored more states (9400) compared to the original version $\mathit { p } < 0 . 0 1$ for both). Interestingly, the participants also took longer compared to the masked semantics version $( p < 0 . 0 5 )$ implying that when we reverse semantic information, humans find the game even tougher.
+
+# 3.2 OBJECTS AS SUB-GOALS FOR EXPLORATION
+
+While blocks of uniform color in the game shown in Figure 2(b) convey no semantics, they are distinct from the background and seem to attract human attention. It is possible that humans infer these distinct entities (or objects) as sub-goals, which results in more efficient exploration than random search. That is, there is something special about objects that draws human attention compared to any random piece of texture. To test this, we modified the game to cover each space on the platform with a block of different color to hide where the objects are (see Figure 2(d), game link). Most colored blocks are placebos and do not correspond to any object and the actual objects have the same color and form as in the previous version of the game with masked semantics (i.e., Figure 2(b)). If the prior knowledge that visibly distinct entities are interesting to explore is critical, this game manipulation should lead to a significant drop in human performance.
+
+Results in Figure 3(d) show that masking the concept of objects leads to drastic deterioration in performance. The average time taken by human players to solve the game is nearly four times longer (7.7 minutes), the number of deaths is nearly six times greater (20.2), and humans explore four times as many game states (12, 232) as compared to the original game. When compared to the game version in which only semantic information was removed (Figure 3(b)), the time taken, number of deaths and number of states are all significantly greater $( p < 0 . 0 1 )$ ). When only semantics are removed, after encountering one object, human players become aware of what possible locations might be interesting to explore next. However, when concept of objects is also masked, it is unclear what to explore next. This effect can be seen by the increase in normalized time taken to reach the door from the key as compared to the game where only semantics are masked (Figure 4(b)). All these results suggest that concept of objects i.e. knowing that visibly distinct entities are interesting and can be used as sub-goals for exploration, is a critical prior and perhaps more important than knowledge of semantics.
+
+![](images/0b81effaaea534ff6de8b5e18ac2414c448284af2a794dc4f6a5cfee58825bf9.jpg)  
+Figure 4: Change in behavior upon ablation of various priors. (a) Graph comparing number of participants that reached the key before the door in the original version, game without semantics, and game without object prior. (b) Amount of time taken by participants to reach the door once they obtained the key. (c) Average number of steps taken by participants to reach various vertical levels in original version, game without affordance, and game without similarity.
+
+# 3.3 AFFORDANCES
+
+Until now, we manipulated objects in ways that made inferring the underlying reward structure of the game non-trivial. However, in these games it was obvious for humans that platforms can support agent sprites, ladders could be climbed to reach different platforms (even when the ladders were colored in uniform red in games shown in Figure 2(b,c), the connectivity pattern revealed where the ladders were) and black parts of the game constitute free space. Here, the platforms and ladders afford the actions of walking and climbing (Gibson, 2014), irrespective of their appearance. In the next set of experiments, we manipulated the game to mask the affordance prior.
+
+One way to mask affordances is to fill free space with random textures, which are visually similar to textures used for rendering ladders and platforms (see Figure 2(e), game link). Note that in this game manipulation, objects and their semantics are clearly observable. When tasked to play this game, as shown in Figure 3(e), humans require significantly more time (4.7 minutes), die more often (10.7), and visit more states (7031) compared to the original game $\mathit { p } < 0 . 0 1 )$ ). On the other hand, there is no significant difference in performance compared to the game without semantics, i.e., Figure 2(b), implying that the affordance prior is as important as the semantics prior in our setup.
+
+# 3.4 THINGS THAT LOOK SIMILARLY, BEHAVE SIMILARLY
+
+In the previous game, although we masked affordance information, once the player realizes that it is possible to stand on a particular texture and climb a specific texture, it is easy to use color/texture similarity to identify other platforms and ladders in the game. Similarly, in the game with masked semantics (Figure 2(b)), visual similarity can be used to identify other enemies and spikes. These considerations suggest that a general prior of the form that things that look the same act the same might help humans efficiently explore environments where semantics or affordances are hidden.
+
+We tested this hypothesis by modifying the masked affordance game in a way that none of the platforms and ladders had the same visual signature (Figure 2(f), game link). Such rendering prevented human players from using the similarity prior. Figure 3(f)) shows that performance of humans was significantly worse in comparison to the original game (Figure 2(a)), the game with masked semantics (Figure 2(b)) and the game with masked affordances (Figure 2(e)) $\mathit { p } < 0 . 0 1 )$ . When compared to the game with no object information (Figure 2(d)), the time to complete the game (7.6 minutes) and the number of states explored by players were similar (11, 715), but the number of deaths (14.8) was significantly lower $( p < 0 . 0 1 )$ ). These results suggest that visual similarity is the second most important prior used by humans in gameplay after the knowledge of directing exploration towards objects.
+
+![](images/38ddc00fb1a334f8127e4ef21d154734c36f992907b627e310e8e117fba43637.jpg)  
+Figure 5: Masking all object priors drastically affects human performance. (a) Original game. (b) Version without any object priors. (c) Graph depicting difference in participant’s performance for both the games. (d) Exploration trajectory for original version and (e) for no object prior version.
+
+In order to gain insight into how this prior knowledge affects humans, we investigated the exploration pattern of human players. In the game when all information is visible we expected that the progress of humans would be uniform in time. In the case when affordances are removed, the human players would initially take some time to figure out what visual pattern corresponds to what entity and then quickly make progress in the game. Finally, in the case when the similarity prior is removed, we would expect human players to be unable to generalize any knowledge across the game and to take large amounts of time exploring the environment even towards the end. We investigated if this indeed was true by computing the time taken by each player to reach different vertical distances in the game for the first time. Note that the door is on the top of the game, so the moving up corresponds to getting closer to solving the game. The results of this analysis are shown in Figure 4(c). The horizontal-axis shows the height reached by the player and the vertical-axis show the average time taken by the players. As the figure shows, the results confirm our hypothesis.
+
+# 3.5 HOW TO INTERACT WITH OBJECTS
+
+Until now we have analyzed the prior knowledge used by humans to interpret the visual structure in the game. However, interpretation of visual structure is only useful if the player understands what to do with the interpretation. Humans seem to possess prior knowledge about how to interact with different objects. For example, monsters can be avoided by jumping over them, ladders can be climbed by pressing the up key repeatedly etc. Deep reinforcement learning agents, on the other hand, do not possess such priors and must learn how to interact with objects by mere trial and error.
+
+To test how critical such prior knowledge is, we created a version of the game in which the ladders couldn’t be climbed by simply pressing the up key. Instead, the ladders were zigzag in nature and in order to climb the ladder players had to press the up key, followed by alternating presses between the right and left key. Note that the ladders in this version looked like normal ladders, so players couldn’t infer the properties of the ladder by simply looking at them (see Figure $2 ( \mathbf { g } )$ , game link). As shown in Figure $3 ( \mathbf { g } )$ , changing the property of the ladder increases the time taken (3.6 minutes), number of deaths (6), and states explored (5942) when compared to the original game $( p < 0 . 0 1 )$ ).
+
+# 4 TAXONOMY OF OBJECT PRIORS
+
+In previous sections, we studied how different priors about objects affect human performance one at a time. To quantify human performance when all object priors investigated so far are simultaneously masked, we created the game shown in Figure 5(b) that hid all information about objects, semantics, affordance, and similarity(game link). Results in Figure 5(c) show that humans found it extremely hard to play this game. The average time taken to solve the game increased to 20 minutes and the average number of deaths rose sharply to 40. Remarkably, the exploration trajectory of humans is now almost completely random as shown in Figure 5(e) with the number of unique states visited by the human players increasing by a factor of 9 as compared to the original game. Due to difficulty in completing this game, we noticed a high dropout of human participants before they finished the game. We had to increase the pay to $\$ 2.25$ to encourage participants not to quit. Many participants noted that they could solve the game only by memorizing it.
+
+Even though we preserved priors related to physics (e.g., objects fall down) and motor control (e.g., pressing left key moves the agent sprite to the left), just by rendering the game in a way that makes it impossible to use prior knowledge about how to visually interpret the game screen makes the game extremely hard to play. To further test the limits of human ability, we designed a harder game where we also reversed gravity and randomly re-mapped the key presses to how it affect’s the motion of agent’s sprite. We, the creators of the game, having played a previous version of the game hundreds of times had an extremely hard time trying to complete this version of the game. This game placed us in the shoes of reinforcement learning (RL) agents that start off without the immense prior knowledge that humans possess. While improvements in the performance of RL agents with better algorithms and better computational resources is inevitable, our results make a strong case for developing algorithms that incorporate prior knowledge as a way to improve the performance of artificial agents.
+
+![](images/c6de54deff9ffc6f81218d7fddc60a2fd4a31716a09d2a617bcdb3bec17213fc.jpg)  
+Figure 6: Taxonomy of object priors. The earlier an object prior is obtained during childhood, the more critical that object prior is in human problem solving in video games.
+
+While there are many possible directions on how to incorporate priors in RL and more generally AI agents, it is informative to study how humans acquire such priors. Studies in developmental psychology suggest that human infants as young as 2 months old possess a primitive notion of objects and expect them to move as connected and bounded wholes that allows them to perceive object boundaries and therefore possibly distinguish them from the background (Spelke, 1990; Spelke & Kinzler, 2007). At this stage, infants do not reason about object categories. By the age of 3-5 months, infants start exhibiting categorization behavior based on similarity and familiarity (Mandler, 1998; Mareschal & Quinn, 2001). The ability to recognize individual objects rapidly and accurately emerges comparatively late in development (usually by the time babies are 18-24 months old (Pereira & Smith, 2009)). Similarly, while young infants exhibit some knowledge about affordances early during development, the ability to distinguish a walkable step from a cliff emerges only by the time they are 18 months old (Kretch & Adolph, 2013).
+
+These results in infant development suggest that starting with a primitive notion of objects, infants gradually learn about visual similarity and eventually about object semantics and affordances. It is quite interesting to note that the order in which infants increase their knowledge matches the importance of different object priors such as the existence of objects as sub-goals for exploration, visual similarity, object semantics, and affordances. Based on these results, we suggest a possible taxonomy and ranking of object priors in Figure 6. We put ‘object interaction’ at the bottom as in the context of our problem, knowledge about how to interact with specific objects can be only learned once recognition is performed.
+
+# 5 PHYSICS AND MOTOR CONTROL PRIORS
+
+In addition to prior knowledge about objects, humans also bring in rich prior knowledge about intuitive physics and strong motor control priors when they approach a new task (Hespos et al., 2009; Baillargeon, 2004; 1994; Wolpert & Ghahramani, 2000). Here, we have taken some initial steps to explore the importance of such priors in context of human gameplay.
+
+# 5.1 GRAVITY
+
+One of the most obvious forms of knowledge that we have about the physical world is with regards to gravity, i.e., things fall from up to down. To mask this prior, we created a version of the game in which the whole game window was rotated $9 0 ^ { \circ }$ (refer to Figure $2 ( \mathrm { h } ) _ { \cdot }$ ). In this way, the gravity was reversed from left to right (as opposed to up to down). As shown in Figure 7, participants spent more time to solve this game compared to the original version with average time taken close to 3 minutes $( p < 0 . 0 1 )$ . The average number of deaths and number of states explored was also significantly larger than the original version $( p < 0 . 0 1 )$ .
+
+![](images/fe57c9bff923118ead29402503f9e21af64cc76837b8dca3ee63c45ab9747c73.jpg)  
+Figure 7: Quantifying physics and motor control priors. Graph shows performance of participants in original version, game with gravity reversed, and game with key controls reversed. Number of deaths is divided by 2 and number of states is divided by 1000.
+
+# 5.2 MUSCLE MEMORY
+
+Human players also come with knowledge about the consequences of actions such as pressing arrow keys moves the agent sprite in the corresponding directions (i.e., pressing up makes the agent sprite jump, pressing left makes the agent sprite go left and so forth). We created a version of the game in which we reversed the arrow key controls. Thus, pressing the left arrow key made the agent sprite go right, pressing the right key moved the sprite left, pressing the down key made the player jump (or go up the stairs), and pressing the up key made the player go down the stairs. Participants again took longer to solve this game compared to the original version with average time taken close to 3 minutes (refer to Figure 7). The average number of deaths and number of states explored was also significantly larger than the original version $( p \ < \ 0 . 0 1 )$ . Interestingly, the performance of players when the gravity was reversed, and key controls were reversed is similar, with no significant difference between the two conditions.
+
+# 6 CONTROLLING FOR CHANGE IN COMPLEXITY
+
+So far in this paper, we have manipulated various visual priors while keeping the underlying game and reward structure exactly the same. We have assumed that this will influence human performance while keeping RL agent performance unchanged, since RL does not have any priors to begin with. However, one possible confound is that the visual complexity of the modified games might have changed from the original game version, because masking out priors without changing visual complexity is extremely difficult.
+
+To control for this confound, we investigated the performance of an RL agent on the various game manipulations. If RL agents are not affected by the game manipulations, then it would suggest that prior knowledge and not visual complexity is the main reason behind the change in human performance. Note that this confound is not present in the physics and motor control experiments as the visual input stays the same as the original game.
+
+To this end, we systematically created different versions of the game in Figure 1(a) to ablate semantics, the concept of object, affordance, and similarity as shown in Figure 8. Note that the game used for human experiments shown in Figure 2 is more complex than the game used for RL experiments in Figure 8. This is because the larger game was simply too hard for state-of-the-art RL agents to solve. Apart from the difference in the game size, we tried to make the games as similar as possible. Even though this version of the game is simpler (regarding size, number of objects etc.), we note that this game is still non-trivial for an RL agent. For instance, due to the sparse reward structure of the game, both A3C (Mnih et al., 2016) and breadth-first search didn’t come close to solving the game even after 10 million steps. Hence, for our purpose, we used an RL algorithm augmented with a curiosity based exploration strategy (Pathak et al., 2017). For each game version, we report the mean performance of five random seeds that succeeded.
+
+As shown in Figure 8(e), the RL agent was unaffected by the removal of semantics, the concept of objects, as well as affordances – there is no significant difference between the mean score of the RL agent on these games when compared to the performance on the original game $( p > 0 . 0 5 )$ . This suggests that the drop in human performance in these game manipulations is not due to the change in visual complexity, but it is rather due to the masking of the various priors. On the other hand, the performance of the RL agent does worsen when visual similarity is masked as it takes nearly twice as many interactions to complete the game compared to the original version. We believe this is due to to the use of convolutional neural networks that implicitly impose the prior of visual similarity rather than simply due to the change in visual complexity.
+
+![](images/7df00ec37565f947b2632b34158d12258e7b7bacb8dbd404173302b2ddc64feb.jpg)  
+Figure 8: Quantifying the performance of RL agent. (a) Game without semantic information. (b) Game with masked and distractor objects to ablate concept of objects. (c) Game without affordance information. (d) Game without similarity information. (e) Performance of RL agent on various game manipulations (steps shown in order of million). Error bars indicate standard error of mean for the 5 random seeds. The RL agent performs similarly on all games except for the one without visual similarity.
+
+# 7 DISCUSSION
+
+While there is no doubt that the performance of deep RL algorithms is impressive, there is much to be learned from human cognition if our goal is to enable RL agents to solve sparse reward tasks with human-like efficiency. Humans have the amazing ability to use their past knowledge (i.e., priors) to solve new tasks quickly. Success in such scenarios critically depends on the agent’s ability to explore its environment and then promptly learn from its successes (Daw et al., 2006; Cohen et al., 2007). In this vein, our results demonstrate the importance of prior knowledge in helping humans explore efficiently in these sparse reward environments (Knox et al., 2012; Gershman & Niv, 2015).
+
+However, being equipped with strong prior knowledge can sometimes lead to constrained exploration that might not be optimal in all environments (Lucas et al., 2014; Bonawitz et al., 2011). For instance, consider the game shown in Figure 9 consisting of a robot and a princess object. The game environment also includes rewards in hidden locations (shown as dashed yellow boxes only for illustration). When tasked to play this game, human participants $\mathrm { ( n { = } 3 0 } ) _ { , }$ ) immediately assume that princess is the goal and do not explore the free space containing hidden rewards. They directly reach the princess and thereby terminate the game with sub-optimal rewards. In contrast, a random agent (30 seeds) ends up obtaining almost four times more reward than human players as shown in Figure 9. Thus, while incorporating prior knowledge in RL agents has many potential benefits, future work should also consider challenges regarding under-constrained exploration in certain kinds of settings.
+
+While our paper primarily investigated object priors (and physics priors to some extent), humans also possess rich prior knowledge about the world in the form of intuitive psychology and also bring in various priors about general video game playing such as that moving up and to the right in games is generally correlated with progress, games have goals, etc. Studying the importance of such priors will be an interesting future direction of research.
+
+Building RL algorithms that require fewer interactions to reach the goal (i.e., sample efficient algorithms) is an active area of research, and further progress is inevitable. In addition to developing better optimization methods, we believe that instead of always initializing learning from scratch, either incorporating prior knowledge directly or constructing mechanisms for condensing experience into reusable knowledge (i.e., learning priors through continual learning) might be critical for building RL agents with human-like efficiency. Our work takes first steps toward quantifying the importance of various priors that humans employ in solving video games and in understanding how prior knowledge makes humans good at such complex tasks. We believe that our results will inspire researchers to think about different mechanisms of incorporating prior knowledge in the design of RL agents. We also hope that our experimental platform of video games, available in open-source, will fuel more detailed studies investigating human priors and a benchmark for quantifying the efficacy of different mechanisms of incorporating prior knowledge into RL agents.
+
+![](images/545251162cf99cc4a4b04eb7881fad9852398bb62b8a09c2d2f92a2e484ab430.jpg)  
+Figure 9: Prior information constrains human exploration. (Left) A very simple game with hidden rewards (shown in dashed yellow). (Right) Average rewards accumulated by human players vs a random agent.
+
+# ACKNOWLEDGEMENT
+
+We thank Jordan Suchow, Michael Chang, Shubham Tulsiani, Alison Gopnik, and other members of the BAIR community for helpful discussions and comments. This work has been supported, in part, by Google, ONR MURI N00014-14-1-0671, Berkeley DeepDrive, NVIDIA Graduate Fellowship to DP, and the Valrhona Reinforcement Learning Fellowship.
+
+# REFERENCES
+
+Renee Baillargeon. How do infants learn about the physical world? Current Directions in Psychological Science, 3(5):133–140, 1994.
+
+Renee Baillargeon. Infants’ physical world. ´ Current directions in psychological science, 13(3): 89–94, 2004.
+
+Marc Bellemare, Sriram Srinivasan, Georg Ostrovski, Tom Schaul, David Saxton, and Remi Munos. Unifying count-based exploration and intrinsic motivation. In NIPS, 2016.
+
+Elizabeth Bonawitz, Patrick Shafto, Hyowon Gweon, Noah D Goodman, Elizabeth Spelke, and Laura Schulz. The double-edged sword of pedagogy: Instruction limits spontaneous exploration and discovery. Cognition, 120(3):322–330, 2011.
+
+Susan Carey. The origin of concepts. Oxford University Press, 2009.
+
+Jonathan D Cohen, Samuel M McClure, and J Yu Angela. Should i stay or should i go? how the human brain manages the trade-off between exploitation and exploration. Philosophical Transactions of the Royal Society B: Biological Sciences, 362(1481):933–942, 2007.
+
+Nathaniel D Daw, John P O’Doherty, Peter Dayan, Ben Seymour, and Raymond J Dolan. Cortical substrates for exploratory decisions in humans. Nature, 441(7095):876–879, 2006.
+
+Samuel J Gershman and Yael Niv. Novelty and inductive generalization in human reinforcement learning. Topics in cognitive science, 7(3):391–415, 2015.
+
+James J Gibson. The ecological approach to visual perception: classic edition. Psychology Press, 2014.
+
+Shixiang Gu, Timothy Lillicrap, Ilya Sutskever, and Sergey Levine. Continuous deep q-learning with model-based acceleration. In ICML, 2016.
+
+Susan J Hespos, Alissa L Ferry, and Lance J Rips. Five-month-old infants have different expectations for solids and liquids. Psychological Science, 20(5):603–611, 2009.
+
+W Bradley Knox, A Ross Otto, Peter Stone, and Bradley Love. The nature of belief-directed exploratory choice in human decision-making. Frontiers in psychology, 2:398, 2012.
+
+Kari S Kretch and Karen E Adolph. Cliff or step? posture-specific learning at the edge of a drop-off. Child Development, 84(1):226–240, 2013.
+
+Brenden M Lake, Tomer D Ullman, Joshua B Tenenbaum, and Samuel J Gershman. Building machines that learn and think like people. Behavioral and Brain Sciences, pp. 1–101, 2016.
+
+Christopher G Lucas, Sophie Bridgers, Thomas L Griffiths, and Alison Gopnik. When children are better (or at least more open-minded) learners than adults: Developmental differences in learning the forms of causal relationships. Cognition, 131(2):284–299, 2014.
+
+Jean M. Mandler. Representation. In Cognition, perception, and language: Handbook of child psychology. John Wiley & Sons Inc, 1998.
+
+Denis Mareschal and Paul C Quinn. Categorization in infancy. Trends in cognitive sciences, 5(10): 443–450, 2001.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 2015.
+
+Volodymyr Mnih, Adria Puigdomenech Badia, Mehdi Mirza, Alex Graves, Timothy P Lillicrap, Tim Harley, David Silver, and Koray Kavukcuoglu. Asynchronous methods for deep reinforcement learning. In ICML, 2016.
+
+Junhyuk Oh, Satinder Singh, and Honglak Lee. Value prediction network. In NIPS, 2017.
+
+Deepak Pathak, Pulkit Agrawal, Alexei A Efros, and Trevor Darrell. Curiosity-driven exploration by self-supervised prediction. arXiv preprint arXiv:1705.05363, 2017.
+
+Alfredo F Pereira and Linda B Smith. Developmental changes in visual object recognition between 18 and 24 months of age. Developmental science, 12(1):67–80, 2009.
+
+Elizabeth S Spelke. Principles of object perception. Cognitive science, 14(1):29–56, 1990.
+
+Elizabeth S Spelke and Katherine D Kinzler. Core knowledge. Developmental science, 10(1):89–96, 2007.
+
+Pedro A Tsividis, Thomas Pouncy, Jacqueline L Xu, Joshua B Tenenbaum, and Samuel J Gershman. Human learning in atari. In The AAAI 2017 Spring Symposium on Science of Intelligence: Computational Principles of Natural and Artificial Intelligence, 2017.
+
+Daniel M Wolpert and Zoubin Ghahramani. Computational principles of movement neuroscience. Nature neuroscience, 3:1212–1217, 2000.

parse/train/Hk91SGWR-/Hk91SGWR-_content_list.json

@@ -0,0 +1,1189 @@
+[
+    {
+        "type": "text",
+        "text": "INVESTIGATING HUMAN PRIORS FOR PLAYING VIDEO GAMES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            821,
+            145
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Rachit Dubey, Pulkit Agrawal, Deepak Pathak, Thomas L. Griffiths, and Alexei A. Efros ",
+        "bbox": [
+            186,
+            175,
+            805,
+            190
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "University of California, Berkeley ",
+        "bbox": [
+            388,
+            203,
+            609,
+            217
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            258,
+            544,
+            273
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "What makes humans so good at solving seemingly complex video games? Unlike computers, humans bring in a great deal of prior knowledge about the world, enabling efficient decision making. This paper investigates the role of human priors for solving video games. Given a sample game, we conduct a series of ablation studies to quantify the importance of various priors. We do this by modifying the video game environment to systematically mask different types of visual information that could be used by humans as priors. We find that removal of some prior knowledge causes a drastic degradation in the speed with which human players solve the game, e.g. from 2 minutes to over 20 minutes. Furthermore, our results indicate that general priors, such as the importance of objects and visual consistency, are critical for efficient game-play. ",
+        "bbox": [
+            233,
+            290,
+            764,
+            443
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            474,
+            336,
+            489
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "While deep Reinforcement Learning (RL) methods have shown impressive performance on a variety of video games (Mnih et al., 2015), they remain woefully inefficient compared to human players, taking millions of action inputs to solve even the simplest Atari games. Much research is currently focused on improving sample efficiency of RL algorithms (Oh et al., 2017; Gu et al., 2016). However, there is an orthogonal issue that is often overlooked: RL agents attack each problem tabula rasa, whereas humans come in with a wealth of prior knowledge about the world, from physics to semantics to affordances. ",
+        "bbox": [
+            174,
+            498,
+            825,
+            595
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Consider the following motivating example: you are tasked with playing an unfamiliar computer game shown in Figure 1(a). No manual or instructions are provided; you don’t even know which game sprite is controlled by you. Indeed, the only feedback you are ever given is “terminal”, i.e. once you successfully finish the game. Would you be able to successfully finish this game? How long would it take? We recruited forty human subjects to play this game and found that subjects finished it quite easily, taking just under 1 minute of game-play or 3000 action inputs. This is not overly surprising as one could easily guess that the game’s goal is to move the robot sprite towards the princess by stepping on the brick-like objects and using ladders to reach the higher platforms while avoiding the angry pink and the fire objects. ",
+        "bbox": [
+            174,
+            603,
+            825,
+            728
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Now consider a second scenario in which this same simple game is re-rendered with new textures, getting rid of semantic and affordance (Gibson, 2014) cues, as shown in Figure 1(b). How would human performance change? We recruited another forty subjects to play this game and found that, on average, it took the players more than twice the time (2 minutes) and action inputs ( 6500) to complete the game. The second game is clearly much harder for humans, likely because it is now more difficult to guess the game structure and goal, as well as to spot obstacles. ",
+        "bbox": [
+            174,
+            736,
+            823,
+            819
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "For comparison, we can also examine how modern RL algorithms perform on these games. This is not so simple, as most standard RL approaches expect very dense rewards (e.g. continuously updated game-score (Mnih et al., 2015)), whereas we provide only a terminal reward, to mimic how most humans play video games. In such sparse reward scenarios, standard methods like A3C (Mnih et al., 2016) are too sample-inefficient and were too slow to finish the games. Hence, we used a curiosity-based RL algorithm specifically tailored to sparse-reward settings (Pathak et al., 2017), which was able to solve both games. Unlike humans, RL did not show much difference between the two games, taking about 4 million action inputs to solve each one. This should not be surprising: since RL did not have any prior knowledge about the world, both these games carried roughly the same amount of information from the perspective of the agent. ",
+        "bbox": [
+            174,
+            827,
+            823,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/c37716b0322148eb37283fbdf8219c7d957917a639ec67d4635058d95679c3ed.jpg",
+        "image_caption": [
+            "Figure 1: Motivating example. (a) A simple platformer game. (b) The same game modified by re-rendering the textures. Despite the two games being structurally the same, human players took twice as long to finish the second game as the first one. In comparison, the performance of an RL agent was approximately the same for the two games. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            334,
+            101,
+            660,
+            234
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            303,
+            821,
+            344
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "This simple motivating experiment highlights the importance of prior knowledge that humans draw upon to quickly solve tasks given to them (Lake et al., 2016; Tsividis et al., 2017). Developmental psychologists have begun documenting the prior knowledge that children draw upon in learning about the world (Spelke & Kinzler, 2007; Carey, 2009). However, these studies have not explicitly quantified the relative importance of the various priors for problem-solving. ",
+        "bbox": [
+            174,
+            351,
+            825,
+            421
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we systematically quantify the importance of different types of priors humans bring to bear while solving one particular kind of problem – video games. We chose video games as the task for our investigation because it is relatively easy to methodically change the game to include or mask different kinds of knowledge and run large-scale human studies. Furthermore, video games, such as ATARI, are a popular choice in the reinforcement learning community. ",
+        "bbox": [
+            174,
+            428,
+            825,
+            498
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The paper consists of a series of ablation studies on a specially-designed game environment, systematically masking out various types of visual information that could be used by humans as priors. The full game (unlike the motivating example above) was designed to be sufficiently complex and difficult for humans to easily measure changes in performance between different testing conditions. ",
+        "bbox": [
+            174,
+            505,
+            823,
+            560
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We find that removal of some prior knowledge causes a drastic degradation in the performance of human players from 1 minute to over 20 minutes. Another key finding of our investigation is that while specific knowledge, such as “ladders are to be climbed”, “keys are used to open doors”, “jumping on spikes is dangerous”, is important for humans to quickly solve games, more general priors about the importance of objects and visual consistency are even more critical. ",
+        "bbox": [
+            174,
+            568,
+            825,
+            637
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 METHOD ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            665,
+            282,
+            681
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To investigate the aspects of visual information that enable humans to efficiently solve video games, we designed a browser-based platform game consisting of an agent sprite, platforms, ladders, angry pink object that kills the agent, spikes that are dangerous to jump on, a key, and a door (see Figure 2 (a)). The agent sprite can be moved with the help of arrow keys. A terminal reward of $+ 1$ is provided when the agent reaches the door after having to taken the key, thereby terminating the game. The game is reset whenever the agent touches the enemy, jumps on the spike, or falls below the lowest platform. We made this game to resemble the exploration problems faced in the classic ATARI game of Montezuma’s Revenge that has proven to be very challenging for deep reinforcement learning techniques (Bellemare et al., 2016; Mnih et al., 2015). Unlike the motivating example, this game is too large-scale to be solved by RL agents, but provides the complexity we need to run a wide range of human experiments. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            847
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We created different versions of the video game by re-rendering various entities such as ladders, enemies, keys, platforms etc. using alternate textures (Figure 2). These textures were chosen to mask various forms of prior knowledge that are described in the experiments section. We also changed various physical properties of the game, such as the effect of gravity, and the way the agent interacts with its environment. Note that all the games were exactly the same in their underlying structure and reward, as well as the shortest path to reach the goal, thereby ensuring that the change in human performance (if any) is only due to masking of the priors. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/0edfda630ee4b64a7d02dba3086235177d1ca7f3981e18e046692df1d3a36ac7.jpg",
+        "image_caption": [
+            "Figure 2: Various game manipulations. (a) Original version of the game. (b) Game with masked objects to ablate semantics prior. (c) Game with reversed associations as an alternate way to ablate semantics prior. (d) Game with masked objects and distractor objects to ablate the concept of object. (e) Game with background textures to ablate affordance prior. (f) Game with background textures and different colors for all platforms to ablate similarity prior. (g) Game with modified ladder to hinder participant’s prior about ladder interactions. (h) Rotated game to change participant’s prior about gravity. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            101,
+            823,
+            319
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            449,
+            821,
+            478
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We quantified human performance on each version of the game by recruiting 120 participants from Amazon Mechanical Turk. Each participant was instructed to finish the game as quickly as possible using the arrow keys as controls, but no information about the goals or the reward structure of the game was communicated. Each participant was paid $\\$ 1$ for successfully completing the game. The maximum time allowed for playing the game was set to 30 minutes. For each participant, we recorded the $( x , y )$ position of the player at every step of the game, the total time taken by the participant to finish the game and the total number of deaths before finishing the game. We used this data to quantify the performance of each participant. Note that each participant was only allowed to complete a game once, and could not participate again (i.e. different 120 participants played each version of the game). ",
+        "bbox": [
+            174,
+            484,
+            825,
+            623
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 QUANTIFYING THE IMPORTANCE OF OBJECT PRIORS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            647,
+            638,
+            661
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The original game (available to play at this link) is shown in Figure 2(a). A single glance at this game is enough to inform human players that the agent sprite has to reach the key to open the door while avoiding the dangerous objects like spikes and angry pink slime. Unsurprisingly, humans quickly solve this game. Figure 3(a) shows that the average time taken to complete the game is 1.8 minutes (blue bar) and the average number of deaths (3.3, orange bar) and unique game states visited (3011, yellow bar) are all quite small. ",
+        "bbox": [
+            174,
+            667,
+            825,
+            752
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 SEMANTICS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            772,
+            297,
+            786
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To study the importance of prior knowledge about object semantics, we rendered objects and ladders with blocks of uniform color as shown in Figure 2(b). This game can be played at this link. In this version, the visual appearance of objects conveys no information about their semantics. Results in Figure 3(b) show that human players take more than twice the time (4.3 minutes), have higher number of deaths (11.1), and explore significantly larger number of states (7205) as compared to the original game (p-value: $p < 0 . 0 1 $ ). This clearly demonstrates that masking semantics hurts human performance. ",
+        "bbox": [
+            174,
+            791,
+            825,
+            888
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A natural question is how do humans make use of semantic information? One hypothesis is that knowledge of semantics enables humans to infer the latent reward structure of the game. If this indeed is the case, then in the original game, where the key and the door are both visible, players should first visit the key and then go to the door, while in the version of the game without semantics, players should not exhibit such bias. We found that in the original game, nearly all participants reached the key first, while in the version with masked semantics only 42 out of 120 participants reached the key before the door (see Figure 4(a)). Moreover, human players took significantly longer to reach the door after taking the key as compared to the original game (see Figure 4(b)). This result provides further evidence that in the absence of semantics, humans are unable to infer the reward structure and consequently significantly increase their exploration. To rule out the possibility that increase in time is simply due to the fact players take longer to finish the game without semantics, the time to reach the door after taking the key was normalized by the total amount of time spent by the player to complete the game. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            922
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/b7b5614824f7092dba875b8d09480f3580dd53a369b9377a42930d1fd7f689b1.jpg",
+        "image_caption": [
+            "Figure 3: Quantifying the influence of various object priors. The blue bar shows average time taken by humans (in minutes), orange bar shows the average number of deaths, and yellow bar shows the number of unique states visited by players to solve the various games. For visualization purposes, the number of deaths is divided by 2, and the number of states is divided by 1000 respectively. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            97,
+            826,
+            262
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            351,
+            825,
+            503
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To further quantify the importance of semantics, instead of simply masking, we manipulated the semantic prior by swapping the semantics between different entities. As seen on Figure 4(c), we replaced the pink enemy and spikes by coins and ice-cream objects respectively which have a positive connotation; the ladder by fire, the key and the door by spikes and enemies which have negative connotations (see game link). As shown in Figure 3(c), the participants took longer to solve this game (6.1 minutes, $p < 0 . 0 1 $ ). The average number of deaths (13.7) was also significantly more and the participants explored more states (9400) compared to the original version $\\mathit { p } < 0 . 0 1$ for both). Interestingly, the participants also took longer compared to the masked semantics version $( p < 0 . 0 5 )$ implying that when we reverse semantic information, humans find the game even tougher. ",
+        "bbox": [
+            174,
+            511,
+            825,
+            636
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 OBJECTS AS SUB-GOALS FOR EXPLORATION",
+        "text_level": 1,
+        "bbox": [
+            174,
+            657,
+            524,
+            671
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "While blocks of uniform color in the game shown in Figure 2(b) convey no semantics, they are distinct from the background and seem to attract human attention. It is possible that humans infer these distinct entities (or objects) as sub-goals, which results in more efficient exploration than random search. That is, there is something special about objects that draws human attention compared to any random piece of texture. To test this, we modified the game to cover each space on the platform with a block of different color to hide where the objects are (see Figure 2(d), game link). Most colored blocks are placebos and do not correspond to any object and the actual objects have the same color and form as in the previous version of the game with masked semantics (i.e., Figure 2(b)). If the prior knowledge that visibly distinct entities are interesting to explore is critical, this game manipulation should lead to a significant drop in human performance. ",
+        "bbox": [
+            174,
+            679,
+            825,
+            818
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Results in Figure 3(d) show that masking the concept of objects leads to drastic deterioration in performance. The average time taken by human players to solve the game is nearly four times longer (7.7 minutes), the number of deaths is nearly six times greater (20.2), and humans explore four times as many game states (12, 232) as compared to the original game. When compared to the game version in which only semantic information was removed (Figure 3(b)), the time taken, number of deaths and number of states are all significantly greater $( p < 0 . 0 1 )$ ). When only semantics are removed, after encountering one object, human players become aware of what possible locations might be interesting to explore next. However, when concept of objects is also masked, it is unclear what to explore next. This effect can be seen by the increase in normalized time taken to reach the door from the key as compared to the game where only semantics are masked (Figure 4(b)). All these results suggest that concept of objects i.e. knowing that visibly distinct entities are interesting and can be used as sub-goals for exploration, is a critical prior and perhaps more important than knowledge of semantics. ",
+        "bbox": [
+            174,
+            825,
+            823,
+            922
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/0b81effaaea534ff6de8b5e18ac2414c448284af2a794dc4f6a5cfee58825bf9.jpg",
+        "image_caption": [
+            "Figure 4: Change in behavior upon ablation of various priors. (a) Graph comparing number of participants that reached the key before the door in the original version, game without semantics, and game without object prior. (b) Amount of time taken by participants to reach the door once they obtained the key. (c) Average number of steps taken by participants to reach various vertical levels in original version, game without affordance, and game without similarity. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            236,
+            98,
+            763,
+            236
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            332,
+            825,
+            415
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 AFFORDANCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            434,
+            318,
+            449
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Until now, we manipulated objects in ways that made inferring the underlying reward structure of the game non-trivial. However, in these games it was obvious for humans that platforms can support agent sprites, ladders could be climbed to reach different platforms (even when the ladders were colored in uniform red in games shown in Figure 2(b,c), the connectivity pattern revealed where the ladders were) and black parts of the game constitute free space. Here, the platforms and ladders afford the actions of walking and climbing (Gibson, 2014), irrespective of their appearance. In the next set of experiments, we manipulated the game to mask the affordance prior. ",
+        "bbox": [
+            174,
+            454,
+            825,
+            551
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "One way to mask affordances is to fill free space with random textures, which are visually similar to textures used for rendering ladders and platforms (see Figure 2(e), game link). Note that in this game manipulation, objects and their semantics are clearly observable. When tasked to play this game, as shown in Figure 3(e), humans require significantly more time (4.7 minutes), die more often (10.7), and visit more states (7031) compared to the original game $\\mathit { p } < 0 . 0 1 )$ ). On the other hand, there is no significant difference in performance compared to the game without semantics, i.e., Figure 2(b), implying that the affordance prior is as important as the semantics prior in our setup. ",
+        "bbox": [
+            174,
+            558,
+            825,
+            655
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.4 THINGS THAT LOOK SIMILARLY, BEHAVE SIMILARLY ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            676,
+            578,
+            689
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In the previous game, although we masked affordance information, once the player realizes that it is possible to stand on a particular texture and climb a specific texture, it is easy to use color/texture similarity to identify other platforms and ladders in the game. Similarly, in the game with masked semantics (Figure 2(b)), visual similarity can be used to identify other enemies and spikes. These considerations suggest that a general prior of the form that things that look the same act the same might help humans efficiently explore environments where semantics or affordances are hidden. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            777
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We tested this hypothesis by modifying the masked affordance game in a way that none of the platforms and ladders had the same visual signature (Figure 2(f), game link). Such rendering prevented human players from using the similarity prior. Figure 3(f)) shows that performance of humans was significantly worse in comparison to the original game (Figure 2(a)), the game with masked semantics (Figure 2(b)) and the game with masked affordances (Figure 2(e)) $\\mathit { p } < 0 . 0 1 )$ . When compared to the game with no object information (Figure 2(d)), the time to complete the game (7.6 minutes) and the number of states explored by players were similar (11, 715), but the number of deaths (14.8) was significantly lower $( p < 0 . 0 1 )$ ). These results suggest that visual similarity is the second most important prior used by humans in gameplay after the knowledge of directing exploration towards objects. ",
+        "bbox": [
+            174,
+            785,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/38ddc00fb1a334f8127e4ef21d154734c36f992907b627e310e8e117fba43637.jpg",
+        "image_caption": [
+            "Figure 5: Masking all object priors drastically affects human performance. (a) Original game. (b) Version without any object priors. (c) Graph depicting difference in participant’s performance for both the games. (d) Exploration trajectory for original version and (e) for no object prior version. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            99,
+            823,
+            199
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In order to gain insight into how this prior knowledge affects humans, we investigated the exploration pattern of human players. In the game when all information is visible we expected that the progress of humans would be uniform in time. In the case when affordances are removed, the human players would initially take some time to figure out what visual pattern corresponds to what entity and then quickly make progress in the game. Finally, in the case when the similarity prior is removed, we would expect human players to be unable to generalize any knowledge across the game and to take large amounts of time exploring the environment even towards the end. We investigated if this indeed was true by computing the time taken by each player to reach different vertical distances in the game for the first time. Note that the door is on the top of the game, so the moving up corresponds to getting closer to solving the game. The results of this analysis are shown in Figure 4(c). The horizontal-axis shows the height reached by the player and the vertical-axis show the average time taken by the players. As the figure shows, the results confirm our hypothesis. ",
+        "bbox": [
+            174,
+            267,
+            825,
+            434
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.5 HOW TO INTERACT WITH OBJECTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            455,
+            452,
+            468
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Until now we have analyzed the prior knowledge used by humans to interpret the visual structure in the game. However, interpretation of visual structure is only useful if the player understands what to do with the interpretation. Humans seem to possess prior knowledge about how to interact with different objects. For example, monsters can be avoided by jumping over them, ladders can be climbed by pressing the up key repeatedly etc. Deep reinforcement learning agents, on the other hand, do not possess such priors and must learn how to interact with objects by mere trial and error. ",
+        "bbox": [
+            174,
+            474,
+            825,
+            558
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To test how critical such prior knowledge is, we created a version of the game in which the ladders couldn’t be climbed by simply pressing the up key. Instead, the ladders were zigzag in nature and in order to climb the ladder players had to press the up key, followed by alternating presses between the right and left key. Note that the ladders in this version looked like normal ladders, so players couldn’t infer the properties of the ladder by simply looking at them (see Figure $2 ( \\mathbf { g } )$ , game link). As shown in Figure $3 ( \\mathbf { g } )$ , changing the property of the ladder increases the time taken (3.6 minutes), number of deaths (6), and states explored (5942) when compared to the original game $( p < 0 . 0 1 )$ ). ",
+        "bbox": [
+            174,
+            565,
+            825,
+            662
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 TAXONOMY OF OBJECT PRIORS ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            685,
+            465,
+            700
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In previous sections, we studied how different priors about objects affect human performance one at a time. To quantify human performance when all object priors investigated so far are simultaneously masked, we created the game shown in Figure 5(b) that hid all information about objects, semantics, affordance, and similarity(game link). Results in Figure 5(c) show that humans found it extremely hard to play this game. The average time taken to solve the game increased to 20 minutes and the average number of deaths rose sharply to 40. Remarkably, the exploration trajectory of humans is now almost completely random as shown in Figure 5(e) with the number of unique states visited by the human players increasing by a factor of 9 as compared to the original game. Due to difficulty in completing this game, we noticed a high dropout of human participants before they finished the game. We had to increase the pay to $\\$ 2.25$ to encourage participants not to quit. Many participants noted that they could solve the game only by memorizing it. ",
+        "bbox": [
+            174,
+            708,
+            825,
+            861
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Even though we preserved priors related to physics (e.g., objects fall down) and motor control (e.g., pressing left key moves the agent sprite to the left), just by rendering the game in a way that makes it impossible to use prior knowledge about how to visually interpret the game screen makes the game extremely hard to play. To further test the limits of human ability, we designed a harder game where we also reversed gravity and randomly re-mapped the key presses to how it affect’s the motion of agent’s sprite. We, the creators of the game, having played a previous version of the game hundreds of times had an extremely hard time trying to complete this version of the game. This game placed us in the shoes of reinforcement learning (RL) agents that start off without the immense prior knowledge that humans possess. While improvements in the performance of RL agents with better algorithms and better computational resources is inevitable, our results make a strong case for developing algorithms that incorporate prior knowledge as a way to improve the performance of artificial agents. ",
+        "bbox": [
+            174,
+            868,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/c6de54deff9ffc6f81218d7fddc60a2fd4a31716a09d2a617bcdb3bec17213fc.jpg",
+        "image_caption": [
+            "Figure 6: Taxonomy of object priors. The earlier an object prior is obtained during childhood, the more critical that object prior is in human problem solving in video games. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            375,
+            104,
+            619,
+            219
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            276,
+            825,
+            387
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "While there are many possible directions on how to incorporate priors in RL and more generally AI agents, it is informative to study how humans acquire such priors. Studies in developmental psychology suggest that human infants as young as 2 months old possess a primitive notion of objects and expect them to move as connected and bounded wholes that allows them to perceive object boundaries and therefore possibly distinguish them from the background (Spelke, 1990; Spelke & Kinzler, 2007). At this stage, infants do not reason about object categories. By the age of 3-5 months, infants start exhibiting categorization behavior based on similarity and familiarity (Mandler, 1998; Mareschal & Quinn, 2001). The ability to recognize individual objects rapidly and accurately emerges comparatively late in development (usually by the time babies are 18-24 months old (Pereira & Smith, 2009)). Similarly, while young infants exhibit some knowledge about affordances early during development, the ability to distinguish a walkable step from a cliff emerges only by the time they are 18 months old (Kretch & Adolph, 2013). ",
+        "bbox": [
+            174,
+            395,
+            825,
+            561
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "These results in infant development suggest that starting with a primitive notion of objects, infants gradually learn about visual similarity and eventually about object semantics and affordances. It is quite interesting to note that the order in which infants increase their knowledge matches the importance of different object priors such as the existence of objects as sub-goals for exploration, visual similarity, object semantics, and affordances. Based on these results, we suggest a possible taxonomy and ranking of object priors in Figure 6. We put ‘object interaction’ at the bottom as in the context of our problem, knowledge about how to interact with specific objects can be only learned once recognition is performed. ",
+        "bbox": [
+            174,
+            569,
+            825,
+            680
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 PHYSICS AND MOTOR CONTROL PRIORS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            705,
+            537,
+            719
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In addition to prior knowledge about objects, humans also bring in rich prior knowledge about intuitive physics and strong motor control priors when they approach a new task (Hespos et al., 2009; Baillargeon, 2004; 1994; Wolpert & Ghahramani, 2000). Here, we have taken some initial steps to explore the importance of such priors in context of human gameplay. ",
+        "bbox": [
+            174,
+            728,
+            825,
+            784
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 GRAVITY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            805,
+            279,
+            819
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "One of the most obvious forms of knowledge that we have about the physical world is with regards to gravity, i.e., things fall from up to down. To mask this prior, we created a version of the game in which the whole game window was rotated $9 0 ^ { \\circ }$ (refer to Figure $2 ( \\mathrm { h } ) _ { \\cdot }$ ). In this way, the gravity was reversed from left to right (as opposed to up to down). As shown in Figure 7, participants spent more time to solve this game compared to the original version with average time taken close to 3 minutes $( p < 0 . 0 1 )$ . The average number of deaths and number of states explored was also significantly larger than the original version $( p < 0 . 0 1 )$ . ",
+        "bbox": [
+            174,
+            827,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/fe57c9bff923118ead29402503f9e21af64cc76837b8dca3ee63c45ab9747c73.jpg",
+        "image_caption": [
+            "Figure 7: Quantifying physics and motor control priors. Graph shows performance of participants in original version, game with gravity reversed, and game with key controls reversed. Number of deaths is divided by 2 and number of states is divided by 1000. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            364,
+            99,
+            629,
+            222
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.2 MUSCLE MEMORY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            280,
+            341,
+            292
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Human players also come with knowledge about the consequences of actions such as pressing arrow keys moves the agent sprite in the corresponding directions (i.e., pressing up makes the agent sprite jump, pressing left makes the agent sprite go left and so forth). We created a version of the game in which we reversed the arrow key controls. Thus, pressing the left arrow key made the agent sprite go right, pressing the right key moved the sprite left, pressing the down key made the player jump (or go up the stairs), and pressing the up key made the player go down the stairs. Participants again took longer to solve this game compared to the original version with average time taken close to 3 minutes (refer to Figure 7). The average number of deaths and number of states explored was also significantly larger than the original version $( p \\ < \\ 0 . 0 1 )$ . Interestingly, the performance of players when the gravity was reversed, and key controls were reversed is similar, with no significant difference between the two conditions. ",
+        "bbox": [
+            173,
+            299,
+            825,
+            452
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 CONTROLLING FOR CHANGE IN COMPLEXITY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            477,
+            581,
+            492
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "So far in this paper, we have manipulated various visual priors while keeping the underlying game and reward structure exactly the same. We have assumed that this will influence human performance while keeping RL agent performance unchanged, since RL does not have any priors to begin with. However, one possible confound is that the visual complexity of the modified games might have changed from the original game version, because masking out priors without changing visual complexity is extremely difficult. ",
+        "bbox": [
+            174,
+            500,
+            825,
+            583
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To control for this confound, we investigated the performance of an RL agent on the various game manipulations. If RL agents are not affected by the game manipulations, then it would suggest that prior knowledge and not visual complexity is the main reason behind the change in human performance. Note that this confound is not present in the physics and motor control experiments as the visual input stays the same as the original game. ",
+        "bbox": [
+            174,
+            589,
+            825,
+            660
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To this end, we systematically created different versions of the game in Figure 1(a) to ablate semantics, the concept of object, affordance, and similarity as shown in Figure 8. Note that the game used for human experiments shown in Figure 2 is more complex than the game used for RL experiments in Figure 8. This is because the larger game was simply too hard for state-of-the-art RL agents to solve. Apart from the difference in the game size, we tried to make the games as similar as possible. Even though this version of the game is simpler (regarding size, number of objects etc.), we note that this game is still non-trivial for an RL agent. For instance, due to the sparse reward structure of the game, both A3C (Mnih et al., 2016) and breadth-first search didn’t come close to solving the game even after 10 million steps. Hence, for our purpose, we used an RL algorithm augmented with a curiosity based exploration strategy (Pathak et al., 2017). For each game version, we report the mean performance of five random seeds that succeeded. ",
+        "bbox": [
+            174,
+            666,
+            825,
+            819
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "As shown in Figure 8(e), the RL agent was unaffected by the removal of semantics, the concept of objects, as well as affordances – there is no significant difference between the mean score of the RL agent on these games when compared to the performance on the original game $( p > 0 . 0 5 )$ . This suggests that the drop in human performance in these game manipulations is not due to the change in visual complexity, but it is rather due to the masking of the various priors. On the other hand, the performance of the RL agent does worsen when visual similarity is masked as it takes nearly twice as many interactions to complete the game compared to the original version. We believe this is due to to the use of convolutional neural networks that implicitly impose the prior of visual similarity rather than simply due to the change in visual complexity. ",
+        "bbox": [
+            174,
+            827,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/7df00ec37565f947b2632b34158d12258e7b7bacb8dbd404173302b2ddc64feb.jpg",
+        "image_caption": [
+            "Figure 8: Quantifying the performance of RL agent. (a) Game without semantic information. (b) Game with masked and distractor objects to ablate concept of objects. (c) Game without affordance information. (d) Game without similarity information. (e) Performance of RL agent on various game manipulations (steps shown in order of million). Error bars indicate standard error of mean for the 5 random seeds. The RL agent performs similarly on all games except for the one without visual similarity. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            99,
+            825,
+            193
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            296,
+            823,
+            325
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "7 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            352,
+            310,
+            367
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "While there is no doubt that the performance of deep RL algorithms is impressive, there is much to be learned from human cognition if our goal is to enable RL agents to solve sparse reward tasks with human-like efficiency. Humans have the amazing ability to use their past knowledge (i.e., priors) to solve new tasks quickly. Success in such scenarios critically depends on the agent’s ability to explore its environment and then promptly learn from its successes (Daw et al., 2006; Cohen et al., 2007). In this vein, our results demonstrate the importance of prior knowledge in helping humans explore efficiently in these sparse reward environments (Knox et al., 2012; Gershman & Niv, 2015). ",
+        "bbox": [
+            173,
+            377,
+            825,
+            476
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "However, being equipped with strong prior knowledge can sometimes lead to constrained exploration that might not be optimal in all environments (Lucas et al., 2014; Bonawitz et al., 2011). For instance, consider the game shown in Figure 9 consisting of a robot and a princess object. The game environment also includes rewards in hidden locations (shown as dashed yellow boxes only for illustration). When tasked to play this game, human participants $\\mathrm { ( n { = } 3 0 } ) _ { , }$ ) immediately assume that princess is the goal and do not explore the free space containing hidden rewards. They directly reach the princess and thereby terminate the game with sub-optimal rewards. In contrast, a random agent (30 seeds) ends up obtaining almost four times more reward than human players as shown in Figure 9. Thus, while incorporating prior knowledge in RL agents has many potential benefits, future work should also consider challenges regarding under-constrained exploration in certain kinds of settings. ",
+        "bbox": [
+            173,
+            482,
+            825,
+            635
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "While our paper primarily investigated object priors (and physics priors to some extent), humans also possess rich prior knowledge about the world in the form of intuitive psychology and also bring in various priors about general video game playing such as that moving up and to the right in games is generally correlated with progress, games have goals, etc. Studying the importance of such priors will be an interesting future direction of research. ",
+        "bbox": [
+            174,
+            642,
+            825,
+            712
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Building RL algorithms that require fewer interactions to reach the goal (i.e., sample efficient algorithms) is an active area of research, and further progress is inevitable. In addition to developing better optimization methods, we believe that instead of always initializing learning from scratch, either incorporating prior knowledge directly or constructing mechanisms for condensing experience into reusable knowledge (i.e., learning priors through continual learning) might be critical for building RL agents with human-like efficiency. Our work takes first steps toward quantifying the importance of various priors that humans employ in solving video games and in understanding how prior knowledge makes humans good at such complex tasks. We believe that our results will inspire researchers to think about different mechanisms of incorporating prior knowledge in the design of RL agents. We also hope that our experimental platform of video games, available in open-source, will fuel more detailed studies investigating human priors and a benchmark for quantifying the efficacy of different mechanisms of incorporating prior knowledge into RL agents. ",
+        "bbox": [
+            173,
+            719,
+            825,
+            803
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/545251162cf99cc4a4b04eb7881fad9852398bb62b8a09c2d2f92a2e484ab430.jpg",
+        "image_caption": [
+            "Figure 9: Prior information constrains human exploration. (Left) A very simple game with hidden rewards (shown in dashed yellow). (Right) Average rewards accumulated by human players vs a random agent. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            334,
+            815,
+            655,
+            882
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGEMENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            213,
+            357,
+            227
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We thank Jordan Suchow, Michael Chang, Shubham Tulsiani, Alison Gopnik, and other members of the BAIR community for helpful discussions and comments. This work has been supported, in part, by Google, ONR MURI N00014-14-1-0671, Berkeley DeepDrive, NVIDIA Graduate Fellowship to DP, and the Valrhona Reinforcement Learning Fellowship. ",
+        "bbox": [
+            176,
+            236,
+            825,
+            291
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            316,
+            285,
+            332
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Renee Baillargeon. How do infants learn about the physical world? Current Directions in Psychological Science, 3(5):133–140, 1994. ",
+        "bbox": [
+            173,
+            340,
+            821,
+            368
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Renee Baillargeon. Infants’ physical world. ´ Current directions in psychological science, 13(3): 89–94, 2004. ",
+        "bbox": [
+            173,
+            377,
+            821,
+            406
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Marc Bellemare, Sriram Srinivasan, Georg Ostrovski, Tom Schaul, David Saxton, and Remi Munos. Unifying count-based exploration and intrinsic motivation. In NIPS, 2016. ",
+        "bbox": [
+            171,
+            415,
+            821,
+            444
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Elizabeth Bonawitz, Patrick Shafto, Hyowon Gweon, Noah D Goodman, Elizabeth Spelke, and Laura Schulz. The double-edged sword of pedagogy: Instruction limits spontaneous exploration and discovery. Cognition, 120(3):322–330, 2011. ",
+        "bbox": [
+            176,
+            453,
+            823,
+            496
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Susan Carey. The origin of concepts. Oxford University Press, 2009. ",
+        "bbox": [
+            173,
+            503,
+            625,
+            520
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jonathan D Cohen, Samuel M McClure, and J Yu Angela. Should i stay or should i go? how the human brain manages the trade-off between exploitation and exploration. Philosophical Transactions of the Royal Society B: Biological Sciences, 362(1481):933–942, 2007. ",
+        "bbox": [
+            176,
+            527,
+            820,
+            571
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nathaniel D Daw, John P O’Doherty, Peter Dayan, Ben Seymour, and Raymond J Dolan. Cortical substrates for exploratory decisions in humans. Nature, 441(7095):876–879, 2006. ",
+        "bbox": [
+            173,
+            579,
+            823,
+            609
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Samuel J Gershman and Yael Niv. Novelty and inductive generalization in human reinforcement learning. Topics in cognitive science, 7(3):391–415, 2015. ",
+        "bbox": [
+            171,
+            617,
+            823,
+            646
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "James J Gibson. The ecological approach to visual perception: classic edition. Psychology Press, 2014. ",
+        "bbox": [
+            171,
+            655,
+            823,
+            684
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Shixiang Gu, Timothy Lillicrap, Ilya Sutskever, and Sergey Levine. Continuous deep q-learning with model-based acceleration. In ICML, 2016. ",
+        "bbox": [
+            171,
+            693,
+            823,
+            722
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Susan J Hespos, Alissa L Ferry, and Lance J Rips. Five-month-old infants have different expectations for solids and liquids. Psychological Science, 20(5):603–611, 2009. ",
+        "bbox": [
+            171,
+            729,
+            823,
+            760
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "W Bradley Knox, A Ross Otto, Peter Stone, and Bradley Love. The nature of belief-directed exploratory choice in human decision-making. Frontiers in psychology, 2:398, 2012. ",
+        "bbox": [
+            171,
+            768,
+            823,
+            797
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kari S Kretch and Karen E Adolph. Cliff or step? posture-specific learning at the edge of a drop-off. Child Development, 84(1):226–240, 2013. ",
+        "bbox": [
+            174,
+            806,
+            823,
+            835
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Brenden M Lake, Tomer D Ullman, Joshua B Tenenbaum, and Samuel J Gershman. Building machines that learn and think like people. Behavioral and Brain Sciences, pp. 1–101, 2016. ",
+        "bbox": [
+            169,
+            843,
+            825,
+            872
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Christopher G Lucas, Sophie Bridgers, Thomas L Griffiths, and Alison Gopnik. When children are better (or at least more open-minded) learners than adults: Developmental differences in learning the forms of causal relationships. Cognition, 131(2):284–299, 2014. ",
+        "bbox": [
+            176,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jean M. Mandler. Representation. In Cognition, perception, and language: Handbook of child psychology. John Wiley & Sons Inc, 1998. ",
+        "bbox": [
+            169,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Denis Mareschal and Paul C Quinn. Categorization in infancy. Trends in cognitive sciences, 5(10): 443–450, 2001. ",
+        "bbox": [
+            173,
+            140,
+            823,
+            170
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 2015. ",
+        "bbox": [
+            176,
+            178,
+            823,
+            222
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Adria Puigdomenech Badia, Mehdi Mirza, Alex Graves, Timothy P Lillicrap, Tim Harley, David Silver, and Koray Kavukcuoglu. Asynchronous methods for deep reinforcement learning. In ICML, 2016. ",
+        "bbox": [
+            176,
+            231,
+            825,
+            273
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Junhyuk Oh, Satinder Singh, and Honglak Lee. Value prediction network. In NIPS, 2017. ",
+        "bbox": [
+            169,
+            281,
+            763,
+            297
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Deepak Pathak, Pulkit Agrawal, Alexei A Efros, and Trevor Darrell. Curiosity-driven exploration by self-supervised prediction. arXiv preprint arXiv:1705.05363, 2017. ",
+        "bbox": [
+            171,
+            306,
+            823,
+            335
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alfredo F Pereira and Linda B Smith. Developmental changes in visual object recognition between 18 and 24 months of age. Developmental science, 12(1):67–80, 2009. ",
+        "bbox": [
+            173,
+            343,
+            823,
+            372
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Elizabeth S Spelke. Principles of object perception. Cognitive science, 14(1):29–56, 1990. ",
+        "bbox": [
+            171,
+            381,
+            767,
+            397
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Elizabeth S Spelke and Katherine D Kinzler. Core knowledge. Developmental science, 10(1):89–96, 2007. ",
+        "bbox": [
+            171,
+            405,
+            823,
+            434
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Pedro A Tsividis, Thomas Pouncy, Jacqueline L Xu, Joshua B Tenenbaum, and Samuel J Gershman. Human learning in atari. In The AAAI 2017 Spring Symposium on Science of Intelligence: Computational Principles of Natural and Artificial Intelligence, 2017. ",
+        "bbox": [
+            173,
+            443,
+            821,
+            486
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Daniel M Wolpert and Zoubin Ghahramani. Computational principles of movement neuroscience. Nature neuroscience, 3:1212–1217, 2000. ",
+        "bbox": [
+            174,
+            494,
+            821,
+            523
+        ],
+        "page_idx": 10
+    }
+]

parse/train/jtrQswOMLrd/jtrQswOMLrd.md

@@ -0,0 +1,505 @@
+# Parameter-free Statistically Consistent Interpolation: Dimension-independent Convergence Rates for Hilbert kernel regression
+
+Anonymous Author(s)   
+Affiliation   
+Address   
+email
+
+# Abstract
+
+Previously, statistical textbook wisdom has held that interpolation of noisy training data will lead to poor generalization. However, recent work has shown that this is not true and that good generalization can be obtained with function fits that interpolate training data. This could explain why overparameterized deep nets with zero or small training error do not necessarily overfit and could generalize well. Data interpolation schemes have been exhibited that are provably Bayes optimal in the large sample limit and achieve the theoretical lower bounds for excess risk (Statistically Consistent Interpolation) in any dimension. These interpolation schemes are non-parametric Nadaraya-Watson style estimators with singular kernels, which exhibit statistical consistency in any data dimension for large sample sizes. The recently proposed weighted interpolating nearest neighbors scheme (wiNN) is in this class, as is the previously studied Hilbert kernel interpolation scheme. In the Hilbert scheme, the regression function estimator for a set of labelled data pairs, $( x _ { i } , y _ { i } ) \in \mathbb { R } ^ { d } \times \mathbb { R }$ , $i = 0 , . . . , n$ , has the form $\begin{array} { r } { \hat { f } ( x ) = \sum _ { i } y _ { i } w _ { i } ( x ) } \end{array}$ , where $\begin{array} { r } { w _ { i } ( x ) = \| x - x _ { i } \| ^ { - d } / \sum _ { j } \| x - x _ { j } \| ^ { - d } } \end{array}$ . This interpolating function estimator is unique in being entirely free of parameters and does not require bandwidth selection. While statistical consistency was previously proven for this scheme, the precise convergence rates for the finite sample risk were not established. Here, we carry out a comprehensive study of the asymptotic finite sample behavior of the Hilbert kernel regression scheme and prove a number of relevant theorems. We prove under broad conditions that the excess risk of the Hilbert regression estimator is asymptotically equivalent pointwise to $\sigma ^ { 2 } ( x ) / \ln ( n )$ where $\scriptstyle { \bar { \sigma } } ^ { 2 } ( x )$ is the noise variance. We also show that the excess risk of the plugin classifier is upper bounded by $2 | f ( x ) - 1 / 2 | ^ { 1 - \alpha } ( 1 + \varepsilon ) ^ { \alpha } \sigma ^ { \alpha } ( x ) ( \ln ( n ) ) ^ { - { \frac { \alpha } { 2 } } }$ , for any $0 < \alpha < 1$ , where $f$ is the regression function $x \mapsto \mathbb { E } [ y | x ]$ . Our proofs proceed by deriving asymptotic equivalents of the moments of the weight functions $w _ { i } ( x )$ for large $n$ , for instance for $\beta > 1$ , $\mathbb { E } [ w _ { i } ^ { \beta } ( x ) ] \sim _ { n  \infty }$ ((β − 1)n ln(n))−1. We further derive an asymptotic equivalent for the Lagrange function and explicitly exhibit the nontrivial extrapolation properties of this estimator. Notably, the convergence rates are independent of data dimension and the excess risk is dominated by the noise variance. The bias term, for which we also give precise asymptotic estimates, is always subleading when the density of data at the considered point is strictly positive. If this local density is zero, we show that the bias term does not vanish in the limit of a large data set and we compute its limit explicitly. Finally, we present heuristic arguments for a universal $w ^ { - 2 }$ power-law behavior of the probability density of the weights in the large $n$ limit.
+
+38 Data interpolation and statistical regression of noisy data are both classical subjects but their domain   
+39 of application have been disjoint until recently. Scattered data interpolation techniques [1] are   
+40 generally used for clean data. On the other hand, when supervised learning or statistical regression   
+41 techniques are applied to noisy data, in general smoothing or regularization methods are applied   
+42 to prevent training data interpolation, as the latter is believed to lead to poor generalization [2].   
+43 However, accumulating empirical evidence from overparameterized deep networks has shown that   
+44 data interpolation (equivalently, zero error on the training set) does not automatically imply poor   
+45 generalization [3, 4]. This has in turn given rise to a rapidly growing body of theoretical work to   
+46 understand how and why noisy data interpolation can still lead to good generalization [5, 6, 7, 8, 9,   
+47 10, 11, 12, 13, 14, 15].   
+48 A key observations in this regard is the phenomenon of Statistically Consistent Interpolation [16],   
+49 i.e., regression function estimation that interpolates training data but also generalizes as well as   
+50 possible by achieving the Bayes limit for expected generalization error (risk) when the sample size   
+51 becomes large. This hints at a rich set of theoretical questions at the interface between the disciplines   
+52 of scattered data interpolation and supervised learning, that have only begun to be addressed. In   
+53 particular, there has been comparatively little study of the generalization error or risk of interpolating   
+54 learners. Computation of generalization error bounds in machine learning often relies on the capacity   
+55 of the class of fitting functions [17], however such model complexity based bounds are not tight   
+56 enough to be useful for interpolating learners [4]. For nonparametric interpolation approaches such as   
+57 that considered here, it is also not clear what model complexity means. Thus, there is a need for other   
+58 approaches to understanding the generalization behavior of nonparametric interpolating learners,   
+59 including more direct treatments of the generalization error for specific interpolation schemes so as   
+60 to gain better theoretical understanding. The current paper addresses this need.   
+61 We present a detailed analysis of the finite-sample risk of an interpolating learner with intriguing   
+62 theoretical properties, the Hilbert kernel estimator (Devroye et. al. [18]). A unique property of   
+63 this Nadaraya-Watson (NW) style estimator [19, 20] is that it is fully parameter-free and does not   
+64 have any bandwidth or scale parameter. It is global and uses all data points for each estimate: the   
+65 associated kernel is a power law and thus scale-free. Although statistical consistency of this estimator   
+66 was proven [18] when it was proposed, there has been no systematic analysis of the associated   
+67 convergence rates and asymptotic finite sample behavior. We provide this analysis in the present   
+68 study.   
+69 Related work The only other interpolation scheme we are aware of, that is proven to be statistically   
+70 consistent in arbitrary dimensions under general conditions, is the recently proposed weighted   
+71 interpolating nearest neighbors method (wiNN) [7], which is also a NW estimator utilizing a singular   
+72 power law kernel of a very similar form but with two important differences: a finite number of   
+73 neighbors $k$ is utilized (rather than all data points), and the power law exponent $\delta$ of the NW kernel   
+74 satisfies $0 < \delta < d / 2$ rather than $\delta = d$ . To achieve consistency $k$ has to scale appropriately with   
+75 sample size. Despite the superficial resemblance, the wiNN and Hilbert Kernel estimators have quite   
+76 different convergence rates, as we will see from the results of this paper. Also worth mentioning is the   
+77 Shepard interpolation scheme [21] originally proposed for interpolation of 2D geospatial data sets,   
+78 also a NW style interpolating estimator, though used in the context of scattered data interpolation.   
+79 In scattered data interpolation [1], the focus is generally on the approximation error (corresponding   
+80 to the “bias” term in our analysis below). The approximation error of the Shepard scheme has been   
+81 analyzed [22] but as we will see below the risk for Hilbert kernel interpolation is dominated by the   
+82 noise or “variance” term. In contrast with wiNN or Hilbert kernel interpolation, other interpolating   
+83 learning methods such as simplex interpolation [7] or ridgeless kernel regression [11] are generally   
+84 not statistically consistent in fixed finite dimension [8].   
+85 Summary of results of this paper Notation and assumptions pertaining to this summary are defined   
+86 in the problem setup section below. We prove under broad conditions that the excess risk of the   
+87 Hilbert regression estimator is asymptotically equivalent pointwise to $\sigma ^ { 2 } ( x ) / \ln ( n )$ where $\sigma ^ { 2 } ( x )$ is   
+88 the noise variance. We also show that the excess risk of the plugin classifier is upper bounded by   
+89 $2 | f ( x ) - 1 / 2 | ^ { 1 - \alpha } ( 1 + \varepsilon ) ^ { \alpha } \sigma ^ { \alpha } ( x ) ( \ln ( n ) ) ^ { - { \frac { \alpha } { 2 } } }$ , for any $0 < \alpha < 1$ , where $f$ is the regression function   
+90 $x \mapsto \mathbb { E } [ y | x ]$ . Our proofs proceed by deriving asymptotic equivalents of the moments of the weight   
+91 functions $w _ { i } ( x )$ for large $n$ , for instance for $\beta > 1$ $> 1 , \mathbb { E } [ w _ { i } ^ { \beta } ( x ) ] \sim _ { n  \infty } ( ( \beta - 1 ) n \ln ( n ) ) ^ { - 1 }$ . We   
+92 further derive an asymptotic equivalent for the Lagrange function and explicitly exhibit the nontrivial   
+93 extrapolation properties of this estimator. Notably, the convergence rates are independent of data   
+94 dimension and the excess risk is dominated by the noise variance. The bias term, for which we also   
+95 give precise asymptotic estimates, is always subleading when the density of data at the considered   
+96 point is strictly positive. If this local density is zero, we show that the bias term does not vanish in the   
+97 limit of a large data set and we compute its limit explicitly. Finally, we present heuristic arguments   
+98 for a universal $w ^ { - 2 }$ power-law behavior of the probability density of the weights in the large $n$ limit.
+
+# 99 2 Problem setup
+
+100 Notation, Definitions, Statistical Model We model the labelled training data set   
+101 $( x _ { 0 } , y _ { 0 } ) , \ldots , ( x _ { n } , y _ { n } )$ as $n + 1$ i.i.d. observations of a random vector $( X , Y )$ with values in   
+102 $\mathbb { R } ^ { d } \times \mathbb { R }$ for regression, and with values in $\mathbb { R } ^ { d } \times \{ 0 , 1 \}$ for binary classification. Due to the indepen  
+103 dence property, the collection $X _ { 0 } , \ldots , X _ { n }$ has the product density $\textstyle \prod _ { i = 0 } ^ { n } \rho ( x _ { i } )$ . We will denote by $\mathbb { E }$   
+104 an expectation over the collection of $n + 1$ random vectors and by $\mathbb { E } _ { X }$ the expectation over the col  
+105 lection $X _ { 0 } , \ldots , X _ { n }$ . An expectation over the same collection while holding $X _ { i } = x _ { i }$ will be denoted   
+106 $\mathbb { E } _ { X \mid x _ { i } }$ . The regression function $f \colon  { \mathbb { R } ^ { d } } \to  { \mathbb { R } }$ is defined as the conditional mean of $Y$ given $X = x$   
+107 $f ( x ) : = \mathbb { E } [ Y \mid X = x ]$ and the conditional variance function is $\sigma ^ { 2 } ( x ) : = \mathbb { E } [ | Y - f ( X ) | ^ { 2 } | X = x ]$ .   
+108 $f$ minimizes the expected value of the mean squared prediction error (risk under squared loss),   
+109 $f = \arg \operatorname* { m i n } \mathcal { R } _ { \mathrm { s q } } ( h )$ where $\mathcal { R } _ { \mathrm { s q } } ( h ) : = \mathbb { E } [ ( h ( X ) - Y ) ^ { 2 } ]$ . Given any regression estimator ${ \hat { f } } ( x )$ the   
+110 corresponding risk can be decomposed as $\mathbb { E } [ \mathcal { R } _ { \mathrm { s q } } ( \hat { f } ( X ) ) ] = \mathcal { R } _ { \mathrm { s q } } ( f ) + \mathbb { E } [ ( \hat { f } ( X ) - f ( X ) ^ { 2 } ]$ . The   
+111 excess risk is given by $\mathcal { R } _ { \mathrm { s q } } ( \hat { f } ) - \mathcal { R } _ { \mathrm { s q } } ( f ) = \mathbb { E } [ ( \hat { f } ( X ) - f ( X ) ) ^ { 2 } ]$ . For a consistent estimator this   
+112 excess risk goes to zero as $n \to \infty$ and we are interested in characterizing the rate at which it goes to   
+113 zero with increasing $n$ (note our sample size is $n + 1$ for notational simplicity but for large $n$ this   
+114 does not change the rate).   
+115 In the case of binary classification, $Y \in \{ 0 , 1 \}$ and $f ( x ) = \mathbb { P } [ Y = 1 \mid X = x ) ]$ . Let $F \colon  { \mathbb { R } } ^ { d } \to \{ 0 , 1 \}$   
+116 denote the Bayes optimal classifier, defined by $F ( x ) : = \theta ( f ( x ) - 1 / 2 )$ where $\theta ( \cdot )$ is the Heaviside   
+117 theta function. This classifier minimizes the risk $\mathscr { R } _ { 0 / 1 } ( h ) : = \mathbb { E } \big [ \mathbb { 1 } _ { \{ h ( X ) \neq Y \} } \big ] = \mathbb { P } ( h ( X ) \neq Y )$ under   
+118 zero-one loss. Given the regression estimator $\hat { f }$ , we consider the plugin classifier ${ \hat { F } } ( x ) = \theta ( { \hat { f } } ( x ) - { \textstyle \frac { 1 } { 2 } } )$   
+119 The classification risk for the plugin classifier $\hat { F }$ is bounded as $\begin{array} { r } { \mathbb { E } [ \mathcal { R } _ { 0 / 1 } ( \hat { F } ( x ) ) ] - \mathcal { R } _ { 0 / 1 } ( F ( x ) ) \leq } \end{array}$   
+120 $2 \mathbb { E } [ | \hat { f } ( x ) - f ( x ) | ] \leq 2 \sqrt { \mathbb { E } [ ( \hat { f } ( x ) - f ( x ) ) ^ { 2 } ] } .$ .
+
+Finally, we define two sequences $a _ { n } , b _ { n } > 0$ , $n \in \mathbb { N }$ , to be asymptotically equivalent for $n  + \infty$ denoted $a _ { n } \sim _ { n \to + \infty } b _ { n }$ , if the limit of their ratio exists and $\scriptstyle \operatorname* { l i m } _ { n \to \infty } a _ { n } / b _ { n } = 1$ .
+
+123 In summary, our work will focus on the estimation of asymptotic equivalents for $\mathbb { E } [ ( \hat { f } ( x ) - f ( x ) ) ^ { 2 } ]$   
+124 and other relevant quantities as this determines the rate at which the excess risk goes to zero for   
+125 regression, and bounds the rate at which the excess risk goes to zero for classification.   
+126 Assumptions. We define the support $\Omega$ of the density $\rho$ as $\Omega = \{ x \in \mathbb { R } ^ { d } / \rho ( x ) > 0 \}$ , the closed   
+127 support $\bar { \Omega }$ as the closure of $\Omega$ , and $\Omega ^ { \circ }$ as the interior of $\Omega$ . Our results will not assume any compactness   
+128 condition on $\Omega$ or $\bar { \Omega }$ . The boundary of $\Omega$ is then defined as $\partial \Omega = \bar { \Omega } \setminus \Omega ^ { \circ }$ . We assume that $\rho$ has a   
+129 finite variance $\sigma _ { \rho } ^ { 2 }$ . In addition, we will most of the time assume that the density $\rho$ is continuous at the   
+130 considered point $x \in \Omega ^ { \circ }$ , and in some cases, $x \in \partial \Omega \cap \Omega$ .
+
+131 For the regression function $f$ , we will obtain results assuming either of the following conditions
+
+$C _ { \mathrm { C o n t } } ^ { f } \colon f$ is continuous at the considered $x$ ,   
+• $C _ { \mathrm { H o l d e r } } ^ { f }$ : fo $x \in \Omega ^ { \circ }$ $\alpha _ { x } > 0$ $K _ { x } > 0$ $\delta _ { x } > 0$ , such thatαx   
+$x ^ { \prime } \in \Omega$ $\begin{array} { r } { \| \boldsymbol { x } - \boldsymbol { x } ^ { \prime } \| \le \delta _ { x } \implies | f ( \boldsymbol { x } ) - f ( \boldsymbol { x } ^ { \prime } ) | \le K _ { x } \| \boldsymbol { x } - \boldsymbol { \mathrm { \widehat { x } } } } \end{array}$   
+(local Hölder smoothness condition),
+
+36 where condition $C _ { \mathrm { H o l d e r } } ^ { f }$ r is obviously stronger than CfCont . In addition, we will always assume a   
+37 growth condition for the regression function $f$ :
+
+$$
+\begin{array} { r } { \bullet C _ { \mathrm { G r o w t h } } ^ { f } \colon \int \rho ( y ) \frac { f ^ { 2 } ( y ) } { 1 + \| y \| ^ { 2 d } } d ^ { d } y < \infty . } \end{array}
+$$
+
+139 As for the variance function $\sigma$ , we will obtain results assuming either that $\sigma$ is bounded or satisfies a   
+140 growth condition similar to the one above
+
+$$
+\begin{array} { r } { \bullet C _ { \mathrm { G r o w t h } } ^ { \sigma } \colon \int \rho ( y ) \frac { \sigma ^ { 2 } ( y ) } { 1 + \| y \| ^ { 2 d } } d ^ { d } y < \infty . } \end{array}
+$$
+
+When we will assume condition 143 $C _ { \mathrm { G r o w t h } } ^ { \sigma }$ (obviously satisfied when $\sigma ^ { 2 }$ is bounded), we will also assume a continuity condition 144 $C _ { \mathrm { { C o n t } } } ^ { \sigma }$ for $\sigma$ at the considered $x$ .
+
+145 Note that all our results can be readily extended in the case where $x \in \partial \Omega = \bar { \Omega } \backslash \Omega ^ { \circ }$ but keeping   
+146 the condition $\rho ( x ) > 0$ (i.e., $x \in \partial \Omega \cap \Omega )$ , and assuming the continuity at $x$ of $\rho$ as seen as a   
+147 function restricted to $\Omega$ , i.e., ${ \mathrm { l i m } } _ { y \in \Omega \to x } \rho ( y ) = \rho ( x )$ . Useful examples are when the support $\Omega$ of   
+148 $\rho$ is a $d$ -dimensional sphere or hypercube and $x$ is on the surface of $\Omega$ (but still with $\rho ( x ) > 0 ,$ ). To   
+149 guarantee these results for $x \in \partial \Omega \cap \Omega$ , we need also to assume the continuity at $x$ of $f$ , and assume   
+150 that $\Omega$ is smooth enough near $x$ , so that there exists a strictly positive local solid angle $\omega _ { x }$ defined by
+
+$$
+\omega _ { x } = \operatorname* { l i m } _ { r \to 0 } \frac { 1 } { V _ { d } \rho ( x ) r ^ { d } } \int _ { \lVert x - y \rVert \leq r } \rho ( y ) d ^ { d } y = \operatorname* { l i m } _ { r \to 0 } \frac { 1 } { V _ { d } r ^ { d } } \int _ { y \in \Omega / \lVert x - y \rVert \leq r } d ^ { d } y ,
+$$
+
+151 where $V _ { d } = S _ { d } / d = \pi ^ { d / 2 } / \Gamma ( d / 2 + 1 )$ is the volume of the unit ball in $d$ dimensions, and the second   
+152 inequality results from the continuity of $\rho$ at $x$ . If $x \in \Omega ^ { \circ }$ , we have $\omega _ { x } = 1$ , while for $x \in \partial \Omega$ , we   
+153 have $0 \leq \omega _ { x } \leq 1$ . For instance, if $x$ is on the surface of a sphere or on the interior of a face of a   
+154 hypercube (and in general, when the boundary near $x$ is locally an hyperplane), we have $\begin{array} { r } { \omega _ { x } = \frac { 1 } { 2 } } \end{array}$ . If $x$   
+155 is a corner of a hypercube, we have $\begin{array} { r } { \omega _ { x } = \frac { 1 } { 2 ^ { d } } } \end{array}$ . From our methods of proof presented in the appendix,   
+156 it should be clear that all our results for $x \in \Omega ^ { \circ }$ perfectly generalize to any $x \in \partial \Omega \cap \Omega$ for which   
+157 $\omega _ { x } > 0$ , by simply replacing $V _ { d }$ whenever it appears in our different results by $\omega _ { x } V _ { d }$ .
+
+158 Hilbert kernel interpolating estimator and Bias-Variance decomposition. The Hilbert kernel regression estimator 159 ${ \hat { f } } ( x )$ is a Nadaraya-Watson style estimator employing a singular kernel:
+
+$$
+\begin{array} { r c l } { { w _ { i } ( x ) } } & { { = } } & { { \displaystyle \frac { \| x - x _ { i } \| ^ { - d } } { \sum _ { j = 0 } ^ { n } \| x - x _ { j } \| ^ { - d } } , } } \\ { { \hat { f } ( x ) } } & { { = } } & { { \displaystyle \sum _ { i = 0 } ^ { n } w _ { i } ( x ) y _ { i } . } } \end{array}
+$$
+
+160 The weights $w _ { i } ( x )$ are also called Lagrange functions in the interpolation literature and satisfy the   
+161 interpolation property $w _ { i } ( x _ { j } ) = \delta _ { i j }$ , where $\delta _ { i j } = 1$ , if $i = j$ , and 0 otherwise. At any given point   
+162 $x$ , they provide a partition of unity so that $\textstyle \sum _ { i = 0 } ^ { \tilde { n } } w _ { i } ( x ) = 1$ . The mean squared error between the   
+163 Hilbert estimator and the true regression function has a bias-variance decomposition (using the i.i.d   
+164 condition and the earlier definitions)
+
+$$
+\begin{array} { r c l } { { \hat { f } ( x ) - f ( x ) } } & { { = } } & { { \displaystyle \sum _ { i = 0 } ^ { n } w _ { i } ( x ) [ f ( x _ { i } ) - f ( x ) ] + \sum _ { i = 0 } ^ { n } w _ { i } ( x ) [ y _ { i } - f ( x _ { i } ) ] , } } \\ { { \mathbb { E } [ ( \hat { f } ( x ) - f ( x ) ) ^ { 2 } ] } } & { { = } } & { { \displaystyle B ( x ) + \mathcal { V } ( x ) , } } \\ { { ( B i a s ) \mathcal { B } ( x ) } } & { { = } } & { { \displaystyle \mathbb { E } _ { X } \left[ \left( \sum _ { i = 0 } ^ { n } w _ { i } ( x ) [ f ( x _ { i } ) - f ( x ) ] \right) ^ { 2 } \right] , } } \\ { { ( V a r i a n c e ) \mathcal { V } ( x ) } } & { { = } } & { { \displaystyle \mathbb { E } \left[ \sum _ { i = 0 } ^ { n } w _ { i } ^ { 2 } ( x ) [ y _ { i } - f ( x _ { i } ) ] ^ { 2 } \right] = \mathbb { E } _ { X } \left[ \sum _ { i = 0 } ^ { n } w _ { i } ^ { 2 } ( x ) \sigma ^ { 2 } ( x _ { i } ) \right] . } } \end{array}
+$$
+
+165 The present work derives asymptotic behaviors and bounds for the regression and classification risk   
+166 of the Hilbert estimator for large sample size $n$ . These results are derived by analyzing the large $n$   
+167 behaviors of the bias and variance terms, which in turn depend on the behavior of the moments of the   
+168 weights or the Lagrange functions $w _ { i } ( x )$ . For all these quantities, asymptotically equivalent forms   
+169 are derived. The proofs exploit a simple integral form of the weight function and details are provided   
+170 in the appendix, while the body of the paper provides the results and associated discussions.
+
+# 3 Results
+
+# 3.1 The weights, variance and bias terms
+
+# 3.1.1 Moments of the weights: large $n$ behavior
+
+4 In this section, we consider the moments and the distribution of the weights $w _ { i } ( x )$ at a given point $x$ .   
+75 The first moment is simple to compute. Since the weights sum to 1 and $X _ { i }$ are i.i.d, it follows that   
+76 $\mathbb { E } _ { X \mid x _ { i } } [ w _ { i } ( x ) ]$ are all equal and thus $\mathbb { E } _ { X | x _ { i } } [ w _ { i } ( x ) ] = ( \overline { { n } } + 1 ) ^ { - 1 }$ . The other moments are much less   
+77 trivial to compute and we prove the following theorem in the appendix A.2:   
+78 Theorem 3.1. For $x \in \Omega ^ { \circ }$ (so that $\rho ( x ) > 0 ,$ ), we assume $\rho$ continuous at $x$ . Then, the moments of   
+179 the weight $w _ { 0 } ( x )$ satisfy the following properties:
+
+180
+
+• For $\beta > 1$ :
+
+$$
+\mathbb { E } [ w _ { 0 } ^ { \beta } ( x ) ] \underset { n  + \infty } { \sim } \frac { 1 } { ( \beta - 1 ) n \ln ( n ) } .
+$$
+
+• For $0 < \beta < 1$ : defining $\begin{array} { r } { \kappa _ { \beta } ( x ) : = \int \frac { \rho ( x + y ) } { | | y | | ^ { \beta d } } d ^ { d } y < \infty } \end{array}$ , we have
+
+$$
+\mathbb { E } [ w _ { 0 } ^ { \beta } ( x ) ] \underset { n  + \infty } { \sim } \frac { \kappa _ { \beta } ( x ) } { ( V _ { d } \rho ( x ) n \ln ( n ) ) ^ { \beta } } .
+$$
+
+• For $\beta < 0$ : all moments for $\beta \leq - 1$ are infinite, and the moments of order $- 1 < \beta < 0$ satisfy
+
+$$
+\mathbb { E } \left[ w _ { 0 } ^ { \beta } ( x ) \right] \leq 1 + n \kappa _ { | \beta | } ( x ) \kappa _ { \beta } ( x ) ,
+$$
+
+184
+
+so that a sufficient condition for its existence is $\begin{array} { r } { \kappa _ { \beta } ( x ) = \int \rho ( x + y ) \lvert | y \rvert | ^ { \lvert \beta \rvert d } d ^ { d } y < \infty . } \end{array}$ .
+
+185 Heuristically, the behavior of these moments are consistent with the random variable $W = w _ { 0 } ( x )$   
+186 having a probability distribution satisfying a scaling relation $\begin{array} { r } { P ( W ) = \frac { 1 } { W _ { n } } p \left( \frac { W } { W _ { n } } \right) } \end{array}$ , with the scaling   
+187 function $p$ having the universal tail (i.e., independent of $x$ and $\rho \mathrm { \hbar }$ ), $p ( w ) \sim w ^ { - 2 }$ , and a scale $W _ { n }$   
+188 expected to vanish with $n$ , when $n  + \infty$ . With this assumption, we can determine the scale $W _ { n }$ by   
+189 imposing the exact condition $\mathbb { E } [ W ] = 1 / ( n + 1 ) \sim 1 / n$ :
+
+$$
+\begin{array} { r c l } { \mathbb { E } [ W ] } & { = } & { \displaystyle \frac { 1 } { W _ { n } } \int _ { 0 } ^ { 1 } p \left( \frac { W } { W _ { n } } \right) W d W = W _ { n } \int _ { 0 } ^ { \frac { 1 } { W _ { n } } } p ( w ) w d w } \\ & { \sim } & { W _ { n } \int _ { 1 } ^ { \frac { 1 } { W _ { n } } } \displaystyle \frac { d w } { w } \sim - W _ { n } \ln ( W _ { n } ) \sim \frac { 1 } { n } , } \end{array}
+$$
+
+$\begin{array} { r } { W _ { n } \sim \frac { 1 } { n \ln ( n ) } } \end{array}$ . Then, the moment of order $\beta > 1$
+
+$$
+\mathbb { E } [ W ^ { \beta } ] = \frac { 1 } { W _ { n } } \int _ { 0 } ^ { 1 } p \left( \frac { W } { W _ { n } } \right) W ^ { \beta } d W \sim W _ { n } \int _ { 0 } ^ { 1 } W ^ { \beta - 2 } d W \underset { n \to + \infty } { \sim } \frac { 1 } { ( \beta - 1 ) n \ln ( n ) } ,
+$$
+
+191 which indeed coincides with the first result of Theorem 3.1. Our heuristic argument also suggests   
+192 that in the case $0 < \beta < 1$ , we have
+
+$$
+\mathbb { E } [ W ] = \frac { 1 } { W _ { n } } \int _ { 0 } ^ { 1 } p ( \frac { W } { W _ { n } } ) W ^ { \beta } d W \quad \underset { n  + \infty } { \sim } \quad \frac { \int _ { 0 } ^ { + \infty } p ( w ) w ^ { \beta } d w } { ( n \ln ( n ) ) ^ { \beta } } ,
+$$
+
+193 where the last integral converges since $p ( w ) \underset { w  + \infty } { \sim } w ^ { - 2 }$ and $\beta < 1$ . This result is perfectly consistent   
+194 with Eq. (9) in Theorem 3.1, and suggests that $\begin{array} { r } { \int _ { 0 } ^ { + \infty } p \left( w \right) w ^ { \beta } d w = \frac { \kappa _ { \beta } \left( x \right) } { \left( V _ { d } \rho \left( x \right) \right) ^ { \beta } } } \end{array}$ κβ(x)(Vdρ(x)) β . Interestingly, for   
+195 $0 < \beta < 1$ , and contrary to the case $\beta > 1$ , we find that the large $n$ equivalent of the moment is not   
+196 universal and depends explicitly on $x$ and the density $\rho$ . As for moments of order $- 1 < \beta < 0$ , we   
+197 conjecture that they are still given by Eq. (9) (and equivalently, by Eq. (14)) provided they exist, and   
+198 that the sufficient condition for their existence $\kappa _ { \beta } ( x ) < \infty$ is hence also necessary, since $\kappa _ { \beta } ( x )$ also   
+199 appears in Eq. (9). The fact that moments for $\beta \leq - 1$ do not exist strongly suggests that $p ( 0 ) > 0$ .   
+200 In fact, Eq. (14)) also suggests that all moments for $- 1 < \beta < 0$ exist if and only if $0 < p ( 0 ) < \infty$ .   
+201 In the Fig. 2 of the appendix, we present numerical simulations confirming our scaling ansatz, the   
+202 fact that $\overline { { p } } ( w ) \underset { w  + \infty } { \sim } w ^ { - 2 }$ , and the quantitative prediction for $W _ { n }$ .   
+203 It is shown in Devroye et al. [18] that the Hilbert kernel regression estimate does not converge   
+204 almost surely (a.s.) by giving a specific example. Insight can be gained into this lack of almost sure   
+205 convergence by considering the weight function $w _ { 0 } ( x )$ , for a sequence of independent training sample   
+206 sets of increasing size $n + 1$ . Let the corresponding sequence of weights be denoted as $\omega _ { n } \in [ 0 , 1 ]$ .   
+207 From Theorem 3.1, it is clear that $\omega _ { n }$ converges to zero in probability, since the following Chebyshev   
+208 bound holds (analogous to the bound on the regression risk):
+
+$$
+\mathbb { P } ( \omega _ { n } > \varepsilon ) \leq \frac { 1 + \delta } { \varepsilon ^ { 2 } n \ln ( n ) } ,
+$$
+
+209 for arbitrary $\varepsilon > 0$ and $\delta > 0$ , and for $n$ larger than some constant $N _ { x , \delta }$ . Alternatively, one can   
+210 exploit the fact that $\begin{array} { r } { \mathbb { E } [ \omega _ { n } ] = \frac { 1 } { n + 1 } } \end{array}$ , leading to $\begin{array} { r } { \mathbb { P } ( \omega _ { n } > \varepsilon ) \le \frac { 1 } { \varepsilon n } } \end{array}$ , which is less stringent than Eq. (15)   
+211 as far as the $n$ -dependence is concerned, but is more stringent for the $\varepsilon$ -dependence of the bounds.   
+212 Let us show heuristically that $\omega _ { n }$ does not converge a.s. to zero. Consider the infinite sequence of   
+213 events ${ \mathcal { E } } _ { n } \equiv \{ \omega _ { n } > \varepsilon \}$ , $n \in \mathbb N$ , and the corresponding infinite sum $\begin{array} { r } { \sum _ { n } \mathbb { P } ( \mathcal { E } _ { n } ) = \sum _ { n } \mathbb { P } ( \omega _ { n } > \varepsilon ) } \end{array}$ .   
+214 Exploiting our previous heuristic argument for the scaling form of the distribution of weights, we   
+215 obtain
+
+$$
+\mathbb { P } ( \omega _ { n } > \varepsilon ) = \int _ { \varepsilon } ^ { 1 } { \frac { 1 } { W _ { n } } } p \left( { \frac { W } { W _ { n } } } \right) d W \sim \int _ { \varepsilon n \ln n } ^ { n \ln n } { \frac { d w } { w ^ { 2 } } } \sim { \frac { 1 - \varepsilon } { \varepsilon n \ln ( n ) } } .
+$$
+
+216 Since PNn=2 1n ln(n) $\begin{array} { r } { \sum _ { n = 2 } ^ { N } { \frac { 1 } { n \ln ( n ) } } \sim \ln ( \ln ( N ) ) } \end{array}$ is a divergent series, a Borel-Cantelli argument suggests that an   
+217 infinite number of the events ${ \mathcal { E } } _ { n }$ (i.e., $\omega _ { n } > \varepsilon$ ) must occur, which implies that $\omega _ { n }$ does not converge   
+218 a.s. to 0. Note that the weights are equal to 1 at the data points due to the interpolation condition, so   
+219 that large weights occasionally occur, causing the lack of a.s. convergence.
+
+# 3.1.2 Lagrange function: scaling limit
+
+The expected value of the Lagrange functions $w _ { i } ( x )$ have a simple form in the large $n$ limit. Due to the i.i.d. condition the indices $i$ are exchangeable and we set $i = 0$ for the computation of the expected Lagrange function $L _ { 0 } ( x ) = \mathbb { E } _ { X \mid x _ { 0 } } [ w \overline { { 0 } } ( x ) ]$ . Thus, one of the sample points (denoted $x _ { 0 }$ ) is held fixed and the other ones are averaged over in computing the expected Lagrange function. For $x _ { 0 } \neq x$ kept fixed, we have $\begin{array} { r } { \operatorname* { l i m } _ { n  \infty } L _ { 0 } ( x ) = 0 } \end{array}$ . However, we show in the appendix A.3 that $L _ { 0 } ( x )$ takes a very simple form when taking a specific scaling limit:
+
+Theorem 3.2. For $x \in \Omega ^ { \circ }$ , we assume $\rho$ continuous at $x$ . Then, in the limit (denoted by $\operatorname { l i m } _ { Z }$ ), $n $ $+ \infty ,$ , $\lVert \boldsymbol { x } - \boldsymbol { x } _ { 0 } \rVert ^ { - d } \to + \infty$ (i.e., $x _ { 0 } \to x _ { , }$ ), and such that $z _ { x } ( n , x _ { 0 } ) = V _ { d } \rho ( x ) \| x - x _ { 0 } \| ^ { d } n \log ( n ) \to Z$ the Lagrange function $L _ { 0 } ( x ) = \mathbb { E } _ { X \mid x _ { 0 } } [ w _ { 0 } ( x ) ]$ converges to a proper limit,
+
+$$
+\operatorname* { l i m } _ { Z } L _ { 0 } ( x ) = \frac { 1 } { 1 + Z } .
+$$
+
+The proof of this theorem shows that the relative error between 230 $L _ { 0 } ( x )$ and $\frac { 1 } { 1 { + } Z }$ for finite but large $n$ and large 231 $\lVert x - x _ { 0 } \rVert ^ { - d }$ , such that $z _ { x } ( n , x _ { 0 } )$ remains close to $Z$ , is $O ( 1 / \ln ( n ) )$ .
+
+232 Exploiting Theorem 3.2, we can use a simple heuristic argument to estimate the tail of the distribution   
+233 of the random variable $W = w _ { 0 } ( x )$ . Indeed, approximating $L _ { 0 } ( x )$ for finite but large $n$ by its   
+234 asymptotic for m 11+z (n,x ) , with zx(n, x0) = Vdρ(x)n log(n)kx − x0kd, we obtain
+
+$$
+\begin{array} { r c l } { \displaystyle \int _ { W } ^ { 1 } P ( W ^ { \prime } ) d W ^ { \prime } } & { \sim } & { \displaystyle \int \rho ( x _ { 0 } ) \theta \left( \frac { 1 } { 1 + V _ { d } \rho ( x ) n \log ( n ) \| x - x _ { 0 } \| ^ { d } } - W \right) d ^ { d } x _ { 0 } , } \\ & { \sim } & { \displaystyle V _ { d } \rho ( x ) \int _ { 0 } ^ { + \infty } \theta \left( \frac { 1 } { 1 + V _ { d } \rho ( x ) n \log ( n ) u } - W \right) d u , } \\ & { \sim } & { \displaystyle \frac { 1 } { n \ln ( n ) W } \quad \Longrightarrow \ P ( W ) \sim \frac { 1 } { n \ln ( n ) W ^ { 2 } } , } \end{array}
+$$
+
+235 where $\theta ( . )$ is the Heaviside function. This heuristic result is again perfectly consistent with our guess of the previous section that 236 $\begin{array} { r } { P ( W ) = \frac { 1 } { W _ { n } } p \left( \frac { W } { W _ { n } } \right) } \end{array}$ , with the scaling function $p$ having the universal
+
+tail, $p ( w ) \underset { w  + \infty } { \sim } w ^ { - 2 }$ , and a scale $\begin{array} { r } { W _ { n } \sim \frac { 1 } { n \ln ( n ) } } \end{array}$ . Indeed, in this case and in the limit $n  + \infty$ , we obtain that $\begin{array} { r } { P ( W ) \sim \frac { 1 } { W _ { n } } \left( \frac { W _ { n } } { W } \right) ^ { 2 } \sim \frac { W _ { n } } { W ^ { 2 } } \sim \frac { 1 } { n \ln ( n ) W ^ { 2 } } } \end{array}$ , which is identical to the result of Eq. (20).
+
+# 3.1.3 The variance term
+
+A simple application of the result of Theorem 3.1 for $\beta = 2$ (see appendix A.4) allows us to bound the variance term $\begin{array} { r } { \mathcal { V } ( x ) = \mathbb { E } \left[ \sum _ { i = 0 } ^ { n } w _ { i } ^ { 2 } ( x ) [ y _ { i } - f ( x _ { i } ) ] ^ { 2 } \right] } \end{array}$ for a bounded variance function $\sigma ^ { 2 }$ :
+
+Theorem 3.3. For $x \in \Omega ^ { \circ }$ , $\rho$ continuous at $x$ , $\sigma ^ { 2 } \le \sigma _ { 0 } ^ { 2 }$ , and for any $\varepsilon > 0$ , there exists a constant $N _ { x , \varepsilon }$ such that for $n \geq N _ { x , \varepsilon }$ , we have
+
+$$
+\mathcal { V } ( x ) \leq ( 1 + \varepsilon ) \frac { \sigma _ { 0 } ^ { 2 } } { \ln ( n ) } .
+$$
+
+244 Relaxing the boundedness condition for $\sigma$ , but assuming the continuity of $\sigma ^ { 2 }$ at $x$ along with a growth   
+245 condition, allows us to obtain a precise asymptotic equivalent of $\mathcal { V } ( x )$ , when $n  + \infty$ :
+
+Theorem 3.4. For 246 $x \in \Omega ^ { \circ }$ , $\sigma ( x ) > 0$ , $\rho \sigma ^ { 2 }$ continuous at $x$ , and assuming the condition $C _ { \mathrm { G r o w t h } } ^ { \sigma }$ , i.e., 247 $\begin{array} { r } { \int \rho ( y ) \frac { \sigma ^ { 2 } ( y ) } { 1 + \| y \| ^ { 2 d } } d ^ { d } y < \infty } \end{array}$ , we have
+
+$$
+\mathcal { V } ( x ) \underset { n \to + \infty } { \sim } \frac { \sigma ^ { 2 } ( x ) } { \ln ( n ) } .
+$$
+
+48 Note that if the mean variance $\begin{array} { r } { \int \rho ( y ) \sigma ^ { 2 } ( y ) d ^ { d } y < \infty } \end{array}$ , which is in particular the case when $\sigma ^ { 2 }$ is   
+49 bounded over $\Omega$ , then the condition $C _ { \mathrm { G r o w t h } } ^ { \sigma }$ is in fact automatically satisfied.
+
+# 3.1.4 The bias term
+
+In appendix A.5, we prove the following three theorems for the bias term.
+
+Theorem 3.5. For 52 $x \in \Omega ^ { \circ }$ (so that $\rho ( x ) > 0 .$ ), we assume that $\rho$ is continuous at $x$ , and the conditions
+
+$$
+\begin{array} { r } { \bullet _ { \mathbf { \phi } } C _ { \mathrm { G r o w t h } } ^ { f } \colon \int _ { \mathbf { \phi } } ( y ) \frac { f ^ { 2 } ( y ) } { 1 + \| y \| ^ { 2 d } } d ^ { d } y < \infty , } \end{array}
+$$
+
+Moreover, we define 257 $\begin{array} { r } { \kappa ( x ) = \int \rho ( x + y ) \frac { f ( x + y ) - f ( x ) } { \vert \vert y \vert \vert ^ { d } } d ^ { d } y . } \end{array}$ , where we have $| \kappa ( x ) | < \infty$
+
+Then, for 258 $\kappa ( x ) \neq 0 ,$ , the bias term $\begin{array} { r } { \mathcal { B } ( x ) = \mathbb { E } _ { X } \Big [ \Big ( \sum _ { i = 0 } ^ { n } w _ { i } ( x ) [ f ( x _ { i } ) - f ( x ) ] \Big ) ^ { 2 } \Big ] } \end{array}$ satisfies
+
+$$
+\mathcal { B } ( x ) \underset { n  + \infty } { \sim } ( \mathbb { E } [ \hat { f } ( x ) ] - f ( x ) ) ^ { 2 } , \qquad \mathrm { w i t h } \quad \mathbb { E } [ \hat { f } ( x ) ] - f ( x ) \underset { n  + \infty } { \sim } \frac { \kappa ( x ) } { V _ { d } \rho ( x ) \ln ( n ) } .
+$$
+
+259 In the non generic case $\kappa ( \boldsymbol { x } ) = 0$ , we have the weaker result
+
+$$
+\begin{array} { r } { B ( x ) = \left\{ \begin{array} { l l } { O \left( n ^ { - \frac { 2 \alpha _ { x } } { d } } ( \ln ( n ) ) ^ { - 1 - \frac { 2 \alpha _ { x } } { d } } \right) , } & { f o r \ d > 2 \alpha _ { x } } \\ { O \left( n ^ { - 1 } ( \ln ( n ) ) ^ { - 1 } \right) , } & { f o r \ d = 2 \alpha _ { x } } \\ { O \left( n ^ { - 1 } ( \ln ( n ) ) ^ { - 2 } \right) , } & { f o r \ d < 2 \alpha _ { x } } \end{array} \right. } \end{array}
+$$
+
+260 Note that $\kappa ( \boldsymbol { x } ) = 0$ is non generic but can still happen, even if $f$ is not constant. For instance, if $\Omega$ is a   
+261 sphere centered at $x$ or $\Omega = \mathbb { R } ^ { d }$ , if $\rho ( x + y ) = \hat { \rho } ( | | y | | )$ is isotropic around $x$ , and if $f _ { x } : y \mapsto f ( x + y )$   
+262 is an odd function of $y$ , then we indeed have $\kappa ( \boldsymbol { x } ) = 0$ at this symmetric point $x$ .
+
+Interestingly, for $\kappa ( \boldsymbol { x } ) \neq 0$ , Eq. (23) shows that the bias $B ( x )$ is asymptotically dominated by the square of $\mathbb { E } \left[ { \hat { f } } ( x ) \right] - f ( x )$ , showing that the fluctuations of $\begin{array} { r } { \mathbb { E } \left[ \hat { f } ( x ) \right] - \sum _ { i = 0 } ^ { n } w _ { i } ( x ) f ( x _ { i } ) } \end{array}$ are negligible compared to $\mathbb { E } \left[ { \hat { f } } ( x ) \right] - f ( x )$ , in the limit $n  + \infty$ and for $\kappa ( x ) \neq 0$ .
+
+One can relax the local Hölder condition, but at the price of a weaker estimate for $B ( x )$ which will however be enough to obtain strong results for the regression and classification risks (see below):
+
+Theorem 3.6. For $x \in \Omega ^ { \circ }$ , we assume $\rho$ and $f$ continuous at $x$ , and the growth condition $C _ { \mathrm { G r o w t h } } ^ { f }$ $\begin{array} { r } { \int \rho ( y ) \frac { f ^ { 2 } ( y ) } { 1 + \| y \| ^ { 2 d } } d ^ { d } y < \infty . } \end{array}$ . Then, the bias term satisfies
+
+$$
+{ \cal B } ( x ) = o \left( \frac { 1 } { \ln ( n ) } \right) ,
+$$
+
+270 or equivalently, for any $\varepsilon > 0$ , there exists $N _ { x , \varepsilon }$ , such that for $n \geq N _ { x , \varepsilon }$
+
+$$
+B ( x ) \leq { \frac { \varepsilon } { \ln ( n ) } } .
+$$
+
+271 Let us now consider a point $x \in \partial \Omega$ for which we have $\rho ( { \boldsymbol { x } } ) = 0$ (note that $x \in \partial \Omega$ does not 272 necessarily imply $\rho ( x ) = 0 ,$ ). In appendix A.5, we show the following theorem for the expectation value of the estimator 273 ${ \hat { f } } ( x )$ in the limit $n \to + \infty$ :
+
+274 Theorem 3.7. For $x \in \partial \Omega$ such that $\rho ( x ) = 0$ , we assume that $f$ and $\rho$ satisfy the conditions
+
+$\begin{array} { r } { \bullet \ C _ { \mathrm { G r o w t h } } ^ { f } \cdot \int \rho ( y ) \frac { | f ( y ) | } { 1 + \| y \| ^ { d } } \ d ^ { d } y < \infty , } \end{array}$   
+• $C _ { \mathrm { H o l d e r } } ^ { \rho }$ : thand $\alpha _ { x } > 0$ $K _ { x } > 0$ $\delta _ { x } > 0$   
+$x ^ { \prime } \in \Omega$ $\| x - x ^ { \prime } \| \leq \delta _ { x } \implies | \rho ( x ^ { \prime } ) | \leq K _ { x } \| x - x ^ { \prime } \| ^ { \alpha _ { x } }$ (local Hölder condition for $\rho$ ).
+
+Mor279 and 280 $\begin{array} { r } { \kappa ( x ) = \int \rho ( x + y ) \frac { f ( x + y ) - f ( x ) } { | | y | | ^ { d } } d ^ { d } y ( | \kappa ( x ) | < \infty  } \end{array}$ under condition en, $C _ { \mathrm { G r o w t h } } ^ { f } )$ $\begin{array} { r } { \lambda ( x ) = \int \frac { \rho ( x + y ) } { | | y | | ^ { d } } d ^ { d } y } \end{array}$ $( 0 < \lambda ( x ) < \infty$ $C _ { \mathrm { H o l d e r } } ^ { \sigma }$
+
+$$
+\operatorname* { l i m } _ { n  + \infty } \mathbb { E } [ \hat { f } ( x ) ] - f ( x ) = \frac { \kappa ( x ) } { \lambda ( x ) } .
+$$
+
+281 Hence, in the generic case $\kappa ( \boldsymbol { x } ) \neq 0$ (see Theorem 3.5 and the discussion below it) and under   
+282 condition $C _ { \mathrm { H o l d e r } } ^ { \rho }$ , we find that the bias does not vanish when $\rho ( x ) = 0$ , and that the estimator $\hat { f } ( x )$   
+283 does not converge to $f ( x )$ . When $\rho ( x ) = 0$ , the scarcity of data near the point $x$ indeed prevents the   
+284 285 $\rho$ stimator to concontinuous at $x$ rge to the actuand such that $\rho ( x ) = 0$ f , $f ( x )$ . In appendix A.5, we shownot satisfying the condition $C _ { \mathrm { H o l d e r } } ^ { \rho }$ ple of a density, and for which   
+286 $\begin{array} { r } { \operatorname* { l i m } _ { n  + \infty } \mathbb { E } [ \hat { f } ( x ) ] = f ( x ) } \end{array}$ , even if $\kappa ( x ) \neq 0$ .
+
+# 3.2 Asymptotic equivalent for the regression risk
+
+In appendix A.6, we prove the following theorem establishing the asymptotic rate at which the excess risk goes to zero with large sample size $n$ for Hilbert kernel regression, under mild conditions that do not require $f$ or $\sigma$ to be bounded, but only to satisfy some growth conditions:
+
+Theorem 3.8. For $x \in \Omega ^ { \circ }$ , we assume $\sigma ( x ) > 0$ , ρ, σ, and $f$ continuous at $x$ , and the growth conditions $\begin{array} { r } { C _ { \mathrm { G r o w t h } } ^ { \sigma } \colon \int \rho ( y ) \frac { \sigma ^ { 2 } ( y ) } { 1 + \| y \| ^ { 2 d } } d ^ { d } y < \infty } \end{array}$ and $\begin{array} { r } { C _ { \mathrm { G r o w t h } } ^ { f } \colon \int \rho ( y ) \frac { f ^ { 2 } ( y ) } { 1 + \| y \| ^ { 2 d } } d ^ { d } y < \infty } \end{array}$ .
+
+93 Then the following statements are true:
+
+• The excess regression risk at the point $x$ satisfies
+
+$$
+\mathbb { E } [ ( \hat { f } ( x ) - f ( x ) ) ^ { 2 } ] \underset { n  + \infty } { \sim } \frac { \sigma ^ { 2 } ( x ) } { \ln ( n ) } .
+$$
+
+• The Hilbert kernel estimate converges pointwise to the regression function in probability. More specifically, for any $\delta > 0$ , there exists a constant $N _ { x , \delta }$ , such that for any $\varepsilon > 0$ , we have the following Chebyshev bound, valid for $n \geq N _ { x , \delta }$
+
+$$
+\mathbb { P } [ | \hat { f } ( x ) - f ( x ) | \geq \varepsilon ] \leq \frac { 1 + \delta } { \varepsilon ^ { 2 } } \frac { \sigma ^ { 2 } ( x ) } { \ln ( n ) } .
+$$
+
+8 This theorem is a consequence of the corresponding asymptotically equivalent forms of the variance   
+9 and bias terms presented above. Note that as long as $\rho ( x ) > 0$ , the variance term dominates over the   
+00 bias term and the regression risk has the same form as the variance term.
+
+# 3.3 Rates for the plugin classifier
+
+In appendix A.7, we prove the following theorem establishing the asymptotic rate at which the classification risk goes to zero with large sample size $n$ for Hilbert kernel regression:
+
+Theorem 3.9. For $x \in \Omega ^ { \circ }$ , we assume $\sigma ( x ) > 0$ , $\rho , \sigma$ , and $f$ continuous at $x$ . Then, the classification risk $\mathbb { E } [ \mathcal { R } _ { 0 / 1 } ( \hat { F } ( x ) ) ] - \mathcal { R } _ { 0 / 1 } ( F ( x ) )$ vanishes for $n  + \infty$ .
+
+306 More precisely, for any $\varepsilon > 0$ , there exists $N _ { x , \varepsilon }$ , such that for any $n \geq N _ { x , \varepsilon }$ ,
+
+$$
+0 \leq \mathbb { E } [ \mathcal { R } _ { 0 / 1 } ( \hat { F } ( x ) ) ] - \mathcal { R } _ { 0 / 1 } ( F ( x ) ) \leq 2 ( 1 + \varepsilon ) \frac { \sigma ( x ) } { \sqrt { \ln ( n ) } } ,
+$$
+
+307 In addition, for any $0 < \alpha < 1$ , the general inequality
+
+$$
+\begin{array} { r } { \mathbb { E } [ \mathcal { R } _ { 0 / 1 } ( \hat { F } ( x ) ) ] - \mathcal { R } _ { 0 / 1 } ( F ( x ) ) \leq 2 | f ( x ) - 1 / 2 | ^ { 1 - \alpha } \mathbb { E } \left[ | \hat { f } ( x ) - f ( x ) | ^ { 2 } \right] ^ { \frac { \alpha } { 2 } } , } \end{array}
+$$
+
+308 holds unconditionally and, for $n \geq N _ { x , \varepsilon }$ , leads to
+
+$$
+0 \leq \mathbb { E } [ \mathcal { R } _ { 0 / 1 } ( \hat { F } ( x ) ) ] - \mathcal { R } _ { 0 / 1 } ( F ( x ) ) \leq 2 | f ( x ) - 1 / 2 | ^ { 1 - \alpha } \left( 1 + \varepsilon \right) ^ { \alpha } \frac { \sigma ^ { \alpha } ( x ) } { \left( \ln ( n ) \right) ^ { \frac { \alpha } { 2 } } } .
+$$
+
+309 For $0 < \alpha < 1$ , Eq. (32) is weaker than Eq. (30) in terms of its dependence on $n$ , but explicitly   
+310 shows that the classification risk vanishes for $f ( x ) = 1 / 2$ . This theorem does not require any growth   
+311 condition for $f$ or $\sigma$ , since both functions takes values in $[ 0 , 1 ]$ in the classification context.
+
+# 3.4 Extrapolation behavior outside the support of $\rho$
+
+We now take the point $x$ outside the closed support $\bar { \Omega }$ of the distribution $\rho$ (which excludes the case $\Omega = \mathbb { R } ^ { d }$ ). We are interested in the behavior of $\mathbb { E } \left[ \hat { f } ( x ) \right]$ as $n  + \infty$ . In appendix A.8 we prove:
+
+Theorem 3.10. For 315 $x \notin \bar { \Omega }$ , we assume the growth condition $\begin{array} { r } { \int \rho ( y ) \frac { | f ( y ) | } { 1 + \| y \| ^ { d } } d ^ { d } y < \infty } \end{array}$
+
+$$
+\hat { f } _ { \infty } ( x ) : = \operatorname* { l i m } _ { n \to + \infty } \mathbb { E } \left[ \hat { f } ( x ) \right] = \frac { \int \rho ( y ) f ( y ) \| x - y \| ^ { - d } d ^ { d } y } { \int \rho ( y ) \| x - y \| ^ { - d } d ^ { d } y } ,
+$$
+
+and 316 $\hat { f } _ { \infty }$ is continuous at all $x \notin \bar { \Omega }$ .
+
+In addition, i317 $\begin{array} { r } { f \int \rho ( y ) | f ( y ) | d ^ { d } y < \infty } \end{array}$ , and defining $d ( x , \Omega ) > 0$ as the distance between $x$ and $\Omega$ , we 318 have
+
+$$
+\operatorname* { l i m } _ { d ( x , \Omega ) \to + \infty } \hat { f } _ { \infty } ( x ) = \int \rho ( y ) f ( y ) d ^ { d } y .
+$$
+
+319 Finally, we consider $x _ { 0 } ~ \in ~ \partial \Omega$ such that $\rho ( x _ { 0 } ) ~ > ~ 0$ (i.e., $x _ { 0 } ~ \in ~ \partial \Omega \cap \Omega \}$ , and assume   
+320 that $f$ and $\rho$ seen as functions restricted to $\Omega$ are continuous at $x _ { 0 }$ , i.e. $\quad \operatorname* { l i m } _ { y \in \Omega \to x _ { 0 } } \rho ( y ) \ =$   
+321 $\rho ( x _ { 0 } )$ and $\begin{array} { l } { \operatorname* { l i m } _ { y \in \Omega \to x _ { 0 } } { \overline { { f ( y ) } } } } & { = } \end{array} f ( x _ { 0 } )$ . We also assume that the local solid angle $\begin{array} { r l } { \omega _ { 0 } } & { { } = } \end{array}$   
+322 $\begin{array} { r } { \operatorname* { l i m } _ { r \to 0 } \frac { 1 } { V _ { d } \rho ( x _ { 0 } ) r ^ { d } } \int _ { \| x _ { 0 } - y \| \leq r } \rho ( y ) d ^ { d } y } \end{array}$ exists and satisfies $\omega _ { 0 } > 0$ . Then,
+
+$$
+\operatorname * { l i m } _ { x \notin \bar { \Omega }  x _ { 0 } } \hat { f } _ { \infty } ( x ) = f ( x _ { 0 } ) .
+$$
+
+323 Eq. (34) shows that far away from $\Omega$ (which is possible to realize, for instance, when $\Omega$ is bounded),   
+324 $\hat { f } _ { \infty } ( x )$ goes smoothly to the $\rho$ -mean of $f$ . Moreover, Eq. (35) establishes a continuity property for   
+325 the extrapolation $\hat { f } _ { \infty }$ at $x _ { 0 } \in \partial \Omega \cap \Omega$ under the stated conditions (remember that for $x \in \Omega ^ { \circ }$ , we   
+326 have $\begin{array} { r } { \operatorname* { l i m } _ { n  + \infty } \mathbb { E } [ \hat { f } ( x ) ] = f ( x ) } \end{array}$ ; see Theorem 3.5, and in particular Eq. (23)).
+
+References [1] Holger Wendland. Scattered data approximation, volume 17. Cambridge university press, 2004. [2] Gareth James, Daniela Witten, Trevor Hastie, and Robert Tibshirani. An introduction to statistical learning, volume 112. Springer, 2013. [3] Chiyuan Zhang, Samy Bengio, Moritz Hardt, Benjamin Recht, and Oriol Vinyals. Understanding deep learning requires rethinking generalization. In International Conference on Learning Representations, 2017. [4] Mikhail Belkin, Siyuan Ma, and Soumik Mandal. To understand deep learning we need to understand kernel learning. In Proceedings of the 35th International Conference on Machine Learning, pages 541–549, 2018. [5] Adele Cutler and Guohua Zhao. Pert-perfect random tree ensembles. Computing Science and Statistics, 33:490–497, 2001. [6] Abraham J Wyner, Matthew Olson, Justin Bleich, and David Mease. Explaining the success of adaboost and random forests as interpolating classifiers. Journal of Machine Learning Research, 18(48):1–33, 2017. [7] Mikhail Belkin, Daniel Hsu, and Partha Mitra. Overfitting or perfect fitting? risk bounds for classification and regression rules that interpolate. arXiv preprint arXiv:1806.05161, 2018. [8] Alexander Rakhlin and Xiyu Zhai. Consistency of interpolation with laplace kernels is a high-dimensional phenomenon. arXiv preprint arXiv:1812.11167, 2018. [9] Greg Ongie, Rebecca Willett, Daniel Soudry, and Nathan Srebro. A function space view of bounded norm infinite width relu nets: The multivariate case. arXiv preprint arXiv:1910.01635, 2019. [10] Mikhail Belkin, Daniel Hsu, Siyuan Ma, and Soumik Mandal. Reconciling modern machinelearning practice and the classical bias–variance trade-off. Proceedings of the National Academy of Sciences, 116(32):15849–15854, 2019. [11] Tengyuan Liang and Alexander Rakhlin. Just interpolate: Kernel" ridgeless" regression can generalize. arXiv preprint arXiv:1808.00387, 2018. 354 [12] Peter L Bartlett, Philip M Long, Gábor Lugosi, and Alexander Tsigler. Benign overfitting in linear regression. arXiv preprint arXiv:1906.11300, 2019. 356 [13] Andrea Montanari, Feng Ruan, Youngtak Sohn, and Jun Yan. The generalization error of max-margin linear classifiers: High-dimensional asymptotics in the overparametrized regime. arXiv preprint arXiv:1911.01544, 2019. 359 [14] Mina Karzand and Robert D Nowak. Active learning in the overparameterized and interpolating regime. arXiv preprint arXiv:1905.12782, 2019. [15] Yue Xing, Qifan Song, and Guang Cheng. Statistical optimality of interpolated nearest neighbor algorithms. arXiv preprint arXiv:1810.02814, 2018. 363 [16] Partha P. Mitra. Fitting elephants in modern machine learning by statistically consistent interpolation. Nature Machine Intelligence, 3(5):378–386, May 2021. [17] Martin Anthony and Peter L Bartlett. Neural Network Learning: Theoretical Foundations. Cambridge University Press, 1999. [18] Luc Devroye, Laszlo Györfi, and Adam Krzyzak. The hilbert kernel regression estimate. ˙ Journal of Multivariate Analysis, 65(2):209–227, 1998. [19] Elizbar A Nadaraya. On estimating regression. Theory of Probability & Its Applications, 9(1):141–142, 1964. 371 [20] GS Watson. Smooth regression analysis. Sankhya A: 26: 359-372, (50), 1964.
+
+[21] Donald Shepard. A two-dimensional interpolation function for irregularly-spaced data. In Proceedings of the 1968 23rd ACM national conference, pages 517–524. ACM, 1968.
+
+[22] Reinhard Farwig. Rate of convergence of shepard’s global interpolation formula. Mathematics of Computation, 46(174):577–590, 1986.
+
+# 376 Checklist
+
+1. For all authors...
+
+(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes] Brief statement of the primary theorems are included in the abstract together with verbal descriptions of the principal results.   
+(b) Did you describe the limitations of your work? [Yes] Theorems include limiting conditions.   
+(c) Did you discuss any potential negative societal impacts of your work? [No] The paper consists of theorems and proofs about the convergence rates of an interpolation scheme and it is hard to conceive any negative social impact of this mathematical exercise. If anything it might have a positive impact by shedding theoretical light on the interpolation of noisy data in modern ML.   
+(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] We have read the guidelines.
+
+2. If you are including theoretical results...
+
+(a) Did you state the full set of assumptions of all theoretical results? [Yes] We state the conditions for the theorems proven.   
+(b) Did you include complete proofs of all theoretical results? [Yes] Proofs of all theorems are provided in the appendix. The relevant appendix section is noted in the corresponding sections containing the theorems.
+
+3. If you ran experiments...
+
+(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [N/A] The paper is directed to proving a number of theorems.   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [N/A] We do not rely on numerical experiments for the results presented in the paper.   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [N/A]   
+(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [N/A]
+
+06 4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...
+
+(a) If your work uses existing assets, did you cite the creators? [N/A]   
+(b) Did you mention the license of the assets? [N/A]   
+(c) Did you include any new assets either in the supplemental material or as a URL? [N/A]   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A]
+
+5. If you used crowdsourcing or conducted research with human subjects...
+
+(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A] There are no human subjects.   
+(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   
+(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A]

parse/train/jtrQswOMLrd/jtrQswOMLrd_content_list.json

@@ -0,0 +1,1628 @@
+[
+    {
+        "type": "text",
+        "text": "Parameter-free Statistically Consistent Interpolation: Dimension-independent Convergence Rates for Hilbert kernel regression ",
+        "text_level": 1,
+        "bbox": [
+            179,
+            122,
+            821,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous Author(s)   \nAffiliation   \nAddress   \nemail ",
+        "bbox": [
+            423,
+            251,
+            578,
+            306
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            343,
+            535,
+            359
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Previously, statistical textbook wisdom has held that interpolation of noisy training data will lead to poor generalization. However, recent work has shown that this is not true and that good generalization can be obtained with function fits that interpolate training data. This could explain why overparameterized deep nets with zero or small training error do not necessarily overfit and could generalize well. Data interpolation schemes have been exhibited that are provably Bayes optimal in the large sample limit and achieve the theoretical lower bounds for excess risk (Statistically Consistent Interpolation) in any dimension. These interpolation schemes are non-parametric Nadaraya-Watson style estimators with singular kernels, which exhibit statistical consistency in any data dimension for large sample sizes. The recently proposed weighted interpolating nearest neighbors scheme (wiNN) is in this class, as is the previously studied Hilbert kernel interpolation scheme. In the Hilbert scheme, the regression function estimator for a set of labelled data pairs, $( x _ { i } , y _ { i } ) \\in \\mathbb { R } ^ { d } \\times \\mathbb { R }$ , $i = 0 , . . . , n$ , has the form $\\begin{array} { r } { \\hat { f } ( x ) = \\sum _ { i } y _ { i } w _ { i } ( x ) } \\end{array}$ , where $\\begin{array} { r } { w _ { i } ( x ) = \\| x - x _ { i } \\| ^ { - d } / \\sum _ { j } \\| x - x _ { j } \\| ^ { - d } } \\end{array}$ . This interpolating function estimator is unique in being entirely free of parameters and does not require bandwidth selection. While statistical consistency was previously proven for this scheme, the precise convergence rates for the finite sample risk were not established. Here, we carry out a comprehensive study of the asymptotic finite sample behavior of the Hilbert kernel regression scheme and prove a number of relevant theorems. We prove under broad conditions that the excess risk of the Hilbert regression estimator is asymptotically equivalent pointwise to $\\sigma ^ { 2 } ( x ) / \\ln ( n )$ where $\\scriptstyle { \\bar { \\sigma } } ^ { 2 } ( x )$ is the noise variance. We also show that the excess risk of the plugin classifier is upper bounded by $2 | f ( x ) - 1 / 2 | ^ { 1 - \\alpha } ( 1 + \\varepsilon ) ^ { \\alpha } \\sigma ^ { \\alpha } ( x ) ( \\ln ( n ) ) ^ { - { \\frac { \\alpha } { 2 } } }$ , for any $0 < \\alpha < 1$ , where $f$ is the regression function $x \\mapsto \\mathbb { E } [ y | x ]$ . Our proofs proceed by deriving asymptotic equivalents of the moments of the weight functions $w _ { i } ( x )$ for large $n$ , for instance for $\\beta > 1$ , $\\mathbb { E } [ w _ { i } ^ { \\beta } ( x ) ] \\sim _ { n  \\infty }$ ((β − 1)n ln(n))−1. We further derive an asymptotic equivalent for the Lagrange function and explicitly exhibit the nontrivial extrapolation properties of this estimator. Notably, the convergence rates are independent of data dimension and the excess risk is dominated by the noise variance. The bias term, for which we also give precise asymptotic estimates, is always subleading when the density of data at the considered point is strictly positive. If this local density is zero, we show that the bias term does not vanish in the limit of a large data set and we compute its limit explicitly. Finally, we present heuristic arguments for a universal $w ^ { - 2 }$ power-law behavior of the probability density of the weights in the large $n$ limit. ",
+        "bbox": [
+            217,
+            376,
+            766,
+            886
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "38 Data interpolation and statistical regression of noisy data are both classical subjects but their domain   \n39 of application have been disjoint until recently. Scattered data interpolation techniques [1] are   \n40 generally used for clean data. On the other hand, when supervised learning or statistical regression   \n41 techniques are applied to noisy data, in general smoothing or regularization methods are applied   \n42 to prevent training data interpolation, as the latter is believed to lead to poor generalization [2].   \n43 However, accumulating empirical evidence from overparameterized deep networks has shown that   \n44 data interpolation (equivalently, zero error on the training set) does not automatically imply poor   \n45 generalization [3, 4]. This has in turn given rise to a rapidly growing body of theoretical work to   \n46 understand how and why noisy data interpolation can still lead to good generalization [5, 6, 7, 8, 9,   \n47 10, 11, 12, 13, 14, 15].   \n48 A key observations in this regard is the phenomenon of Statistically Consistent Interpolation [16],   \n49 i.e., regression function estimation that interpolates training data but also generalizes as well as   \n50 possible by achieving the Bayes limit for expected generalization error (risk) when the sample size   \n51 becomes large. This hints at a rich set of theoretical questions at the interface between the disciplines   \n52 of scattered data interpolation and supervised learning, that have only begun to be addressed. In   \n53 particular, there has been comparatively little study of the generalization error or risk of interpolating   \n54 learners. Computation of generalization error bounds in machine learning often relies on the capacity   \n55 of the class of fitting functions [17], however such model complexity based bounds are not tight   \n56 enough to be useful for interpolating learners [4]. For nonparametric interpolation approaches such as   \n57 that considered here, it is also not clear what model complexity means. Thus, there is a need for other   \n58 approaches to understanding the generalization behavior of nonparametric interpolating learners,   \n59 including more direct treatments of the generalization error for specific interpolation schemes so as   \n60 to gain better theoretical understanding. The current paper addresses this need.   \n61 We present a detailed analysis of the finite-sample risk of an interpolating learner with intriguing   \n62 theoretical properties, the Hilbert kernel estimator (Devroye et. al. [18]). A unique property of   \n63 this Nadaraya-Watson (NW) style estimator [19, 20] is that it is fully parameter-free and does not   \n64 have any bandwidth or scale parameter. It is global and uses all data points for each estimate: the   \n65 associated kernel is a power law and thus scale-free. Although statistical consistency of this estimator   \n66 was proven [18] when it was proposed, there has been no systematic analysis of the associated   \n67 convergence rates and asymptotic finite sample behavior. We provide this analysis in the present   \n68 study.   \n69 Related work The only other interpolation scheme we are aware of, that is proven to be statistically   \n70 consistent in arbitrary dimensions under general conditions, is the recently proposed weighted   \n71 interpolating nearest neighbors method (wiNN) [7], which is also a NW estimator utilizing a singular   \n72 power law kernel of a very similar form but with two important differences: a finite number of   \n73 neighbors $k$ is utilized (rather than all data points), and the power law exponent $\\delta$ of the NW kernel   \n74 satisfies $0 < \\delta < d / 2$ rather than $\\delta = d$ . To achieve consistency $k$ has to scale appropriately with   \n75 sample size. Despite the superficial resemblance, the wiNN and Hilbert Kernel estimators have quite   \n76 different convergence rates, as we will see from the results of this paper. Also worth mentioning is the   \n77 Shepard interpolation scheme [21] originally proposed for interpolation of 2D geospatial data sets,   \n78 also a NW style interpolating estimator, though used in the context of scattered data interpolation.   \n79 In scattered data interpolation [1], the focus is generally on the approximation error (corresponding   \n80 to the “bias” term in our analysis below). The approximation error of the Shepard scheme has been   \n81 analyzed [22] but as we will see below the risk for Hilbert kernel interpolation is dominated by the   \n82 noise or “variance” term. In contrast with wiNN or Hilbert kernel interpolation, other interpolating   \n83 learning methods such as simplex interpolation [7] or ridgeless kernel regression [11] are generally   \n84 not statistically consistent in fixed finite dimension [8].   \n85 Summary of results of this paper Notation and assumptions pertaining to this summary are defined   \n86 in the problem setup section below. We prove under broad conditions that the excess risk of the   \n87 Hilbert regression estimator is asymptotically equivalent pointwise to $\\sigma ^ { 2 } ( x ) / \\ln ( n )$ where $\\sigma ^ { 2 } ( x )$ is   \n88 the noise variance. We also show that the excess risk of the plugin classifier is upper bounded by   \n89 $2 | f ( x ) - 1 / 2 | ^ { 1 - \\alpha } ( 1 + \\varepsilon ) ^ { \\alpha } \\sigma ^ { \\alpha } ( x ) ( \\ln ( n ) ) ^ { - { \\frac { \\alpha } { 2 } } }$ , for any $0 < \\alpha < 1$ , where $f$ is the regression function   \n90 $x \\mapsto \\mathbb { E } [ y | x ]$ . Our proofs proceed by deriving asymptotic equivalents of the moments of the weight   \n91 functions $w _ { i } ( x )$ for large $n$ , for instance for $\\beta > 1$ $> 1 , \\mathbb { E } [ w _ { i } ^ { \\beta } ( x ) ] \\sim _ { n  \\infty } ( ( \\beta - 1 ) n \\ln ( n ) ) ^ { - 1 }$ . We   \n92 further derive an asymptotic equivalent for the Lagrange function and explicitly exhibit the nontrivial   \n93 extrapolation properties of this estimator. Notably, the convergence rates are independent of data   \n94 dimension and the excess risk is dominated by the noise variance. The bias term, for which we also   \n95 give precise asymptotic estimates, is always subleading when the density of data at the considered   \n96 point is strictly positive. If this local density is zero, we show that the bias term does not vanish in the   \n97 limit of a large data set and we compute its limit explicitly. Finally, we present heuristic arguments   \n98 for a universal $w ^ { - 2 }$ power-law behavior of the probability density of the weights in the large $n$ limit. ",
+        "bbox": [
+            145,
+            122,
+            825,
+            261
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            267,
+            825,
+            446
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            453,
+            825,
+            564
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            570,
+            825,
+            791
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            797,
+            825,
+            912
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            90,
+            825,
+            175
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "99 2 Problem setup ",
+        "text_level": 1,
+        "bbox": [
+            147,
+            200,
+            326,
+            218
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "100 Notation, Definitions, Statistical Model We model the labelled training data set   \n101 $( x _ { 0 } , y _ { 0 } ) , \\ldots , ( x _ { n } , y _ { n } )$ as $n + 1$ i.i.d. observations of a random vector $( X , Y )$ with values in   \n102 $\\mathbb { R } ^ { d } \\times \\mathbb { R }$ for regression, and with values in $\\mathbb { R } ^ { d } \\times \\{ 0 , 1 \\}$ for binary classification. Due to the indepen  \n103 dence property, the collection $X _ { 0 } , \\ldots , X _ { n }$ has the product density $\\textstyle \\prod _ { i = 0 } ^ { n } \\rho ( x _ { i } )$ . We will denote by $\\mathbb { E }$   \n104 an expectation over the collection of $n + 1$ random vectors and by $\\mathbb { E } _ { X }$ the expectation over the col  \n105 lection $X _ { 0 } , \\ldots , X _ { n }$ . An expectation over the same collection while holding $X _ { i } = x _ { i }$ will be denoted   \n106 $\\mathbb { E } _ { X \\mid x _ { i } }$ . The regression function $f \\colon  { \\mathbb { R } ^ { d } } \\to  { \\mathbb { R } }$ is defined as the conditional mean of $Y$ given $X = x$   \n107 $f ( x ) : = \\mathbb { E } [ Y \\mid X = x ]$ and the conditional variance function is $\\sigma ^ { 2 } ( x ) : = \\mathbb { E } [ | Y - f ( X ) | ^ { 2 } | X = x ]$ .   \n108 $f$ minimizes the expected value of the mean squared prediction error (risk under squared loss),   \n109 $f = \\arg \\operatorname* { m i n } \\mathcal { R } _ { \\mathrm { s q } } ( h )$ where $\\mathcal { R } _ { \\mathrm { s q } } ( h ) : = \\mathbb { E } [ ( h ( X ) - Y ) ^ { 2 } ]$ . Given any regression estimator ${ \\hat { f } } ( x )$ the   \n110 corresponding risk can be decomposed as $\\mathbb { E } [ \\mathcal { R } _ { \\mathrm { s q } } ( \\hat { f } ( X ) ) ] = \\mathcal { R } _ { \\mathrm { s q } } ( f ) + \\mathbb { E } [ ( \\hat { f } ( X ) - f ( X ) ^ { 2 } ]$ . The   \n111 excess risk is given by $\\mathcal { R } _ { \\mathrm { s q } } ( \\hat { f } ) - \\mathcal { R } _ { \\mathrm { s q } } ( f ) = \\mathbb { E } [ ( \\hat { f } ( X ) - f ( X ) ) ^ { 2 } ]$ . For a consistent estimator this   \n112 excess risk goes to zero as $n \\to \\infty$ and we are interested in characterizing the rate at which it goes to   \n113 zero with increasing $n$ (note our sample size is $n + 1$ for notational simplicity but for large $n$ this   \n114 does not change the rate).   \n115 In the case of binary classification, $Y \\in \\{ 0 , 1 \\}$ and $f ( x ) = \\mathbb { P } [ Y = 1 \\mid X = x ) ]$ . Let $F \\colon  { \\mathbb { R } } ^ { d } \\to \\{ 0 , 1 \\}$   \n116 denote the Bayes optimal classifier, defined by $F ( x ) : = \\theta ( f ( x ) - 1 / 2 )$ where $\\theta ( \\cdot )$ is the Heaviside   \n117 theta function. This classifier minimizes the risk $\\mathscr { R } _ { 0 / 1 } ( h ) : = \\mathbb { E } \\big [ \\mathbb { 1 } _ { \\{ h ( X ) \\neq Y \\} } \\big ] = \\mathbb { P } ( h ( X ) \\neq Y )$ under   \n118 zero-one loss. Given the regression estimator $\\hat { f }$ , we consider the plugin classifier ${ \\hat { F } } ( x ) = \\theta ( { \\hat { f } } ( x ) - { \\textstyle \\frac { 1 } { 2 } } )$   \n119 The classification risk for the plugin classifier $\\hat { F }$ is bounded as $\\begin{array} { r } { \\mathbb { E } [ \\mathcal { R } _ { 0 / 1 } ( \\hat { F } ( x ) ) ] - \\mathcal { R } _ { 0 / 1 } ( F ( x ) ) \\leq } \\end{array}$   \n120 $2 \\mathbb { E } [ | \\hat { f } ( x ) - f ( x ) | ] \\leq 2 \\sqrt { \\mathbb { E } [ ( \\hat { f } ( x ) - f ( x ) ) ^ { 2 } ] } .$ . ",
+        "bbox": [
+            138,
+            236,
+            826,
+            457
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            460,
+            825,
+            565
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Finally, we define two sequences $a _ { n } , b _ { n } > 0$ , $n \\in \\mathbb { N }$ , to be asymptotically equivalent for $n  + \\infty$ denoted $a _ { n } \\sim _ { n \\to + \\infty } b _ { n }$ , if the limit of their ratio exists and $\\scriptstyle \\operatorname* { l i m } _ { n \\to \\infty } a _ { n } / b _ { n } = 1$ . ",
+        "bbox": [
+            165,
+            570,
+            823,
+            601
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "123 In summary, our work will focus on the estimation of asymptotic equivalents for $\\mathbb { E } [ ( \\hat { f } ( x ) - f ( x ) ) ^ { 2 } ]$   \n124 and other relevant quantities as this determines the rate at which the excess risk goes to zero for   \n125 regression, and bounds the rate at which the excess risk goes to zero for classification.   \n126 Assumptions. We define the support $\\Omega$ of the density $\\rho$ as $\\Omega = \\{ x \\in \\mathbb { R } ^ { d } / \\rho ( x ) > 0 \\}$ , the closed   \n127 support $\\bar { \\Omega }$ as the closure of $\\Omega$ , and $\\Omega ^ { \\circ }$ as the interior of $\\Omega$ . Our results will not assume any compactness   \n128 condition on $\\Omega$ or $\\bar { \\Omega }$ . The boundary of $\\Omega$ is then defined as $\\partial \\Omega = \\bar { \\Omega } \\setminus \\Omega ^ { \\circ }$ . We assume that $\\rho$ has a   \n129 finite variance $\\sigma _ { \\rho } ^ { 2 }$ . In addition, we will most of the time assume that the density $\\rho$ is continuous at the   \n130 considered point $x \\in \\Omega ^ { \\circ }$ , and in some cases, $x \\in \\partial \\Omega \\cap \\Omega$ . ",
+        "bbox": [
+            142,
+            607,
+            826,
+            650
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            655,
+            825,
+            726
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "131 For the regression function $f$ , we will obtain results assuming either of the following conditions ",
+        "bbox": [
+            147,
+            731,
+            802,
+            747
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "$C _ { \\mathrm { C o n t } } ^ { f } \\colon f$ is continuous at the considered $x$ ,   \n• $C _ { \\mathrm { H o l d e r } } ^ { f }$ : fo $x \\in \\Omega ^ { \\circ }$ $\\alpha _ { x } > 0$ $K _ { x } > 0$ $\\delta _ { x } > 0$ , such thatαx   \n$x ^ { \\prime } \\in \\Omega$ $\\begin{array} { r } { \\| \\boldsymbol { x } - \\boldsymbol { x } ^ { \\prime } \\| \\le \\delta _ { x } \\implies | f ( \\boldsymbol { x } ) - f ( \\boldsymbol { x } ^ { \\prime } ) | \\le K _ { x } \\| \\boldsymbol { x } - \\boldsymbol { \\mathrm { \\widehat { x } } } } \\end{array}$   \n(local Hölder smoothness condition), ",
+        "bbox": [
+            217,
+            760,
+            725,
+            834
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "36 where condition $C _ { \\mathrm { H o l d e r } } ^ { f }$ r is obviously stronger than CfCont . In addition, we will always assume a   \n37 growth condition for the regression function $f$ : ",
+        "bbox": [
+            151,
+            847,
+            828,
+            878
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f45b50f10a66e236f87de25ce1d91a32e05b5a63ff7eb9395e95bb996d3bacf0.jpg",
+        "text": "$$\n\\begin{array} { r } { \\bullet C _ { \\mathrm { G r o w t h } } ^ { f } \\colon \\int \\rho ( y ) \\frac { f ^ { 2 } ( y ) } { 1 + \\| y \\| ^ { 2 d } } d ^ { d } y < \\infty . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            215,
+            891,
+            465,
+            916
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "139 As for the variance function $\\sigma$ , we will obtain results assuming either that $\\sigma$ is bounded or satisfies a   \n140 growth condition similar to the one above ",
+        "bbox": [
+            143,
+            90,
+            825,
+            119
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/715a2315108b0dd488c03e9c3d7c98941769d24313a62a5a0e3d0054db1595b0.jpg",
+        "text": "$$\n\\begin{array} { r } { \\bullet C _ { \\mathrm { G r o w t h } } ^ { \\sigma } \\colon \\int \\rho ( y ) \\frac { \\sigma ^ { 2 } ( y ) } { 1 + \\| y \\| ^ { 2 d } } d ^ { d } y < \\infty . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            217,
+            148,
+            465,
+            174
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "When we will assume condition 143 $C _ { \\mathrm { G r o w t h } } ^ { \\sigma }$ (obviously satisfied when $\\sigma ^ { 2 }$ is bounded), we will also assume a continuity condition 144 $C _ { \\mathrm { { C o n t } } } ^ { \\sigma }$ for $\\sigma$ at the considered $x$ . ",
+        "bbox": [
+            147,
+            183,
+            825,
+            213
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "145 Note that all our results can be readily extended in the case where $x \\in \\partial \\Omega = \\bar { \\Omega } \\backslash \\Omega ^ { \\circ }$ but keeping   \n146 the condition $\\rho ( x ) > 0$ (i.e., $x \\in \\partial \\Omega \\cap \\Omega )$ , and assuming the continuity at $x$ of $\\rho$ as seen as a   \n147 function restricted to $\\Omega$ , i.e., ${ \\mathrm { l i m } } _ { y \\in \\Omega \\to x } \\rho ( y ) = \\rho ( x )$ . Useful examples are when the support $\\Omega$ of   \n148 $\\rho$ is a $d$ -dimensional sphere or hypercube and $x$ is on the surface of $\\Omega$ (but still with $\\rho ( x ) > 0 ,$ ). To   \n149 guarantee these results for $x \\in \\partial \\Omega \\cap \\Omega$ , we need also to assume the continuity at $x$ of $f$ , and assume   \n150 that $\\Omega$ is smooth enough near $x$ , so that there exists a strictly positive local solid angle $\\omega _ { x }$ defined by ",
+        "bbox": [
+            140,
+            219,
+            825,
+            304
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7f88489e5f2d1f177867b5d26990fd65b38ed74a7dcadd6eafcb41ef280d4ff7.jpg",
+        "text": "$$\n\\omega _ { x } = \\operatorname* { l i m } _ { r \\to 0 } \\frac { 1 } { V _ { d } \\rho ( x ) r ^ { d } } \\int _ { \\lVert x - y \\rVert \\leq r } \\rho ( y ) d ^ { d } y = \\operatorname* { l i m } _ { r \\to 0 } \\frac { 1 } { V _ { d } r ^ { d } } \\int _ { y \\in \\Omega / \\lVert x - y \\rVert \\leq r } d ^ { d } y ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            254,
+            308,
+            740,
+            344
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "151 where $V _ { d } = S _ { d } / d = \\pi ^ { d / 2 } / \\Gamma ( d / 2 + 1 )$ is the volume of the unit ball in $d$ dimensions, and the second   \n152 inequality results from the continuity of $\\rho$ at $x$ . If $x \\in \\Omega ^ { \\circ }$ , we have $\\omega _ { x } = 1$ , while for $x \\in \\partial \\Omega$ , we   \n153 have $0 \\leq \\omega _ { x } \\leq 1$ . For instance, if $x$ is on the surface of a sphere or on the interior of a face of a   \n154 hypercube (and in general, when the boundary near $x$ is locally an hyperplane), we have $\\begin{array} { r } { \\omega _ { x } = \\frac { 1 } { 2 } } \\end{array}$ . If $x$   \n155 is a corner of a hypercube, we have $\\begin{array} { r } { \\omega _ { x } = \\frac { 1 } { 2 ^ { d } } } \\end{array}$ . From our methods of proof presented in the appendix,   \n156 it should be clear that all our results for $x \\in \\Omega ^ { \\circ }$ perfectly generalize to any $x \\in \\partial \\Omega \\cap \\Omega$ for which   \n157 $\\omega _ { x } > 0$ , by simply replacing $V _ { d }$ whenever it appears in our different results by $\\omega _ { x } V _ { d }$ . ",
+        "bbox": [
+            140,
+            349,
+            825,
+            453
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "158 Hilbert kernel interpolating estimator and Bias-Variance decomposition. The Hilbert kernel regression estimator 159 ${ \\hat { f } } ( x )$ is a Nadaraya-Watson style estimator employing a singular kernel: ",
+        "bbox": [
+            147,
+            463,
+            825,
+            496
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1f48862978b0f9d7a405ba2eadfe3eeb5e66570d3d3e659939e76efe4a0fb4aa.jpg",
+        "text": "$$\n\\begin{array} { r c l } { { w _ { i } ( x ) } } & { { = } } & { { \\displaystyle \\frac { \\| x - x _ { i } \\| ^ { - d } } { \\sum _ { j = 0 } ^ { n } \\| x - x _ { j } \\| ^ { - d } } , } } \\\\ { { \\hat { f } ( x ) } } & { { = } } & { { \\displaystyle \\sum _ { i = 0 } ^ { n } w _ { i } ( x ) y _ { i } . } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            387,
+            501,
+            606,
+            582
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "160 The weights $w _ { i } ( x )$ are also called Lagrange functions in the interpolation literature and satisfy the   \n161 interpolation property $w _ { i } ( x _ { j } ) = \\delta _ { i j }$ , where $\\delta _ { i j } = 1$ , if $i = j$ , and 0 otherwise. At any given point   \n162 $x$ , they provide a partition of unity so that $\\textstyle \\sum _ { i = 0 } ^ { \\tilde { n } } w _ { i } ( x ) = 1$ . The mean squared error between the   \n163 Hilbert estimator and the true regression function has a bias-variance decomposition (using the i.i.d   \n164 condition and the earlier definitions) ",
+        "bbox": [
+            142,
+            585,
+            825,
+            656
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b7ed7545f8c98e5318866d48d4b660fed12460eaa5c3a3b86db971eb3468f227.jpg",
+        "text": "$$\n\\begin{array} { r c l } { { \\hat { f } ( x ) - f ( x ) } } & { { = } } & { { \\displaystyle \\sum _ { i = 0 } ^ { n } w _ { i } ( x ) [ f ( x _ { i } ) - f ( x ) ] + \\sum _ { i = 0 } ^ { n } w _ { i } ( x ) [ y _ { i } - f ( x _ { i } ) ] , } } \\\\ { { \\mathbb { E } [ ( \\hat { f } ( x ) - f ( x ) ) ^ { 2 } ] } } & { { = } } & { { \\displaystyle B ( x ) + \\mathcal { V } ( x ) , } } \\\\ { { ( B i a s ) \\mathcal { B } ( x ) } } & { { = } } & { { \\displaystyle \\mathbb { E } _ { X } \\left[ \\left( \\sum _ { i = 0 } ^ { n } w _ { i } ( x ) [ f ( x _ { i } ) - f ( x ) ] \\right) ^ { 2 } \\right] , } } \\\\ { { ( V a r i a n c e ) \\mathcal { V } ( x ) } } & { { = } } & { { \\displaystyle \\mathbb { E } \\left[ \\sum _ { i = 0 } ^ { n } w _ { i } ^ { 2 } ( x ) [ y _ { i } - f ( x _ { i } ) ] ^ { 2 } \\right] = \\mathbb { E } _ { X } \\left[ \\sum _ { i = 0 } ^ { n } w _ { i } ^ { 2 } ( x ) \\sigma ^ { 2 } ( x _ { i } ) \\right] . } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            232,
+            661,
+            764,
+            809
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "165 The present work derives asymptotic behaviors and bounds for the regression and classification risk   \n166 of the Hilbert estimator for large sample size $n$ . These results are derived by analyzing the large $n$   \n167 behaviors of the bias and variance terms, which in turn depend on the behavior of the moments of the   \n168 weights or the Lagrange functions $w _ { i } ( x )$ . For all these quantities, asymptotically equivalent forms   \n169 are derived. The proofs exploit a simple integral form of the weight function and details are provided   \n170 in the appendix, while the body of the paper provides the results and associated discussions. ",
+        "bbox": [
+            140,
+            827,
+            825,
+            912
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 Results ",
+        "text_level": 1,
+        "bbox": [
+            163,
+            89,
+            266,
+            106
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1 The weights, variance and bias terms ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            119,
+            472,
+            136
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1.1 Moments of the weights: large $n$ behavior ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            145,
+            516,
+            160
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 In this section, we consider the moments and the distribution of the weights $w _ { i } ( x )$ at a given point $x$ .   \n75 The first moment is simple to compute. Since the weights sum to 1 and $X _ { i }$ are i.i.d, it follows that   \n76 $\\mathbb { E } _ { X \\mid x _ { i } } [ w _ { i } ( x ) ]$ are all equal and thus $\\mathbb { E } _ { X | x _ { i } } [ w _ { i } ( x ) ] = ( \\overline { { n } } + 1 ) ^ { - 1 }$ . The other moments are much less   \n77 trivial to compute and we prove the following theorem in the appendix A.2:   \n78 Theorem 3.1. For $x \\in \\Omega ^ { \\circ }$ (so that $\\rho ( x ) > 0 ,$ ), we assume $\\rho$ continuous at $x$ . Then, the moments of   \n179 the weight $w _ { 0 } ( x )$ satisfy the following properties: ",
+        "bbox": [
+            155,
+            169,
+            826,
+            226
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            151,
+            228,
+            826,
+            258
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "180 ",
+        "bbox": [
+            142,
+            271,
+            161,
+            282
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "• For $\\beta > 1$ : ",
+        "bbox": [
+            217,
+            267,
+            307,
+            282
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/029627eabb50f0f8443544799cedc883c94bf7c255caf4c1166415202c435b8f.jpg",
+        "text": "$$\n\\mathbb { E } [ w _ { 0 } ^ { \\beta } ( x ) ] \\underset { n  + \\infty } { \\sim } \\frac { 1 } { ( \\beta - 1 ) n \\ln ( n ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            408,
+            280,
+            647,
+            313
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "• For $0 < \\beta < 1$ : defining $\\begin{array} { r } { \\kappa _ { \\beta } ( x ) : = \\int \\frac { \\rho ( x + y ) } { | | y | | ^ { \\beta d } } d ^ { d } y < \\infty } \\end{array}$ , we have ",
+        "bbox": [
+            217,
+            323,
+            656,
+            344
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e3ee1e909bc8ca6be6e62f067e7afde5ead351b95ad9d9c0a493af8e4cdeeda8.jpg",
+        "text": "$$\n\\mathbb { E } [ w _ { 0 } ^ { \\beta } ( x ) ] \\underset { n  + \\infty } { \\sim } \\frac { \\kappa _ { \\beta } ( x ) } { ( V _ { d } \\rho ( x ) n \\ln ( n ) ) ^ { \\beta } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            383,
+            349,
+            638,
+            385
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "• For $\\beta < 0$ : all moments for $\\beta \\leq - 1$ are infinite, and the moments of order $- 1 < \\beta < 0$ satisfy ",
+        "bbox": [
+            215,
+            396,
+            826,
+            424
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c617dc83fd0915b8e79951c3bd0b8a52dec94e931a0b3eb89b801f429bd27bc5.jpg",
+        "text": "$$\n\\mathbb { E } \\left[ w _ { 0 } ^ { \\beta } ( x ) \\right] \\leq 1 + n \\kappa _ { | \\beta | } ( x ) \\kappa _ { \\beta } ( x ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            413,
+            422,
+            642,
+            450
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "184 ",
+        "bbox": [
+            142,
+            457,
+            161,
+            468
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "so that a sufficient condition for its existence is $\\begin{array} { r } { \\kappa _ { \\beta } ( x ) = \\int \\rho ( x + y ) \\lvert | y \\rvert | ^ { \\lvert \\beta \\rvert d } d ^ { d } y < \\infty . } \\end{array}$ . ",
+        "bbox": [
+            228,
+            453,
+            797,
+            470
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "185 Heuristically, the behavior of these moments are consistent with the random variable $W = w _ { 0 } ( x )$   \n186 having a probability distribution satisfying a scaling relation $\\begin{array} { r } { P ( W ) = \\frac { 1 } { W _ { n } } p \\left( \\frac { W } { W _ { n } } \\right) } \\end{array}$ , with the scaling   \n187 function $p$ having the universal tail (i.e., independent of $x$ and $\\rho \\mathrm { \\hbar }$ ), $p ( w ) \\sim w ^ { - 2 }$ , and a scale $W _ { n }$   \n188 expected to vanish with $n$ , when $n  + \\infty$ . With this assumption, we can determine the scale $W _ { n }$ by   \n189 imposing the exact condition $\\mathbb { E } [ W ] = 1 / ( n + 1 ) \\sim 1 / n$ : ",
+        "bbox": [
+            142,
+            478,
+            826,
+            568
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0c30a8c47d7ef7132e4589b8c6c32899cbc45a653e6964200934a9bf699be76d.jpg",
+        "text": "$$\n\\begin{array} { r c l } { \\mathbb { E } [ W ] } & { = } & { \\displaystyle \\frac { 1 } { W _ { n } } \\int _ { 0 } ^ { 1 } p \\left( \\frac { W } { W _ { n } } \\right) W d W = W _ { n } \\int _ { 0 } ^ { \\frac { 1 } { W _ { n } } } p ( w ) w d w } \\\\ & { \\sim } & { W _ { n } \\int _ { 1 } ^ { \\frac { 1 } { W _ { n } } } \\displaystyle \\frac { d w } { w } \\sim - W _ { n } \\ln ( W _ { n } ) \\sim \\frac { 1 } { n } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            289,
+            573,
+            709,
+            651
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "$\\begin{array} { r } { W _ { n } \\sim \\frac { 1 } { n \\ln ( n ) } } \\end{array}$ . Then, the moment of order $\\beta > 1$ ",
+        "bbox": [
+            143,
+            655,
+            638,
+            674
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f0b6dafafafb21b0751363351a3da579dfc5e37797e37d759df8f3422908491a.jpg",
+        "text": "$$\n\\mathbb { E } [ W ^ { \\beta } ] = \\frac { 1 } { W _ { n } } \\int _ { 0 } ^ { 1 } p \\left( \\frac { W } { W _ { n } } \\right) W ^ { \\beta } d W \\sim W _ { n } \\int _ { 0 } ^ { 1 } W ^ { \\beta - 2 } d W \\underset { n \\to + \\infty } { \\sim } \\frac { 1 } { ( \\beta - 1 ) n \\ln ( n ) } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            205,
+            679,
+            764,
+            717
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "191 which indeed coincides with the first result of Theorem 3.1. Our heuristic argument also suggests   \n192 that in the case $0 < \\beta < 1$ , we have ",
+        "bbox": [
+            135,
+            722,
+            828,
+            751
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/237f93530eda6975aa50ede0ec2bc483edec865604ec556f1bd22d7950ac0eea.jpg",
+        "text": "$$\n\\mathbb { E } [ W ] = \\frac { 1 } { W _ { n } } \\int _ { 0 } ^ { 1 } p ( \\frac { W } { W _ { n } } ) W ^ { \\beta } d W \\quad \\underset { n  + \\infty } { \\sim } \\quad \\frac { \\int _ { 0 } ^ { + \\infty } p ( w ) w ^ { \\beta } d w } { ( n \\ln ( n ) ) ^ { \\beta } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            274,
+            755,
+            722,
+            794
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "193 where the last integral converges since $p ( w ) \\underset { w  + \\infty } { \\sim } w ^ { - 2 }$ and $\\beta < 1$ . This result is perfectly consistent   \n194 with Eq. (9) in Theorem 3.1, and suggests that $\\begin{array} { r } { \\int _ { 0 } ^ { + \\infty } p \\left( w \\right) w ^ { \\beta } d w = \\frac { \\kappa _ { \\beta } \\left( x \\right) } { \\left( V _ { d } \\rho \\left( x \\right) \\right) ^ { \\beta } } } \\end{array}$ κβ(x)(Vdρ(x)) β . Interestingly, for   \n195 $0 < \\beta < 1$ , and contrary to the case $\\beta > 1$ , we find that the large $n$ equivalent of the moment is not   \n196 universal and depends explicitly on $x$ and the density $\\rho$ . As for moments of order $- 1 < \\beta < 0$ , we   \n197 conjecture that they are still given by Eq. (9) (and equivalently, by Eq. (14)) provided they exist, and   \n198 that the sufficient condition for their existence $\\kappa _ { \\beta } ( x ) < \\infty$ is hence also necessary, since $\\kappa _ { \\beta } ( x )$ also   \n199 appears in Eq. (9). The fact that moments for $\\beta \\leq - 1$ do not exist strongly suggests that $p ( 0 ) > 0$ .   \n200 In fact, Eq. (14)) also suggests that all moments for $- 1 < \\beta < 0$ exist if and only if $0 < p ( 0 ) < \\infty$ .   \n201 In the Fig. 2 of the appendix, we present numerical simulations confirming our scaling ansatz, the   \n202 fact that $\\overline { { p } } ( w ) \\underset { w  + \\infty } { \\sim } w ^ { - 2 }$ , and the quantitative prediction for $W _ { n }$ .   \n203 It is shown in Devroye et al. [18] that the Hilbert kernel regression estimate does not converge   \n204 almost surely (a.s.) by giving a specific example. Insight can be gained into this lack of almost sure   \n205 convergence by considering the weight function $w _ { 0 } ( x )$ , for a sequence of independent training sample   \n206 sets of increasing size $n + 1$ . Let the corresponding sequence of weights be denoted as $\\omega _ { n } \\in [ 0 , 1 ]$ .   \n207 From Theorem 3.1, it is clear that $\\omega _ { n }$ converges to zero in probability, since the following Chebyshev   \n208 bound holds (analogous to the bound on the regression risk): ",
+        "bbox": [
+            140,
+            799,
+            826,
+            912
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            90,
+            826,
+            140
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            145,
+            825,
+            228
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/450fc40d858077f7c51d7fbe9773c7ea3db29605cd7bb93fb3ebfca536ac5bfd.jpg",
+        "text": "$$\n\\mathbb { P } ( \\omega _ { n } > \\varepsilon ) \\leq \\frac { 1 + \\delta } { \\varepsilon ^ { 2 } n \\ln ( n ) } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            413,
+            231,
+            583,
+            265
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "209 for arbitrary $\\varepsilon > 0$ and $\\delta > 0$ , and for $n$ larger than some constant $N _ { x , \\delta }$ . Alternatively, one can   \n210 exploit the fact that $\\begin{array} { r } { \\mathbb { E } [ \\omega _ { n } ] = \\frac { 1 } { n + 1 } } \\end{array}$ , leading to $\\begin{array} { r } { \\mathbb { P } ( \\omega _ { n } > \\varepsilon ) \\le \\frac { 1 } { \\varepsilon n } } \\end{array}$ , which is less stringent than Eq. (15)   \n211 as far as the $n$ -dependence is concerned, but is more stringent for the $\\varepsilon$ -dependence of the bounds.   \n212 Let us show heuristically that $\\omega _ { n }$ does not converge a.s. to zero. Consider the infinite sequence of   \n213 events ${ \\mathcal { E } } _ { n } \\equiv \\{ \\omega _ { n } > \\varepsilon \\}$ , $n \\in \\mathbb N$ , and the corresponding infinite sum $\\begin{array} { r } { \\sum _ { n } \\mathbb { P } ( \\mathcal { E } _ { n } ) = \\sum _ { n } \\mathbb { P } ( \\omega _ { n } > \\varepsilon ) } \\end{array}$ .   \n214 Exploiting our previous heuristic argument for the scaling form of the distribution of weights, we   \n215 obtain ",
+        "bbox": [
+            140,
+            267,
+            826,
+            313
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            138,
+            318,
+            826,
+            372
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/df757726a427f551795ab4b73b6126c75885e757ba78099510898cface8ef5d1.jpg",
+        "text": "$$\n\\mathbb { P } ( \\omega _ { n } > \\varepsilon ) = \\int _ { \\varepsilon } ^ { 1 } { \\frac { 1 } { W _ { n } } } p \\left( { \\frac { W } { W _ { n } } } \\right) d W \\sim \\int _ { \\varepsilon n \\ln n } ^ { n \\ln n } { \\frac { d w } { w ^ { 2 } } } \\sim { \\frac { 1 - \\varepsilon } { \\varepsilon n \\ln ( n ) } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            281,
+            369,
+            715,
+            406
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "216 Since PNn=2 1n ln(n) $\\begin{array} { r } { \\sum _ { n = 2 } ^ { N } { \\frac { 1 } { n \\ln ( n ) } } \\sim \\ln ( \\ln ( N ) ) } \\end{array}$ is a divergent series, a Borel-Cantelli argument suggests that an   \n217 infinite number of the events ${ \\mathcal { E } } _ { n }$ (i.e., $\\omega _ { n } > \\varepsilon$ ) must occur, which implies that $\\omega _ { n }$ does not converge   \n218 a.s. to 0. Note that the weights are equal to 1 at the data points due to the interpolation condition, so   \n219 that large weights occasionally occur, causing the lack of a.s. convergence. ",
+        "bbox": [
+            145,
+            409,
+            826,
+            468
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.1.2 Lagrange function: scaling limit ",
+        "text_level": 1,
+        "bbox": [
+            168,
+            481,
+            449,
+            497
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The expected value of the Lagrange functions $w _ { i } ( x )$ have a simple form in the large $n$ limit. Due to the i.i.d. condition the indices $i$ are exchangeable and we set $i = 0$ for the computation of the expected Lagrange function $L _ { 0 } ( x ) = \\mathbb { E } _ { X \\mid x _ { 0 } } [ w \\overline { { 0 } } ( x ) ]$ . Thus, one of the sample points (denoted $x _ { 0 }$ ) is held fixed and the other ones are averaged over in computing the expected Lagrange function. For $x _ { 0 } \\neq x$ kept fixed, we have $\\begin{array} { r } { \\operatorname* { l i m } _ { n  \\infty } L _ { 0 } ( x ) = 0 } \\end{array}$ . However, we show in the appendix A.3 that $L _ { 0 } ( x )$ takes a very simple form when taking a specific scaling limit: ",
+        "bbox": [
+            166,
+            505,
+            825,
+            589
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Theorem 3.2. For $x \\in \\Omega ^ { \\circ }$ , we assume $\\rho$ continuous at $x$ . Then, in the limit (denoted by $\\operatorname { l i m } _ { Z }$ ), $n $ $+ \\infty ,$ , $\\lVert \\boldsymbol { x } - \\boldsymbol { x } _ { 0 } \\rVert ^ { - d } \\to + \\infty$ (i.e., $x _ { 0 } \\to x _ { , }$ ), and such that $z _ { x } ( n , x _ { 0 } ) = V _ { d } \\rho ( x ) \\| x - x _ { 0 } \\| ^ { d } n \\log ( n ) \\to Z$ the Lagrange function $L _ { 0 } ( x ) = \\mathbb { E } _ { X \\mid x _ { 0 } } [ w _ { 0 } ( x ) ]$ converges to a proper limit, ",
+        "bbox": [
+            166,
+            592,
+            825,
+            635
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e6917e76cf39bc3fdf7cfb995013b51157eb4c09809b5968e1775609e355cace.jpg",
+        "text": "$$\n\\operatorname* { l i m } _ { Z } L _ { 0 } ( x ) = \\frac { 1 } { 1 + Z } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            428,
+            637,
+            568,
+            669
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The proof of this theorem shows that the relative error between 230 $L _ { 0 } ( x )$ and $\\frac { 1 } { 1 { + } Z }$ for finite but large $n$ and large 231 $\\lVert x - x _ { 0 } \\rVert ^ { - d }$ , such that $z _ { x } ( n , x _ { 0 } )$ remains close to $Z$ , is $O ( 1 / \\ln ( n ) )$ . ",
+        "bbox": [
+            145,
+            679,
+            828,
+            713
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "232 Exploiting Theorem 3.2, we can use a simple heuristic argument to estimate the tail of the distribution   \n233 of the random variable $W = w _ { 0 } ( x )$ . Indeed, approximating $L _ { 0 } ( x )$ for finite but large $n$ by its   \n234 asymptotic for m 11+z (n,x ) , with zx(n, x0) = Vdρ(x)n log(n)kx − x0kd, we obtain ",
+        "bbox": [
+            142,
+            717,
+            825,
+            763
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e667a8b33b98aa02050ecddb3cf14c22b1f2cbc508548502def75e58bf606ea4.jpg",
+        "text": "$$\n\\begin{array} { r c l } { \\displaystyle \\int _ { W } ^ { 1 } P ( W ^ { \\prime } ) d W ^ { \\prime } } & { \\sim } & { \\displaystyle \\int \\rho ( x _ { 0 } ) \\theta \\left( \\frac { 1 } { 1 + V _ { d } \\rho ( x ) n \\log ( n ) \\| x - x _ { 0 } \\| ^ { d } } - W \\right) d ^ { d } x _ { 0 } , } \\\\ & { \\sim } & { \\displaystyle V _ { d } \\rho ( x ) \\int _ { 0 } ^ { + \\infty } \\theta \\left( \\frac { 1 } { 1 + V _ { d } \\rho ( x ) n \\log ( n ) u } - W \\right) d u , } \\\\ & { \\sim } & { \\displaystyle \\frac { 1 } { n \\ln ( n ) W } \\quad \\Longrightarrow \\ P ( W ) \\sim \\frac { 1 } { n \\ln ( n ) W ^ { 2 } } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            227,
+            767,
+            764,
+            875
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "235 where $\\theta ( . )$ is the Heaviside function. This heuristic result is again perfectly consistent with our guess of the previous section that 236 $\\begin{array} { r } { P ( W ) = \\frac { 1 } { W _ { n } } p \\left( \\frac { W } { W _ { n } } \\right) } \\end{array}$ , with the scaling function $p$ having the universal ",
+        "bbox": [
+            142,
+            876,
+            823,
+            915
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "tail, $p ( w ) \\underset { w  + \\infty } { \\sim } w ^ { - 2 }$ , and a scale $\\begin{array} { r } { W _ { n } \\sim \\frac { 1 } { n \\ln ( n ) } } \\end{array}$ . Indeed, in this case and in the limit $n  + \\infty$ , we obtain that $\\begin{array} { r } { P ( W ) \\sim \\frac { 1 } { W _ { n } } \\left( \\frac { W _ { n } } { W } \\right) ^ { 2 } \\sim \\frac { W _ { n } } { W ^ { 2 } } \\sim \\frac { 1 } { n \\ln ( n ) W ^ { 2 } } } \\end{array}$ , which is identical to the result of Eq. (20). ",
+        "bbox": [
+            171,
+            89,
+            826,
+            140
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.1.3 The variance term ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            154,
+            354,
+            170
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "A simple application of the result of Theorem 3.1 for $\\beta = 2$ (see appendix A.4) allows us to bound the variance term $\\begin{array} { r } { \\mathcal { V } ( x ) = \\mathbb { E } \\left[ \\sum _ { i = 0 } ^ { n } w _ { i } ^ { 2 } ( x ) [ y _ { i } - f ( x _ { i } ) ] ^ { 2 } \\right] } \\end{array}$ for a bounded variance function $\\sigma ^ { 2 }$ : ",
+        "bbox": [
+            169,
+            178,
+            823,
+            217
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Theorem 3.3. For $x \\in \\Omega ^ { \\circ }$ , $\\rho$ continuous at $x$ , $\\sigma ^ { 2 } \\le \\sigma _ { 0 } ^ { 2 }$ , and for any $\\varepsilon > 0$ , there exists a constant $N _ { x , \\varepsilon }$ such that for $n \\geq N _ { x , \\varepsilon }$ , we have ",
+        "bbox": [
+            163,
+            220,
+            825,
+            252
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a3952beba8eeead103169423ac318435549f322eff3918bedf6eedfdd9082dcc.jpg",
+        "text": "$$\n\\mathcal { V } ( x ) \\leq ( 1 + \\varepsilon ) \\frac { \\sigma _ { 0 } ^ { 2 } } { \\ln ( n ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            421,
+            258,
+            575,
+            294
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "244 Relaxing the boundedness condition for $\\sigma$ , but assuming the continuity of $\\sigma ^ { 2 }$ at $x$ along with a growth   \n245 condition, allows us to obtain a precise asymptotic equivalent of $\\mathcal { V } ( x )$ , when $n  + \\infty$ : ",
+        "bbox": [
+            143,
+            309,
+            828,
+            339
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Theorem 3.4. For 246 $x \\in \\Omega ^ { \\circ }$ , $\\sigma ( x ) > 0$ , $\\rho \\sigma ^ { 2 }$ continuous at $x$ , and assuming the condition $C _ { \\mathrm { G r o w t h } } ^ { \\sigma }$ , i.e., 247 $\\begin{array} { r } { \\int \\rho ( y ) \\frac { \\sigma ^ { 2 } ( y ) } { 1 + \\| y \\| ^ { 2 d } } d ^ { d } y < \\infty } \\end{array}$ , we have ",
+        "bbox": [
+            147,
+            342,
+            826,
+            381
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3706bfdabcd1df9bdca065bb5abf98fdce5d41eaa36897376cfc69f817c44feb.jpg",
+        "text": "$$\n\\mathcal { V } ( x ) \\underset { n \\to + \\infty } { \\sim } \\frac { \\sigma ^ { 2 } ( x ) } { \\ln ( n ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            429,
+            388,
+            568,
+            422
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "48 Note that if the mean variance $\\begin{array} { r } { \\int \\rho ( y ) \\sigma ^ { 2 } ( y ) d ^ { d } y < \\infty } \\end{array}$ , which is in particular the case when $\\sigma ^ { 2 }$ is   \n49 bounded over $\\Omega$ , then the condition $C _ { \\mathrm { G r o w t h } } ^ { \\sigma }$ is in fact automatically satisfied. ",
+        "bbox": [
+            153,
+            438,
+            828,
+            469
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.1.4 The bias term ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            483,
+            323,
+            500
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In appendix A.5, we prove the following three theorems for the bias term. ",
+        "bbox": [
+            166,
+            507,
+            666,
+            523
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Theorem 3.5. For 52 $x \\in \\Omega ^ { \\circ }$ (so that $\\rho ( x ) > 0 .$ ), we assume that $\\rho$ is continuous at $x$ , and the conditions ",
+        "bbox": [
+            158,
+            526,
+            820,
+            542
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f7b392164cada2854b1187b61fd0a06bd49100bfd3fc03d2f4272cc206134367.jpg",
+        "text": "$$\n\\begin{array} { r } { \\bullet _ { \\mathbf { \\phi } } C _ { \\mathrm { G r o w t h } } ^ { f } \\colon \\int _ { \\mathbf { \\phi } } ( y ) \\frac { f ^ { 2 } ( y ) } { 1 + \\| y \\| ^ { 2 d } } d ^ { d } y < \\infty , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            222,
+            553,
+            465,
+            578
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Moreover, we define 257 $\\begin{array} { r } { \\kappa ( x ) = \\int \\rho ( x + y ) \\frac { f ( x + y ) - f ( x ) } { \\vert \\vert y \\vert \\vert ^ { d } } d ^ { d } y . } \\end{array}$ , where we have $| \\kappa ( x ) | < \\infty$ ",
+        "bbox": [
+            151,
+            641,
+            736,
+            665
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Then, for 258 $\\kappa ( x ) \\neq 0 ,$ , the bias term $\\begin{array} { r } { \\mathcal { B } ( x ) = \\mathbb { E } _ { X } \\Big [ \\Big ( \\sum _ { i = 0 } ^ { n } w _ { i } ( x ) [ f ( x _ { i } ) - f ( x ) ] \\Big ) ^ { 2 } \\Big ] } \\end{array}$ satisfies ",
+        "bbox": [
+            142,
+            671,
+            753,
+            698
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2c42f323eb13a80226c519a8b2474bd78f0be76c78cf72e77927ac7578a90cbe.jpg",
+        "text": "$$\n\\mathcal { B } ( x ) \\underset { n  + \\infty } { \\sim } ( \\mathbb { E } [ \\hat { f } ( x ) ] - f ( x ) ) ^ { 2 } , \\qquad \\mathrm { w i t h } \\quad \\mathbb { E } [ \\hat { f } ( x ) ] - f ( x ) \\underset { n  + \\infty } { \\sim } \\frac { \\kappa ( x ) } { V _ { d } \\rho ( x ) \\ln ( n ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            189,
+            704,
+            776,
+            742
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "259 In the non generic case $\\kappa ( \\boldsymbol { x } ) = 0$ , we have the weaker result ",
+        "bbox": [
+            140,
+            750,
+            571,
+            766
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c8b52b765a4de5ca9cae12b69fae63a8c7e6f0a7e26b5862a8a7301df2d2b81f.jpg",
+        "text": "$$\n\\begin{array} { r } { B ( x ) = \\left\\{ \\begin{array} { l l } { O \\left( n ^ { - \\frac { 2 \\alpha _ { x } } { d } } ( \\ln ( n ) ) ^ { - 1 - \\frac { 2 \\alpha _ { x } } { d } } \\right) , } & { f o r \\ d > 2 \\alpha _ { x } } \\\\ { O \\left( n ^ { - 1 } ( \\ln ( n ) ) ^ { - 1 } \\right) , } & { f o r \\ d = 2 \\alpha _ { x } } \\\\ { O \\left( n ^ { - 1 } ( \\ln ( n ) ) ^ { - 2 } \\right) , } & { f o r \\ d < 2 \\alpha _ { x } } \\end{array} \\right. } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            308,
+            772,
+            679,
+            854
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "260 Note that $\\kappa ( \\boldsymbol { x } ) = 0$ is non generic but can still happen, even if $f$ is not constant. For instance, if $\\Omega$ is a   \n261 sphere centered at $x$ or $\\Omega = \\mathbb { R } ^ { d }$ , if $\\rho ( x + y ) = \\hat { \\rho } ( | | y | | )$ is isotropic around $x$ , and if $f _ { x } : y \\mapsto f ( x + y )$   \n262 is an odd function of $y$ , then we indeed have $\\kappa ( \\boldsymbol { x } ) = 0$ at this symmetric point $x$ . ",
+        "bbox": [
+            142,
+            867,
+            821,
+            912
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Interestingly, for $\\kappa ( \\boldsymbol { x } ) \\neq 0$ , Eq. (23) shows that the bias $B ( x )$ is asymptotically dominated by the square of $\\mathbb { E } \\left[ { \\hat { f } } ( x ) \\right] - f ( x )$ , showing that the fluctuations of $\\begin{array} { r } { \\mathbb { E } \\left[ \\hat { f } ( x ) \\right] - \\sum _ { i = 0 } ^ { n } w _ { i } ( x ) f ( x _ { i } ) } \\end{array}$ are negligible compared to $\\mathbb { E } \\left[ { \\hat { f } } ( x ) \\right] - f ( x )$ , in the limit $n  + \\infty$ and for $\\kappa ( x ) \\neq 0$ . ",
+        "bbox": [
+            166,
+            90,
+            826,
+            155
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "One can relax the local Hölder condition, but at the price of a weaker estimate for $B ( x )$ which will however be enough to obtain strong results for the regression and classification risks (see below): ",
+        "bbox": [
+            163,
+            159,
+            823,
+            189
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Theorem 3.6. For $x \\in \\Omega ^ { \\circ }$ , we assume $\\rho$ and $f$ continuous at $x$ , and the growth condition $C _ { \\mathrm { G r o w t h } } ^ { f }$ $\\begin{array} { r } { \\int \\rho ( y ) \\frac { f ^ { 2 } ( y ) } { 1 + \\| y \\| ^ { 2 d } } d ^ { d } y < \\infty . } \\end{array}$ . Then, the bias term satisfies ",
+        "bbox": [
+            163,
+            194,
+            825,
+            232
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c2df152db867d03c5c5e0128e5ef90fda1455d2353d8fd2003bc698605f6f326.jpg",
+        "text": "$$\n{ \\cal B } ( x ) = o \\left( \\frac { 1 } { \\ln ( n ) } \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            428,
+            239,
+            568,
+            275
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "270 or equivalently, for any $\\varepsilon > 0$ , there exists $N _ { x , \\varepsilon }$ , such that for $n \\geq N _ { x , \\varepsilon }$ ",
+        "bbox": [
+            140,
+            281,
+            642,
+            297
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fe6a46052837c80a4959bc525ac21df1ae77a1ee8ca54338f3f1dece1f81496e.jpg",
+        "text": "$$\nB ( x ) \\leq { \\frac { \\varepsilon } { \\ln ( n ) } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            446,
+            305,
+            550,
+            335
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "271 Let us now consider a point $x \\in \\partial \\Omega$ for which we have $\\rho ( { \\boldsymbol { x } } ) = 0$ (note that $x \\in \\partial \\Omega$ does not 272 necessarily imply $\\rho ( x ) = 0 ,$ ). In appendix A.5, we show the following theorem for the expectation value of the estimator 273 ${ \\hat { f } } ( x )$ in the limit $n \\to + \\infty$ : ",
+        "bbox": [
+            140,
+            349,
+            825,
+            396
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "274 Theorem 3.7. For $x \\in \\partial \\Omega$ such that $\\rho ( x ) = 0$ , we assume that $f$ and $\\rho$ satisfy the conditions ",
+        "bbox": [
+            148,
+            400,
+            785,
+            416
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "$\\begin{array} { r } { \\bullet \\ C _ { \\mathrm { G r o w t h } } ^ { f } \\cdot \\int \\rho ( y ) \\frac { | f ( y ) | } { 1 + \\| y \\| ^ { d } } \\ d ^ { d } y < \\infty , } \\end{array}$   \n• $C _ { \\mathrm { H o l d e r } } ^ { \\rho }$ : thand $\\alpha _ { x } > 0$ $K _ { x } > 0$ $\\delta _ { x } > 0$   \n$x ^ { \\prime } \\in \\Omega$ $\\| x - x ^ { \\prime } \\| \\leq \\delta _ { x } \\implies | \\rho ( x ^ { \\prime } ) | \\leq K _ { x } \\| x - x ^ { \\prime } \\| ^ { \\alpha _ { x } }$ (local Hölder condition for $\\rho$ ). ",
+        "bbox": [
+            217,
+            425,
+            624,
+            501
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Mor279 and 280 $\\begin{array} { r } { \\kappa ( x ) = \\int \\rho ( x + y ) \\frac { f ( x + y ) - f ( x ) } { | | y | | ^ { d } } d ^ { d } y ( | \\kappa ( x ) | < \\infty  } \\end{array}$ under condition en, $C _ { \\mathrm { G r o w t h } } ^ { f } )$ $\\begin{array} { r } { \\lambda ( x ) = \\int \\frac { \\rho ( x + y ) } { | | y | | ^ { d } } d ^ { d } y } \\end{array}$ $( 0 < \\lambda ( x ) < \\infty$ $C _ { \\mathrm { H o l d e r } } ^ { \\sigma }$ ",
+        "bbox": [
+            140,
+            511,
+            823,
+            554
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1d141f3551702e23f28b7a43ba37886698332a513a70dd95e814e5ae246287ba.jpg",
+        "text": "$$\n\\operatorname* { l i m } _ { n  + \\infty } \\mathbb { E } [ \\hat { f } ( x ) ] - f ( x ) = \\frac { \\kappa ( x ) } { \\lambda ( x ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            374,
+            561,
+            591,
+            595
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "281 Hence, in the generic case $\\kappa ( \\boldsymbol { x } ) \\neq 0$ (see Theorem 3.5 and the discussion below it) and under   \n282 condition $C _ { \\mathrm { H o l d e r } } ^ { \\rho }$ , we find that the bias does not vanish when $\\rho ( x ) = 0$ , and that the estimator $\\hat { f } ( x )$   \n283 does not converge to $f ( x )$ . When $\\rho ( x ) = 0$ , the scarcity of data near the point $x$ indeed prevents the   \n284 285 $\\rho$ stimator to concontinuous at $x$ rge to the actuand such that $\\rho ( x ) = 0$ f , $f ( x )$ . In appendix A.5, we shownot satisfying the condition $C _ { \\mathrm { H o l d e r } } ^ { \\rho }$ ple of a density, and for which   \n286 $\\begin{array} { r } { \\operatorname* { l i m } _ { n  + \\infty } \\mathbb { E } [ \\hat { f } ( x ) ] = f ( x ) } \\end{array}$ , even if $\\kappa ( x ) \\neq 0$ . ",
+        "bbox": [
+            142,
+            609,
+            825,
+            702
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "3.2 Asymptotic equivalent for the regression risk ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            717,
+            526,
+            733
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In appendix A.6, we prove the following theorem establishing the asymptotic rate at which the excess risk goes to zero with large sample size $n$ for Hilbert kernel regression, under mild conditions that do not require $f$ or $\\sigma$ to be bounded, but only to satisfy some growth conditions: ",
+        "bbox": [
+            171,
+            743,
+            825,
+            786
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Theorem 3.8. For $x \\in \\Omega ^ { \\circ }$ , we assume $\\sigma ( x ) > 0$ , ρ, σ, and $f$ continuous at $x$ , and the growth conditions $\\begin{array} { r } { C _ { \\mathrm { G r o w t h } } ^ { \\sigma } \\colon \\int \\rho ( y ) \\frac { \\sigma ^ { 2 } ( y ) } { 1 + \\| y \\| ^ { 2 d } } d ^ { d } y < \\infty } \\end{array}$ and $\\begin{array} { r } { C _ { \\mathrm { G r o w t h } } ^ { f } \\colon \\int \\rho ( y ) \\frac { f ^ { 2 } ( y ) } { 1 + \\| y \\| ^ { 2 d } } d ^ { d } y < \\infty } \\end{array}$ . ",
+        "bbox": [
+            169,
+            790,
+            825,
+            829
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "93 Then the following statements are true: ",
+        "bbox": [
+            156,
+            832,
+            431,
+            847
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "• The excess regression risk at the point $x$ satisfies ",
+        "bbox": [
+            217,
+            858,
+            553,
+            875
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3a0df23cbf8555547567d82f07cc643c25ffb06421216c32466100ded88e2df1.jpg",
+        "text": "$$\n\\mathbb { E } [ ( \\hat { f } ( x ) - f ( x ) ) ^ { 2 } ] \\underset { n  + \\infty } { \\sim } \\frac { \\sigma ^ { 2 } ( x ) } { \\ln ( n ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            413,
+            881,
+            642,
+            916
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "• The Hilbert kernel estimate converges pointwise to the regression function in probability. More specifically, for any $\\delta > 0$ , there exists a constant $N _ { x , \\delta }$ , such that for any $\\varepsilon > 0$ , we have the following Chebyshev bound, valid for $n \\geq N _ { x , \\delta }$ ",
+        "bbox": [
+            217,
+            90,
+            820,
+            133
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2dbbebe98e11af6688d6a91d238394af642981632ad121bf433f4bda8f735cb4.jpg",
+        "text": "$$\n\\mathbb { P } [ | \\hat { f } ( x ) - f ( x ) | \\geq \\varepsilon ] \\leq \\frac { 1 + \\delta } { \\varepsilon ^ { 2 } } \\frac { \\sigma ^ { 2 } ( x ) } { \\ln ( n ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            400,
+            136,
+            656,
+            170
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "8 This theorem is a consequence of the corresponding asymptotically equivalent forms of the variance   \n9 and bias terms presented above. Note that as long as $\\rho ( x ) > 0$ , the variance term dominates over the   \n00 bias term and the regression risk has the same form as the variance term. ",
+        "bbox": [
+            155,
+            176,
+            826,
+            218
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "3.3 Rates for the plugin classifier ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            233,
+            415,
+            248
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In appendix A.7, we prove the following theorem establishing the asymptotic rate at which the classification risk goes to zero with large sample size $n$ for Hilbert kernel regression: ",
+        "bbox": [
+            169,
+            258,
+            823,
+            287
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Theorem 3.9. For $x \\in \\Omega ^ { \\circ }$ , we assume $\\sigma ( x ) > 0$ , $\\rho , \\sigma$ , and $f$ continuous at $x$ . Then, the classification risk $\\mathbb { E } [ \\mathcal { R } _ { 0 / 1 } ( \\hat { F } ( x ) ) ] - \\mathcal { R } _ { 0 / 1 } ( F ( x ) )$ vanishes for $n  + \\infty$ . ",
+        "bbox": [
+            160,
+            289,
+            823,
+            320
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "306 More precisely, for any $\\varepsilon > 0$ , there exists $N _ { x , \\varepsilon }$ , such that for any $n \\geq N _ { x , \\varepsilon }$ , ",
+        "bbox": [
+            147,
+            324,
+            674,
+            340
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9a05715b809769eff558d60aedf7d27fa51af21ea83e8a7d5552afc461bca877.jpg",
+        "text": "$$\n0 \\leq \\mathbb { E } [ \\mathcal { R } _ { 0 / 1 } ( \\hat { F } ( x ) ) ] - \\mathcal { R } _ { 0 / 1 } ( F ( x ) ) \\leq 2 ( 1 + \\varepsilon ) \\frac { \\sigma ( x ) } { \\sqrt { \\ln ( n ) } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            308,
+            340,
+            684,
+            377
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "307 In addition, for any $0 < \\alpha < 1$ , the general inequality ",
+        "bbox": [
+            138,
+            383,
+            529,
+            400
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/52ddb230a269f1f792e812b725d62ffd08d20b9f7ca3a941b78ebb02b643c7c5.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathbb { E } [ \\mathcal { R } _ { 0 / 1 } ( \\hat { F } ( x ) ) ] - \\mathcal { R } _ { 0 / 1 } ( F ( x ) ) \\leq 2 | f ( x ) - 1 / 2 | ^ { 1 - \\alpha } \\mathbb { E } \\left[ | \\hat { f } ( x ) - f ( x ) | ^ { 2 } \\right] ^ { \\frac { \\alpha } { 2 } } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            250,
+            400,
+            745,
+            429
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "308 holds unconditionally and, for $n \\geq N _ { x , \\varepsilon }$ , leads to ",
+        "bbox": [
+            142,
+            429,
+            501,
+            444
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e257221525c91d4ce72ad1befa896ea8a4309dbf38a114952e588b412bd90720.jpg",
+        "text": "$$\n0 \\leq \\mathbb { E } [ \\mathcal { R } _ { 0 / 1 } ( \\hat { F } ( x ) ) ] - \\mathcal { R } _ { 0 / 1 } ( F ( x ) ) \\leq 2 | f ( x ) - 1 / 2 | ^ { 1 - \\alpha } \\left( 1 + \\varepsilon \\right) ^ { \\alpha } \\frac { \\sigma ^ { \\alpha } ( x ) } { \\left( \\ln ( n ) \\right) ^ { \\frac { \\alpha } { 2 } } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            243,
+            444,
+            753,
+            479
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "309 For $0 < \\alpha < 1$ , Eq. (32) is weaker than Eq. (30) in terms of its dependence on $n$ , but explicitly   \n310 shows that the classification risk vanishes for $f ( x ) = 1 / 2$ . This theorem does not require any growth   \n311 condition for $f$ or $\\sigma$ , since both functions takes values in $[ 0 , 1 ]$ in the classification context. ",
+        "bbox": [
+            140,
+            484,
+            823,
+            529
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "3.4 Extrapolation behavior outside the support of $\\rho$ ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            542,
+            544,
+            559
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We now take the point $x$ outside the closed support $\\bar { \\Omega }$ of the distribution $\\rho$ (which excludes the case $\\Omega = \\mathbb { R } ^ { d }$ ). We are interested in the behavior of $\\mathbb { E } \\left[ \\hat { f } ( x ) \\right]$ as $n  + \\infty$ . In appendix A.8 we prove: ",
+        "bbox": [
+            171,
+            566,
+            823,
+            607
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Theorem 3.10. For 315 $x \\notin \\bar { \\Omega }$ , we assume the growth condition $\\begin{array} { r } { \\int \\rho ( y ) \\frac { | f ( y ) | } { 1 + \\| y \\| ^ { d } } d ^ { d } y < \\infty } \\end{array}$ ",
+        "bbox": [
+            156,
+            608,
+            772,
+            631
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ab28fe82419cafc03fc6ed8371601dd011c04570e69266e7819207e5c52f39ce.jpg",
+        "text": "$$\n\\hat { f } _ { \\infty } ( x ) : = \\operatorname* { l i m } _ { n \\to + \\infty } \\mathbb { E } \\left[ \\hat { f } ( x ) \\right] = \\frac { \\int \\rho ( y ) f ( y ) \\| x - y \\| ^ { - d } d ^ { d } y } { \\int \\rho ( y ) \\| x - y \\| ^ { - d } d ^ { d } y } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            305,
+            631,
+            691,
+            666
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "and 316 $\\hat { f } _ { \\infty }$ is continuous at all $x \\notin \\bar { \\Omega }$ . ",
+        "bbox": [
+            145,
+            669,
+            403,
+            685
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In addition, i317 $\\begin{array} { r } { f \\int \\rho ( y ) | f ( y ) | d ^ { d } y < \\infty } \\end{array}$ , and defining $d ( x , \\Omega ) > 0$ as the distance between $x$ and $\\Omega$ , we 318 have ",
+        "bbox": [
+            147,
+            689,
+            823,
+            718
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1ce708bc52ea0b8c3906b3b6b1ce64c4b614b8fb780eea46213beef7937ba998.jpg",
+        "text": "$$\n\\operatorname* { l i m } _ { d ( x , \\Omega ) \\to + \\infty } \\hat { f } _ { \\infty } ( x ) = \\int \\rho ( y ) f ( y ) d ^ { d } y .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            369,
+            714,
+            627,
+            747
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "319 Finally, we consider $x _ { 0 } ~ \\in ~ \\partial \\Omega$ such that $\\rho ( x _ { 0 } ) ~ > ~ 0$ (i.e., $x _ { 0 } ~ \\in ~ \\partial \\Omega \\cap \\Omega \\}$ , and assume   \n320 that $f$ and $\\rho$ seen as functions restricted to $\\Omega$ are continuous at $x _ { 0 }$ , i.e. $\\quad \\operatorname* { l i m } _ { y \\in \\Omega \\to x _ { 0 } } \\rho ( y ) \\ =$   \n321 $\\rho ( x _ { 0 } )$ and $\\begin{array} { l } { \\operatorname* { l i m } _ { y \\in \\Omega \\to x _ { 0 } } { \\overline { { f ( y ) } } } } & { = } \\end{array} f ( x _ { 0 } )$ . We also assume that the local solid angle $\\begin{array} { r l } { \\omega _ { 0 } } & { { } = } \\end{array}$   \n322 $\\begin{array} { r } { \\operatorname* { l i m } _ { r \\to 0 } \\frac { 1 } { V _ { d } \\rho ( x _ { 0 } ) r ^ { d } } \\int _ { \\| x _ { 0 } - y \\| \\leq r } \\rho ( y ) d ^ { d } y } \\end{array}$ exists and satisfies $\\omega _ { 0 } > 0$ . Then, ",
+        "bbox": [
+            138,
+            747,
+            825,
+            809
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/edb4f0821b3f2446ccd58c3547ea4a235a2a84e45b7801e34a07d813a0cf7628.jpg",
+        "text": "$$\n\\operatorname * { l i m } _ { x \\notin \\bar { \\Omega }  x _ { 0 } } \\hat { f } _ { \\infty } ( x ) = f ( x _ { 0 } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            415,
+            809,
+            583,
+            838
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "323 Eq. (34) shows that far away from $\\Omega$ (which is possible to realize, for instance, when $\\Omega$ is bounded),   \n324 $\\hat { f } _ { \\infty } ( x )$ goes smoothly to the $\\rho$ -mean of $f$ . Moreover, Eq. (35) establishes a continuity property for   \n325 the extrapolation $\\hat { f } _ { \\infty }$ at $x _ { 0 } \\in \\partial \\Omega \\cap \\Omega$ under the stated conditions (remember that for $x \\in \\Omega ^ { \\circ }$ , we   \n326 have $\\begin{array} { r } { \\operatorname* { l i m } _ { n  + \\infty } \\mathbb { E } [ \\hat { f } ( x ) ] = f ( x ) } \\end{array}$ ; see Theorem 3.5, and in particular Eq. (23)). ",
+        "bbox": [
+            140,
+            843,
+            826,
+            916
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "References [1] Holger Wendland. Scattered data approximation, volume 17. Cambridge university press, 2004. [2] Gareth James, Daniela Witten, Trevor Hastie, and Robert Tibshirani. An introduction to statistical learning, volume 112. Springer, 2013. [3] Chiyuan Zhang, Samy Bengio, Moritz Hardt, Benjamin Recht, and Oriol Vinyals. Understanding deep learning requires rethinking generalization. In International Conference on Learning Representations, 2017. [4] Mikhail Belkin, Siyuan Ma, and Soumik Mandal. To understand deep learning we need to understand kernel learning. In Proceedings of the 35th International Conference on Machine Learning, pages 541–549, 2018. [5] Adele Cutler and Guohua Zhao. Pert-perfect random tree ensembles. Computing Science and Statistics, 33:490–497, 2001. [6] Abraham J Wyner, Matthew Olson, Justin Bleich, and David Mease. Explaining the success of adaboost and random forests as interpolating classifiers. Journal of Machine Learning Research, 18(48):1–33, 2017. [7] Mikhail Belkin, Daniel Hsu, and Partha Mitra. Overfitting or perfect fitting? risk bounds for classification and regression rules that interpolate. arXiv preprint arXiv:1806.05161, 2018. [8] Alexander Rakhlin and Xiyu Zhai. Consistency of interpolation with laplace kernels is a high-dimensional phenomenon. arXiv preprint arXiv:1812.11167, 2018. [9] Greg Ongie, Rebecca Willett, Daniel Soudry, and Nathan Srebro. A function space view of bounded norm infinite width relu nets: The multivariate case. arXiv preprint arXiv:1910.01635, 2019. [10] Mikhail Belkin, Daniel Hsu, Siyuan Ma, and Soumik Mandal. Reconciling modern machinelearning practice and the classical bias–variance trade-off. Proceedings of the National Academy of Sciences, 116(32):15849–15854, 2019. [11] Tengyuan Liang and Alexander Rakhlin. Just interpolate: Kernel\" ridgeless\" regression can generalize. arXiv preprint arXiv:1808.00387, 2018. 354 [12] Peter L Bartlett, Philip M Long, Gábor Lugosi, and Alexander Tsigler. Benign overfitting in linear regression. arXiv preprint arXiv:1906.11300, 2019. 356 [13] Andrea Montanari, Feng Ruan, Youngtak Sohn, and Jun Yan. The generalization error of max-margin linear classifiers: High-dimensional asymptotics in the overparametrized regime. arXiv preprint arXiv:1911.01544, 2019. 359 [14] Mina Karzand and Robert D Nowak. Active learning in the overparameterized and interpolating regime. arXiv preprint arXiv:1905.12782, 2019. [15] Yue Xing, Qifan Song, and Guang Cheng. Statistical optimality of interpolated nearest neighbor algorithms. arXiv preprint arXiv:1810.02814, 2018. 363 [16] Partha P. Mitra. Fitting elephants in modern machine learning by statistically consistent interpolation. Nature Machine Intelligence, 3(5):378–386, May 2021. [17] Martin Anthony and Peter L Bartlett. Neural Network Learning: Theoretical Foundations. Cambridge University Press, 1999. [18] Luc Devroye, Laszlo Györfi, and Adam Krzyzak. The hilbert kernel regression estimate. ˙ Journal of Multivariate Analysis, 65(2):209–227, 1998. [19] Elizbar A Nadaraya. On estimating regression. Theory of Probability & Its Applications, 9(1):141–142, 1964. 371 [20] GS Watson. Smooth regression analysis. Sankhya A: 26: 359-372, (50), 1964. ",
+        "bbox": [
+            145,
+            55,
+            828,
+            915
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[21] Donald Shepard. A two-dimensional interpolation function for irregularly-spaced data. In Proceedings of the 1968 23rd ACM national conference, pages 517–524. ACM, 1968. ",
+        "bbox": [
+            160,
+            92,
+            825,
+            119
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[22] Reinhard Farwig. Rate of convergence of shepard’s global interpolation formula. Mathematics of Computation, 46(174):577–590, 1986. ",
+        "bbox": [
+            165,
+            128,
+            823,
+            157
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "376 Checklist ",
+        "text_level": 1,
+        "bbox": [
+            142,
+            183,
+            254,
+            199
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            174,
+            210,
+            302,
+            224
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes] Brief statement of the primary theorems are included in the abstract together with verbal descriptions of the principal results.   \n(b) Did you describe the limitations of your work? [Yes] Theorems include limiting conditions.   \n(c) Did you discuss any potential negative societal impacts of your work? [No] The paper consists of theorems and proofs about the convergence rates of an interpolation scheme and it is hard to conceive any negative social impact of this mathematical exercise. If anything it might have a positive impact by shedding theoretical light on the interpolation of noisy data in modern ML.   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] We have read the guidelines. ",
+        "bbox": [
+            199,
+            228,
+            826,
+            387
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            166,
+            392,
+            455,
+            407
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [Yes] We state the conditions for the theorems proven.   \n(b) Did you include complete proofs of all theoretical results? [Yes] Proofs of all theorems are provided in the appendix. The relevant appendix section is noted in the corresponding sections containing the theorems. ",
+        "bbox": [
+            199,
+            411,
+            825,
+            483
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            174,
+            488,
+            354,
+            502
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [N/A] The paper is directed to proving a number of theorems.   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [N/A] We do not rely on numerical experiments for the results presented in the paper.   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [N/A]   \n(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [N/A] ",
+        "bbox": [
+            199,
+            507,
+            825,
+            654
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "06 4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            151,
+            657,
+            785,
+            672
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [N/A]   \n(b) Did you mention the license of the assets? [N/A]   \n(c) Did you include any new assets either in the supplemental material or as a URL? [N/A]   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] ",
+        "bbox": [
+            197,
+            675,
+            825,
+            784
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            163,
+            787,
+            666,
+            803
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A] There are no human subjects.   \n(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   \n(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] ",
+        "bbox": [
+            197,
+            806,
+            826,
+            895
+        ],
+        "page_idx": 10
+    }
+]

parse/train/rJl8FoRcY7/rJl8FoRcY7.md

@@ -0,0 +1,296 @@
+# DEEP GENERATIVE MODELS FOR LEARNING COHERENT LATENT REPRESENTATIONS FROM MULTIMODAL DATA
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+The application of multi-modal generative models by means of a Variational Auto Encoder (VAE) is an upcoming research topic for sensor fusion and bi-directional modality exchange. This contribution gives insights into the learned joint latent representation and shows that expressiveness and coherence are decisive properties for multi-modal datasets. Furthermore, we propose a multi-modal VAE derived from the full joint marginal log-likelihood that is able to learn the most meaningful representation for ambiguous observations. Since the properties of multi-modal sensor setups are essential for our approach but hardly available, we also propose a technique to generate correlated datasets from uni-modal ones.
+
+# 1 INTRODUCTION
+
+Auto Encoder (AE), Variational Auto Encoder (VAE), and more recently Disentangled Variational Auto Encoder ( $\beta$ -VAE) have a considerable impact on the field of data-driven leaning of generative models. Furthermore, recent investigations have shown the fruitful applicability to deep reinforcement learning (DRL) as well as bi-directionally exchange of multi-modal data. VAEs tend to encode the data into latent space features that are (ideally) linearly separable as shown by Higgins et al. (2017a). They also allow the discovery of generative joint models (e.g. Suzuki et al. (2017)), as well as zero-shot domain transfer in DRL as shown by Higgins et al. (2017b).
+
+However, a good generative model should not just generate good data and achieve a good quantitative score, but also gives a coherent and expressive latent space representation. This property is decisive for multi-modal approaches if the data shows correlation, as it is the case for every sensor setup designed for sensor fusion. With this contribution, we investigate the characteristic of the latent space as well as the quantitative features for existing multi-modal VAEs. Furthermore, we propose a novel approach to build and train a novel multi-modal VAE $( \mathbf { M } ^ { 2 } \mathbf { V } \mathbf { A } \mathbf { E } )$ which comprises the complete marginal joint log-likelihood without simplifying assumptions. As our objective is the consideration of raw multi-modal sensor data, we also propose an approach to generate correlated multi-modal datasets from available uni-modal ones. Lastly, we draw connections to in-place sensor fusion and epistemic (ambiguity-resolving) active-sensing.
+
+Section 2 comprises the related work on multi-modal VAEs. Our comprehensive approach (i.e. $\mathbf { M } ^ { 2 } \mathbf { V A E } )$ is given in Sec. 3. Furthermore, we describe multi-modal datasets as well as the generation of correlated sets in Sec. 4 which are evaluated in Sec. 5. Finally, we conclude our work in Sec. 6.
+
+# 2 RELATED WORK
+
+Variational auto encoder (VAE) combine neural networks with variational inference to allow unsupervised learning of complicated distributions according to the graphical model shown in Figure 1 (left). A $D _ { a }$ -dimensional observation $a$ is modeled in terms of a $D _ { z }$ -dimensional latent vector $z$ using a probabilistic decoder $p _ { \theta _ { \mathrm { a } } } ( z )$ with parameters $\theta$ . To generate the corresponding embedding $z$ from observation $a$ , a probabilistic encoder network with $q _ { \phi _ { \mathrm { a } } } ( z )$ is being provided which parametrizes the posterior distribution from which $z$ is sampled. The encoder and decoder, given by neural networks, are trained jointly to bring $a$ close to an $a ^ { \prime }$ under the constraint that an approximate distribution needs to be close to a prior $p ( z )$ and hence inference is basically learned during training.
+
+![](images/3bdbe14ee048385f34f6f5509401d5d87873c034b014b26b98b4566ce55a17fd.jpg)  
+Figure 1: Evolution of full uni-, bi-, and tri-modal VAEs comprising all modality permutations
+
+The specific objective of VAEs is the maximization of the marginal distribution $\begin{array} { r l } { p ( a ) } & { { } = } \end{array}$ $\textstyle { \int p _ { \theta } ( { \dot { a } } | z ) p ( z ) \operatorname { d } { \dot { a } } }$ . Because this distribution is intractable, the model is instead trained via stochastic gradient variational Bayes (SGVB) by maximizing the evidence lower bound (ELBO) $\mathcal { L }$ of the marginal log-likelihood $\log p ( a ) : = L _ { \mathrm { a } }$ as
+
+$$
+\begin{array} { r } { L _ { \mathrm { a } } \ge \mathcal L = \underbrace { - \mathrm { D } _ { \mathrm { K L } } \big ( q _ { \phi } ( z | a ) \| p ( z ) \big ) } _ { \mathrm { R e g u l a r i z a t i o n } } + \underbrace { { \mathbb E } _ { q _ { \phi } ( z | a ) } \log \bigl ( p _ { \theta } ( a | z ) \bigr ) } _ { \mathrm { R e c o n s t r u c t i o n } } . } \end{array}
+$$
+
+This approach proposed by Kingma & Welling (2013) is used in settings where only a single modality $a$ is present in order to find a latent encoding $z$ (c.f. Figure 1 (left)).
+
+In the following chapters, we give a briefly comprise related work by means of multi-modal VAEs. Further, we stress the concept of two joint multi-modal approaches to derive the later proposed variational Auto Encoder (VAE).
+
+# 2.1 MULTI-MODAL AUTO ENCODER
+
+Given a set of modalities $\mathcal { M } = \{ a , b , c , \ldots \}$ , multi-modal variants of Variational Auto Encoders (VAE) have been applied to train generative models for multi-directional reconstruction (i.e. generation of missing data) or feature extraction. Variants are conditional VAEs (CVAE) and conditional multi-modal autoencoders (CMMA), with the lack in bi-directional reconstruction (Sohn et al. (2015); Pandey & Dukkipati (2017)). BiVCCA by Wang et al. (2016) trains two VAEs together with interacting inference networks to facilitate two-way reconstruction with the lack of directly modeling the joint distribution. Models, that are derived from the variation of information (VI) with the objective to estimate the joint distribution with the capabilities of multi-directional reconstruction were recently introduced by Suzuki et al. (2017). Vedantam et al. (2017) introduce another objective for the bi-modal VAE, which they call the triplet ELBO (tVAE). Furthermore, multi-modal stacked Auto Encoders (AE) are a variant of combining the latent spaces of various AEs ( Larochelle et al. (2007); Ranzato et al. (2006)) which can also be applied to the reconstruction of missing modalities (Ngiam et al. (2011); Cadena et al. (2016)). However, while Suzuki et al. (2017) and Vedantam et al. (2017) argue that training of the full multi-modal VAE is intractable, because of the $2 ^ { | { \mathcal { M } } | } - 1$ modality subsets of inference networks, we show that training the full joint model estimates the most expressive latent embeddings.
+
+# 2.1.1 JOINT MULTI-MODAL VARIATIONAL AUTO ENCODER
+
+When more than one modality is available, e.g. $a$ and $b$ as shown in Figure 1 (mid.), the derivation of the ELBO ${ \mathcal { L } } _ { \mathrm { J } }$ for a marginal joint log-likelihood $\log p ( a ) : = L _ { \mathbf { J } }$ is straight forward:
+
+$$
+\begin{array} { r } { L _ { \textup { J } } \geq \mathcal L _ { \textup I } = \underbrace { - \textup D _ { \mathrm { K L } } ( q _ { \phi _ { \Delta } } ( z | a , b ) \| p ( z ) ) } _ { \mathrm { R e g u l a r i z a t i o n } } + \underbrace { \mathbb E _ { q _ { \phi _ { \Delta } } ( z | a , b ) } \log ( p _ { \theta _ { \mathrm { a } } } ( a | z ) ) } _ { \mathrm { R e c o n s t r u c t i o n ~ w r t ~ } , a } + \underbrace { \mathbb E _ { q _ { \phi _ { \Delta } } ( z | a , b ) } \log ( p _ { \theta _ { \mathrm { b } } } ( b | z ) ) } _ { \mathrm { R e c o n s t r u c t i o n ~ w r t ~ } , b } } \end{array}
+$$
+
+However, it is not clear how to perform inference if the dataset consists of samples lacking from modalities (e.g. for samples $i$ and $k$ : $( a _ { i } , \boldsymbol { \mathcal { O } } )$ and $( \emptyset , b _ { k } ) )$ ). Ngiam et al. (2011) propose training of a bimodal deep auto encoder using an augmented dataset with additional examples that have only a single-modality as input. We, therefore, name the resulting model of Eq. 2 joint multi-modal VAE-Zero (JMVAE-Zero).
+
+2.1.2 JOINT MULTI-MODAL VARIATIONAL AUTO ENCODER FROM VARIATION OFINFORMATION
+
+While the former approach cannot directly be applied to missing modalities, Suzuki et al. (2017) propose a joint multi-modal VAE (JMVAE) that is trained via two uni-modal encoders and a bimodal en-/decoder which share one objective function derived from the variation of information (VI) of the marginal conditional log-likelihoods $\log p ( a | b ) p ( b | a ) = : L _ { \mathrm { M } }$ by optimizing the ELBO ${ \mathcal { L } } _ { \mathrm { M } }$ :
+
+$$
+L _ { \mathrm { M } } \ge \mathcal { L } _ { \mathrm { M } } \ge \mathcal { L } _ { \mathrm { J } } - \underbrace { \mathrm { D } _ { \mathrm { K L } } \big ( q _ { \phi _ { \mathrm { a b } } } ( z | a , b ) \| q _ { \phi _ { \mathrm { b } } } ( z | b ) \big ) } _ { \mathrm { U n i m o d a l ~ P D F ~ f u t i n g ~ o f ~ e n c o d e r ~ b } } - \underbrace { \mathrm { D } _ { \mathrm { K L } } \big ( q _ { \phi _ { \mathrm { a b } } } ( z | a , b ) \| q _ { \phi _ { \mathrm { a } } } ( z | a ) \big ) } _ { \mathrm { U n i m o d a l ~ P D F ~ f i t i n g ~ o f ~ e n c o d e r ~ a ~ } }
+$$
+
+Therefore, uni-modal encoders are trained, so that their distributions $q _ { \phi _ { a } }$ and $q _ { \phi _ { b } }$ are close to a multimodal encoder $q _ { \phi _ { \mathrm { a b } } }$ in order to build a coherent posterior distribution. The introduced regularization by Suzuki et al. (2017) puts learning pressure on the uni-modal encoders just by the distributions’ shape, disregarding reconstruction capabilities and the prior $p ( z )$ . Furthermore, one can show that deriving the ELBO from the VI for a set of $\mathcal { M }$ observable modalities, always leads to an expression of the ELBO that allows only training of $\widetilde { \mathcal { M } } = \{ m | m \in \mathcal { P } ( \mathcal { M } ) , | m | = | \mathcal { M } | - 1 \}$ modality combinations. This leads to the fact that for instance in a tri-modal setup, as shown in Fig. 1 (right), one can derive three bi-modal encoders from the VI, but no uni-modal ones.
+
+# 3 MULTI-MODAL VARIATIONAL AUTO ENCODER APPROACH
+
+While the objective of Wang et al. (2016), Ngiam et al. (2011), Suzuki et al. (2017), and Vedantam et al. (2017) is to exchange modalities bi-directionally (e.g. $a  b ^ { \prime }$ ), our primary concern is twofold: First, find a meaningful posterior distribution where the sampled statistics of an encoder network allows inference about further actions. Second, find an expression to jointly train all $2 ^ { | { \mathcal { M } } | } { - } 1$ permutations of modality encoders.
+
+By successively applying logarithm and Bayes rules, we derive the ELBO for the multi-modal VAE $( \dot { \mathbf { M } } ^ { 2 } \mathbf { V } \mathbf { A } \mathbf { E } )$ as follows: First, given the independent set of observable modalities $\mathcal { M } = \{ a , b , c , \ldots \}$ , its marginal log-likelihood $\dot { \log { p ( \mathcal { M } ) } } = : \dot { L _ { \mathrm { M } ^ { 2 } } }$ is multiplied by the cardinality of the set as the neutral element $1 = | \mathcal { M } | / | \mathcal { M } |$ . Second, applying logarithm multiplication rule, the nominator is written as the argument’s exponent. Third, Bayes rule is applied to each term wrt. the remaining observable modalities to derive their conditionals. Further, we bootstrap the derivation technique in a bi- and tri-modal (c.f. tri-modal case in Sec. 6.1) case to illustrate the advantages. By excessively applying the scheme until convergence of the mathematical expression, it leads for a bi-modal set $\mathcal { M } = \{ a , b \}$ to the following result:
+
+$$
+\begin{array} { r l } & { L _ { \mathrm { M } ^ { 2 } } = 2 / 2 \log p ( a , b ) = 1 / 2 \log p ( a , b ) ^ { 2 } = 1 / 2 \log p ( a , b ) p ( a , b ) = 1 / 2 \log p ( b ) p ( a | b ) p ( b | a ) p ( a ) } \\ & { \qquad = 1 / 2 ( \log p ( a ) + \log p ( b | a ) + \log p ( a | b ) + \log p ( b ) ) = 1 / 2 ( L _ { \mathrm { a } } + L _ { \mathrm { M } } + L _ { \mathrm { b } } ) } \end{array}
+$$
+
+This term can be written as inequality wrt. each ELBO of the marginals $L _ { \mathrm { a } } , L _ { \mathrm { b } }$ and conditionals $L _ { \mathrm { M } }$ :
+
+$$
+\begin{array} { r l } & { 2 L _ { \mathsf { M } ^ { 2 } } \geq 2 \mathcal { L } _ { \mathsf { M } ^ { 2 } } = \mathcal { L } _ { \mathsf { a } } + \mathcal { L } _ { \mathsf { b } } + \mathcal { L } _ { \mathsf { M } } = } \\ & { \ - \beta _ { \mathsf { a } } \mathrm { D } _ { \mathrm { K L } } ( q _ { \phi _ { \mathsf { a } } } ( z | a ) \| p ( z ) ) + \mathbb { E } _ { q _ { \phi _ { \mathsf { a } } } ( z | a ) } \log ( p _ { \theta _ { \mathsf { a } } } ( a | z ) ) } \\ & { \ - \beta _ { \mathsf { b } } \mathrm { D } _ { \mathrm { K L } } ( q _ { \phi _ { \mathsf { b } } } ( z | b ) \| p ( z ) ) + \mathbb { E } _ { q _ { \phi _ { \mathsf { b } } } ( z | b ) } \log ( p _ { \theta _ { \mathsf { b } } } ( b | z ) ) } \\ & { \ + \mathbb { E } _ { q _ { \phi _ { \mathsf { a b } } } ( z | a , b ) } \log ( p _ { \theta _ { \mathsf { a } } } ( a | z ) ) + \mathbb { E } _ { q _ { \phi _ { \mathsf { a b } } } ( z | a , b ) } \log ( p _ { \theta _ { \mathsf { b } } } ( b | z ) ) - \beta _ { \mathsf { a b } } \mathrm { D } _ { \mathrm { K L } } ( q _ { \phi _ { \mathsf { a b } } } ( z | a , b ) \| p ( z ) ) } \\ & { \ - \ \alpha \mathrm { D } _ { \mathrm { K L } } ( q _ { \phi _ { \mathsf { a b } } } ( z | a , b ) \| q _ { \phi _ { \mathsf { a } } } ( z | a ) ) - \alpha \mathrm { D } _ { \mathrm { K L } } ( q _ { \phi _ { \mathsf { a b } } } ( z | a , b ) \| q _ { \phi _ { \mathsf { b } } } ( z | b ) ) . } \end{array}
+$$
+
+Equation 6 is substituted by all formerly derived ELBO expressions lead to the combination of the uni-modal VAEs wrt. a and b (c.f. Eq. 7 to 8) and the JMVAE comprising the VAE wrt. the joint modality ab (c.f. Eq. 9) and mutual latent space (c.f. Eq. 10). Equation 7 and 8 have the effect that their regularizers care about the uni-modal distribution to deviate not too much from the common prior while their reconstruction term shapes the underlying embedding of the mutual latent space. We further apply the concept of $\beta$ -VAE (Higgins et al. (2016; 2017a); Burgess et al. (2018)) to the regularizers via $\beta _ { * }$ and adopt the factor $\alpha$ from Suzuki et al. (2017) for the mutual regularizer.
+
+However, while $\beta$ -VAE have the property to disentangle the latent space, our main concern is the balance between the input and the latent space using a constant normalized factor $\beta _ { \mathrm { n o r m } } = \beta _ { * } D _ { * } / D _ { z }$ .
+
+If the derivation, which we leave out for the sake of brevity, is applied to the log-likelihood LM2M of a set $\mathcal { M }$ , one can show that it results into a recursive form consisting of JMVAEs’ and ${ \bf M } ^ { 2 }$ VAEs’ log-likelihood terms
+
+$$
+L _ { \mathrm { M } ^ { 2 } , \mathrm { M } } = \frac { 1 } { | \mathcal { M } | } \left( L _ { \mathrm { M } , \mathrm { M } } + \sum _ { \widetilde { m } \in \widetilde { \mathcal { M } } } L _ { \mathrm { M } ^ { 2 } _ { \widetilde { m } } } \right) \geq \frac { 1 } { | \mathcal { M } | } \left( \mathcal { L } _ { \mathrm { M } , \mathrm { M } } + \sum _ { \widetilde { m } \in \widetilde { \mathcal { M } } } \mathcal { L } _ { \mathrm { M } ^ { 2 } _ { \widetilde { m } } } \right) = : \mathcal { L } _ { \mathrm { M } ^ { 2 } , \mathrm { M } } .
+$$
+
+While the derivation of Eq. 11 is given in Sec 6.1.3, the properties are as follows:
+
+• the $\mathbf { M } ^ { 2 } \mathbf { V A E }$ consist out of $2 ^ { | { \mathcal { M } } | } - 1$ encoders and $| { \mathcal { M } } |$ decoders comprising all modality combinations   
+• while it also allows the bi-directional exchange of modalities, it further allows the setup of arbitrary modality combinations having 1 to $| { \mathcal { M } } |$ modalities   
+subsets of minor cardinality are weighted less and have a therefore minor impact in shaping the overall posterior distribution (vice versa, the major subsets dominate the shaping and the minor sets adapt to it)   
+• all encoder/decoder networks can jointly be trained using SGVB
+
+# 4 DATA SETS
+
+It is quite common in the multi-modal VAE community to model a bi-modal dataset as follows (Wang et al. (2016); Ngiam et al. (2011); Suzuki et al. (2017); Vedantam et al. (2017)): The first modality $a$ denotes the raw data and $b$ denotes the label (e.g. the digits’ images and labels as onehot vector wrt. the MNIST dataset). This is a rather artificial assumption and only sufficient when the objective is within a semi-supervised training framework. Real multi-modal data does not show this behavior as there are commonly multiple raw data inputs. Unfortunately, only complex multimodal datasets of heterogeneous sensor setups exist (Ofli et al. (2013); Udacity (2016); Kragh et al. (2017)), which makes a comprehensive evaluation for VAEs futile. On the other hand, creating own multi-modal datasets is exhaustive since training generative models either demand dense sampling or supervised signals to form a consistent latent manifold (Bengio et al. (2012)).
+
+While na¨ıve consolidation of non-coherently datasets does not meet the conditions of data continuity, as discussed later, we propose a consolidation technique by sampling from superimposed latent spaces of various uni-modal trained CVAEs in Sec. 4.1. This approach allows the generation of multi-modal datasets from distinct and disconnected uni-modal sets. Second, we propose and bi-modal mixture of Gaussians (MoG) dataset to show particular behaviors of the various VAE approaches in Sec. 4.2.
+
+# 4.1 MULTI-MODAL DATA GENERATION
+
+Perry et al. (2010) state that Hebbian learning relies on the fact that the same objects are continuously transformed to their nearest neighbor in the observable space. Higgins et al. (2016) adopted this approach to their assumptions, that this notion can be generalized within the latent manifold learning. Further, neither a coherent manifold nor a proper factorization of the latent space can be trained if these assumptions are not fulfilled by the dataset. In summary, this means that observed data has to have the property of continues transformation wrt. to their properties (e.g. position and shape of an object), such that a small deviation of the observations results in proportional deviations in the latent space. We adopt this assumption for multi-modal datasets where observations should correlate if the same quantity is observed, such that a small deviation in the common latent representation between all modalities conducts a proportional impact in all observations. This becomes an actual fundamental requirement for any multi-modal dataset, as correlation and coherence are within the objective of multi-modal sensor fusion. In the following, we propose a technique to generate new multi-modal datasets, given different uni-modal enclosed sets which meet the former conditions.
+
+A valuable property of the VAE’s learned posterior distribution is, that it matches the desired prior quite sufficiently if only a single class is observed. This characteristic can be found again in the conditional VAE (CVAE) Kingma et al. (2014); Sohn et al. (2015) as it’s training is supported by the ground truth labels of the observations. Thus, it actually builds non-related posterior distribution for each class label, where every distribution matches a given prior. Furthermore, we adopt the idea of $\beta$ -VAE Higgins et al. (2017b) which learns disentangled and factorized latent representations. Combining the properties of both advantages allows the superimposing of latent manifolds from various uni-modal encoders as shown in Fig. 2 (Top-Right). Now, latent samples can be drawn from the posterior to operate all CVAE encoders, with the desired label, to generate continues multi-modal data.
+
+To test the approach we consolidate MNIST (LeCun Yann et al. (1998)) and fashion-MNIST (Xiao et al. (2017)) to an entangled-MNIST (e-MNIST) set by sampling from the prior (i.e. $z \sim \mathcal { N } ( 0 , \mathbf { I } ) )$ to generate observation tuples from the corresponding encoder networks $p _ { \theta _ { a } } ( a | z , C )$ and $p _ { \theta _ { b } } ( b | z , C )$ with class label $C$ . The network architecture is explained in Sec. 3. To avoid artifacts, only samples from within $2 \sigma$ of the prior are obtained.
+
+Furthermore, we train a bi-modal JMVAE on the newly generated data to depict properties of the different datasets. We are aware of the fact that consolidation of uni-modal datasets cannot be achieved easily since continuity is hardly measurable. Therefore, na¨ıve consolidation results in a mixed dataset (i.e. mixed-MNIST) as shown in Fig. 2. To mimic this behavior and to achieve a fair comparison of the ELBO, we shuffle the generated fashion-MNIST per class label of e-MNIST to generate an equivalent mixed-e-MNIST (me-MNIST) set.
+
+As shown in Fig. 2 (bottom), the JMVAE’s latent space reveals that for m-MNIST single clusters share the same mean as the best representative of a single label, but the variance of any uni-modal trained encoder remains orthogonal. Thus, the continuity in the observations does not correlate with each other by any means. On the other hand, the e-MNIST set with continues samples shows the desired behavior of multi-modal datasets as the JMVAE trains a coherent distribution for all uniand multi-modal encoders. These observations show that our proposed approach for generating new entangled datasets meet the formulated requirements of multi-modal datasets.
+
+# 4.2 MOG-EXAMPLE
+
+We investigate a Mixture-of-Gaussians (MoG) distribution, as depicted in Fig. 3, as bi-modal observations to mimic the output of e.g. feature extractors or classifiers. While they commonly already provide linear separable observations, we focus on ambiguity resolving properties of the VAE in particular.
+
+The bi-modal $( a , b )$ observations of Mixture-of-Gaussians have ten classes $( 0 , \ldots , 9 )$ each. $a$ ’s observations are organized on a grid where (5,6,7) and (0,8) result in ambiguous observations by sharing the same mean. $b$ ’s observations are organized on a circle where (0,9) have ambiguous mean values.
+
+This rather artificial experiment has the purpose to depict and evaluate ambiguous resolving properties of the VAEs. However, data of multi-modal sensor setups for complementary fusion show similar behavior, as various modalities are rectified to achieve a complete view of the scene (e.g. vision and grope to rectify objects). In that case, various dependencies of the generative process, given the class labels as factorized latent state representation $\boldsymbol { z } = ( z _ { 0 } , \ldots , z _ { 9 } )$ , are possible. This is mimicked by the MoG-Experiment, in a simplified assumption, as: $p ( a , b | z )$ , $p ( a | z _ { 1 } , \ldots , z _ { 4 } , z _ { 9 } )$ , and $p ( b | z _ { 1 } , \dots , z _ { 8 } )$ .
+
+# 5 EXPERIMENTS
+
+We apply the datasets explained in Sec. 4 to test and depict the capabilities of the $\mathbf { M } ^ { 2 } \mathbf { V } \mathbf { A } \mathbf { E }$ . First, we investigate the MoG data comprehensively. Second, we evaluate the ELBO of various approaches to the e-MNIST dataset. The VAEs are compared qualitatively, by visualizing the latent space, and quantitatively by performing lower bound tests $\mathcal { L } _ { \widetilde { \mathcal { M } } }$ for every subset ${ \widetilde { \mathcal { M } } } \subseteq { \mathcal { M } }$ wrt. to the decoding
+
+![](images/3fde56fef4ef0e262a8c7a57e4df4fa4876cb81377bafb36d490b67353ceb3bc.jpg)  
+Figure 2: Top-Left: Depiction of na¨ıve mixed MNIST (m-MNIST) vs. proposed entangled MNIST (e-MNIST). m-MNIST is pairwise plotted with the closest match of MNIST digits according to the mean-squared-error. The corresponding fashion-MNIST samples show no continuity nor correlation (despite the intended class correlation). e-MNIST shows the desired entanglement for changes of a single latent space factor. Top-Right: Latent space of the CVAE for the modalities $a$ (MNIST) and $b$ (fashion-MNIST). Bottom: Latent space of a trained JMVAE (c.f. Sec. 6.1.4). m-MNIST shows clear orthogonalization between modalities of the same class and segregation between classes (colorization is wrt. the CVAE legend). e-MNIST shows a coherently learned latent space between the uni- and multi-modal encoders. Thus, the JMVAE learns the correlation inside the dataset sufficiently $( \mathcal { L } _ { a , b | \mathrm { m e - M N I S T } } = - 2 0 4 . 4 8$ vs. $\mathcal { L } _ { a , b | \mathrm { e - M N I S T } } = - 1 9 9 . 2 3 )$ .
+
+![](images/a7223c8789eeaabca99004d5056ba2ab10424657bc3719f8d4f7ef0b1004cc14.jpg)  
+Figure 3: MoG input signals with for the modalities $a$ and $b$ . The depicted observations are sampled for the corresponding modality for each class.
+
+of all modalities $p _ { \theta _ { \mathcal { M } } }$
+
+$$
+\mathcal { L } _ { \widetilde { M } } = \mathbb { E } _ { q _ { \phi _ { \widetilde { M } } } ( z | \widetilde { M } ) } \log \frac { p _ { \theta _ { \mathcal { M } } } ( \mathcal { M } | z ) p ( z ) } { q _ { \phi _ { \widetilde { M } } } \Big ( z | \widetilde { \mathcal { M } } \Big ) }
+$$
+
+with $p ( z ) = \mathcal { N } ( z ; \mathbf { 0 } , \mathbf { I } )$ . All VAE architectures can be found in Sec. 6.1.4.
+
+![](images/6c7f440aa21a2e2bfe8569e53318502b9458bb7b263a152ca1eb5d56572af077.jpg)  
+Figure 4: Latent space embeddings of the bi-modal MoG dataset by the three encoder networks of the $\mathbf { M } ^ { 2 } \mathbf { V } \mathbf { A } \mathbf { E }$ . Classes and ELBO colorization is depicted for various parameter settings of $\beta _ { * }$ and $\alpha$ .
+
+# 5.1 MOG-EXPERIMENT
+
+We evaluate the latent space with the premise in mind, that a good generative model should not just generate good data but also gives a good latent representation $z$ .
+
+# 5.1.1 PARAMETRIZATION
+
+We first investigate the impact of the parameter set $( \beta _ { * } , \alpha )$ on the $\mathbf { M } ^ { 2 } \mathbf { V } \mathbf { A } \mathbf { E }$ to find a latent space representation, which suits our needs to learn actions from it.
+
+As the $\alpha$ parameter controls the mutual connection of all encoders in latent space, we found that a direct connection (i.e. $\alpha = 1 .$ ) puts too much learning pressure on matching the mutual latent distributions between uni- and multi-modal encoders. Thus, classes which should be separated in the multi-modal latent space collapse to the mean distributions of the uni-modal encoders. For $\alpha \lessapprox 1 0 ^ { - 2 }$ , the encoders are able to find an expressive latent space distribution by means of separable collapsed classes of uni-modal encoders, and expanded classes of multi-modal around it (c.f. Fig. 4 top/left).
+
+By the findings of Higgins et al. (2017b), high $\beta$ values result in highly entangled factors in latent space whereas small normalized $\beta _ { \mathrm { n o r m } } \lessapprox 1 0 ^ { - 2 }$ show pretty robust disentanglement in all their test cases. The impact of $\beta$ shows similar behavior on the $\mathbf { M } ^ { 2 } \mathbf { V A E }$ and thus, we chose small $\beta$ values of $\beta _ { \mathrm { { n o r m } } } = 1 0 ^ { - 2 }$ to relax the learning pressure caused by the prior. While the over optimization wrt. to the prior leads to a fuzzy generation of data $p ( \mathcal { M } | z )$ and collapse in latent space, high relaxation $( \beta _ { \mathrm { { n o r m } } } \ll 1 0 ^ { - 3 } ,$ ) causes loss of expressiveness between uni- and multi-modal encoding of a single class by means of the difference in the ELBO.
+
+It is worth noticing, that diverging $\beta$ parameters between multi- and uni-modal regularization (e.g. $\beta _ { \mathrm { a b } } \ll \beta _ { \mathrm { a } }$ or vice versa) results in lower ELBOs, but for the sake of expressiveness of latent embedding and the ELBO between encoders’ embeddings. We argue that learning pressure should be applied equally to all encoders so that they experience a similar learning impact.
+
+Another observation results from the fact, that the reconstruction loss of the $\mathbf { M } ^ { 2 } \mathbf { V } \mathbf { A } \mathbf { E }$ ’s objective causes learning of mean representatives of classes in the observation space. This causes the artifact, that if for instance three classes exist in the output space, where one represents the overall mean, and an uni-modal encoder only sees the collapse of classes to that particular mean value, the latent encoding of this uni-modal encoder will collapse to the same mean as well. However, while it is not longer separable (not even non-linearly) in latent space by its mean value, the ELBO for the observation drives up and gives, therefore, evidence about the embedding quality. This insight might be fruitful in terms of epistemic (ambiguity-resolving) tasks, where for instance an unsupervised reinforcement learning approach could use the ELBO as a signal to learn epistemic exploration.
+
+# 5.1.2 COMPARISION
+
+![](images/3ca44be7de39faa13d9ece6ac3a693d3b122b7582779c1af651ee299e04ecff7.jpg)  
+Figure 5: Bi-modal latent space embeddings by the three multi-modal VAEs JMVAE-Zero (left), tVAE (mid.), and ${ \bf M } ^ { 2 }$ VAE (right). The bi-modal input signals are an arrangement of the MoG distributions with ambiguities wrt. their mean values. The ELBO (colorization wrt. Figure 4) is estimated by Eq. 12 and is depicted qualitatively, as it can only be compared between encoders of the same approach.
+
+Comparing the three approaches to estimate the multi-modal marginal log-likelihood by maximizing the ELBO, one can see from Fig. 5 that the most coherent latent space distribution was learned by the proposed $\mathbf { M } ^ { 2 } \mathbf { V } \mathbf { A } \mathbf { E }$ .
+
+While the JMVAE-Zero learned similarities between $q _ { \phi _ { \mathrm { a b } } }$ and $q _ { \phi _ { \mathrm { a } } }$ , it learned a complete new embedding for the classes (1,2) with $q _ { \phi _ { \mathrm { b } } }$ (denoted by $( \mathbb { S } )$ ). Furthermore, the ELBO per embedding allows no conclusion between the embeddings of the various encoders.
+
+The tVAE founds a much more coherent embedding between the encoders. This was achieved by the fact, that first the full multi-modal VAE, consisting out of the encoder $q _ { \phi _ { \mathrm { a b } } }$ and two decoder $p _ { \theta _ { \mathrm { a } } }$ and $p _ { \theta _ { \mathrm { b } } }$ , was trained. Second, the decoder weights are pinned to train the remaining uni-modal networks which enforces coherence. However, the ELBO per embedding also does not allow any direct conclusion between the embeddings of the various encoders. This is depicted by $( \sim )$ , where the multi-modal encoder $q _ { \phi _ { \mathrm { a b } } }$ produces embeddings of higher energy than these of the uni-modal ones. This can happen as there is no regularizer which enforces the variational distribution of the encoders to match each other and thus, the KL-divergence may differ between the models for similar encodings.
+
+The $\mathbf { M } ^ { 2 } \mathbf { V } \mathbf { A } \mathbf { E }$ , on the other hand, enforces the encoders inherently to approximate the same posterior distribution which can be seen by the strong coherence between all embeddings. Furthermore, classes which are separated in the multi-modal latent embedding collapse to the mean values in the uni-modal ones as denoted by $( + )$ and $( - )$ . This behavior is also rendered by the ELBO. As the $\mathbf { M } ^ { 2 } \mathbf { V } \mathbf { A } \mathbf { E }$ makes ambiguous embeddings, the reconstruction loss drives up (c.f. $( * )$ and $( / ) ,$ ).
+
+The embeddings also show an interesting fact about the class (0): As this class is only ambiguously detectable in the uni-modal case, all VAEs learn a linear separable and therefore unambiguous embedding if both modalities make an observation of this class (denoted by $( - )$ for the $\mathbf { M } ^ { 2 } \mathbf { V } \mathbf { A } \mathbf { E } )$ .
+
+# 5.2 IN-PLACE SENSOR FUSION
+
+Further, we introduce the concept of in-place sensor fusion using multi-modal VAEs. This approach is applicable in distributed active-sensing tasks where the latent space representation $z$ of observations $\mathcal { M } ^ { \prime }$ (i.e. an object or point of interest was observed by a set of modalities) can be interpreted as inverse sensor model (c.f. Thrun et al. (2005)). This compressed information can be efficiently transmitted between all sensing agents and also be updated as follows: $z$ can be unfolded to the original observation using the VAE’s decoder networks and combined with any new observation $m$ to update the information in-place $z \to z ^ { * }$ via
+
+$$
+q _ { \phi _ { m \perp } M ^ { \prime } } ( z ^ { * } | m , \mathcal { M } ^ { \prime } ) \quad \mathrm { { w i t h } } \quad \mathcal { M } ^ { \prime } = \bigcup _ { m ^ { \prime } i n \mathcal { M } ^ { \prime } } p _ { \theta _ { m ^ { \prime } } } ( m ^ { \prime } | z ) .
+$$
+
+However, a necessary requirement of Eq. 13 is that auto re-encoding (i.e. $z  z$ via $q _ { \phi _ { \mathcal { M ^ { \prime } } } } ( z | \mathcal { M } ^ { \prime } ) )$ does not manipulate the information comprised by $z$ in an unrecoverable way (e.g. label-switching). Thus, we assume that VAEs tend to have a natural denoising characteristic (despite the explicit denoising Auto Encoders) which should re-encode any $z$ in a better version of its own by means of the reconstruction loss wrt. $z$ . This behavior is shown in Fig. 6 where we underlay the latent representation with the reconstruction loss of every particular $z$ . One can see the learned discrimination of the latent space by means of high entropy separating the clusters vicinity. Furthermore, initial $z$ values are auto re-encoded which draw the trajectories along their path in latent space. The observable properties of the VAE are that every seed converges to a fixed-point while performing descending steps on the latent space manifold. However, this statement is only valid in general for the proposed $\mathbf { M } ^ { 2 } \mathrm { V A E }$ , as the JMVAE-Zero and tVAE learn no or only similar coherent latent spaces between the encoder networks. Thus, seeds may be attracted by wrong attractors which makes these approach not sufficient for in-place sensor fusion.
+
+![](images/cd3afdd90f3c152430a31819ed88e5a41c5c82109378a3c0c2f71c49657f00d2.jpg)  
+Figure 6: From top to bottom: JMVAE-Zero, tVAE, and ${ \bf M } ^ { 2 }$ VAE. Left: Latent space representation with class colorization. Right: Corresponding colorization of the latent space for every $z$ obtained by auto re-encoding. White dots denote randomly drawn seeds which auto re-encoding steps are represented by the black trajectory. See Fig. 5 for legends.
+
+# 5.3 E-MNIST EVALUATION
+
+For this experiment, we estimated the ELBO by Eq. 12 to evaluate the performance of models JMVAE-Zero, tVAE, and $\mathbf { M } ^ { 2 } \mathbf { V } \mathbf { A } \mathbf { E }$ . We chose the model wrt. to the evaluation in Fig. 4 with $\beta _ { \mathrm { n o r m } } ~ = ~ 0 . 0 1$ which is $\beta _ { * } \approx 4$ for the given MNIST image dimension of $D _ { a } \ = \ | | \bar { ( 2 8 , 2 8 , 1 ) } | |$ and $D _ { z } = 2$ . However, Tbl. 1 shows quantitatively and Fig. 7 depicts qualitatively that the proposed $\mathbf { M } ^ { 2 } \mathbf { V } \mathbf { A } \mathbf { E }$ reaches the highest ELBO value, as well as it learns the most expressive latent space distribution. Furthermore, by sampling from the latent space for data generation, the $\mathbf { M } ^ { 2 } \mathbf { V } \mathbf { A } \mathbf { E }$ reveals crisp reconstructions in comparison to the other approaches.
+
+Table 1: Evidence lower bound test for uni- and multi-modal setups of the VAEs (higher is better).   
+
+<table><tr><td colspan="3">M²VAE</td><td colspan="3">tVAE</td><td colspan="3">JMVAE-Zero</td></tr><tr><td>La,b</td><td>La</td><td>Lb</td><td>La.b</td><td>La</td><td>Lb</td><td>La,b</td><td>La</td><td>Lb</td></tr><tr><td>-10.75</td><td>-10.91</td><td>-16.01</td><td>-23.6</td><td>-101.28</td><td>-88.75</td><td>-24.19</td><td>-131.05</td><td>-99.71</td></tr></table>
+
+![](images/42bb0c94e113d1a4888761a38cf9b5cf7d34394b3ad721f22fd9ce8a0c19353f.jpg)  
+Figure 7: From top to bottom: JMVAE-Zero, tVAE, and $\mathbf { M } ^ { 2 } \mathbf { V } \mathbf { A } \mathbf { E }$ . Left: Latent space representation with class colorization. Right: Reconstruction from latent space by applying the corresponding decoder networks. $z$ is sampled linearly within $2 \sigma$ of the prior for all figures.
+
+# 6 CONCLUSION
+
+This work presents a novel multi-modal Variational Auto Encoder which is derived from the complete marginal joint log-likelihood. We showed that this expression can jointly be trained on an Mixture-of-Gaussian dataset with ambiguous observations, as well as on a complex dataset derived from MNIST and fashion-MNIST. Furthermore, we formulated requirements and characteristics for multi-modal data for sensor fusion and derived a technique to learn new datasets, namely the proposed entangled-MNIST, which suffice these requirements. Lastly, we developed the idea of in-place sensor fusion in distributed, active sensing scenarios and formulated the requirements, by means of auto re-encoding, to VAEs. This revealed the properties of VAEs, that they tend to denoise the observable data which leads to an attractor behavior in latent space. However, we performed all qualitative evaluations of the latent space with the premise in mind, that a good generative model should not just generate good data but also gives a good latent representation. This does also correlate with the quantitative behaviors, as our proposed model achieved the highest ELBO values. Future work will concentrate on the integration of the ambiguous resolving characteristics to an epistemic-exploration scenario.
+
+# ACKNOWLEDGMENTS
+
+This research was supported by ’CITEC’ (EXC 277) at Bielefeld University and the Federal Ministry of Education and Research (57388272). The responsibility for the content of this publication lies with the author.
+
+# REFERENCES
+
+Yoshua Bengio, Aaron Courville, and Pascal Vincent. Representation Learning: A Review and New Perspectives. (1993):1–30, 2012. ISSN 15324435. doi: 10.1145/1756006.1756025. URL http://arxiv.org/abs/1206.5538.   
+Christopher P. Burgess, Irina Higgins, Arka Pal, Loic Matthey, Nick Watters, Guillaume Desjardins, and Alexander Lerchner. Understanding disentangling in $\beta$ -VAE. (Nips), 2018. URL http: //arxiv.org/abs/1804.03599.   
+Cesar Cadena, Anthony Dick, and Ian D Reid. Multi-modal Auto-Encoders as Joint Estimators for Robotics Scene Understanding. In Nancy Amato, Siddhartha Srinivasa, Nora Ayanian, and Scott Kiundersma (eds.), Robotics: Science and System XIII, Cambridge, 2016. MIT Press. doi: 10.15607/RSS.2016.XII.041.   
+Irina Higgins, Loic Matthey, Xavier Glorot, Arka Pal, Benigno Uria, Charles Blundell, Shakir Mohamed, and Alexander Lerchner. Early Visual Concept Learning with Unsupervised Deep Learning. 2016. URL http://arxiv.org/abs/1606.05579.   
+Irina Higgins, Loic Matthey, Arka Pal, Christopher Burgess, Xavier Glorot, Matthew Botvinick, Shakir Mohamed, Alexander Lerchner, and Google Deepmind. beta-VAE: Learning Basic Visual Concepts with a Constrained Variational Framework. Iclr, (July):1–13, 2017a. URL https: //openreview.net/forum?id $=$ Sy2fzU9gl.   
+Irina Higgins, Arka Pal, Andrei A. Rusu, Loic Matthey, Christopher P Burgess, Alexander Pritzel, Matthew Botvinick, Charles Blundell, and Alexander Lerchner. DARLA: Improving Zero-Shot Transfer in Reinforcement Learning. 2017b. ISSN 1938-7228. URL http://arxiv.org/ abs/1707.08475.   
+Diederik P Kingma and Max Welling. Auto-Encoding Variational Bayes. CoRR, abs/1312.6, 2013. URL http://arxiv.org/abs/1312.6114.   
+Diederik P. Kingma, Danilo J. Rezende, Shakir Mohamed, and Max Welling. Semi-Supervised Learning with Deep Generative Models. pp. 1–9, 2014. ISSN 10495258. URL http: //arxiv.org/abs/1406.5298.   
+Mikkel Fly Kragh, Peter Christiansen, Morten Stigaard Laursen, Morten Larsen, Kim Arild Steen, Ole Green, Henrik Karstoft, and Rasmus Nyholm Jørgensen. FieldSAFE: Dataset for Obstacle Detection in Agriculture. Sensors, 17(11), 2017.   
+Hugo Larochelle, Dumitru Erhan, Aaron Courville, James Bergstra, and Yoshua Bengio. An Empirical Evaluation of Deep Architectures on Problems with Many Factors of Variation. In Proceedings of the 24th International Conference on Machine Learning, ICML ’07, pp. 473–480, New York, NY, USA, 2007. ACM. ISBN 978-1-59593-793-3. doi: 10.1145/1273496.1273556. URL http://doi.acm.org/10.1145/1273496.1273556.   
+LeCun Yann, Cortes Corinna, and Burges Christopher. THE MNIST DATABASE of handwritten digits. The Courant Institute of Mathematical Sciences, 1998.   
+Jiquan Ngiam, Aditya Khosla, Mingyu Kim, Juhan Nam, Honglak Lee, and Andrew Y Ng. Multimodal Deep Learning. Proceedings of The 28th International Conference on Machine Learning (ICML), 2011. ISSN 9781450306195. doi: 10.1145/2647868.2654931.
+
+Ferda Ofli, Rizwan Chaudhry, Gregorij Kurillo, Rene Vidal, and Ruzena Bajcsy. Berkeley MHAD: A comprehensive Multimodal Human Action Database. In Proceedings of IEEE Workshop on Applications of Computer Vision, 2013. ISBN 9781467350532. doi: 10.1109/WACV.2013.6474999.
+
+Gaurav Pandey and Ambedkar Dukkipati. Variational methods for conditional multimodal deep learning. Proceedings of the International Joint Conference on Neural Networks, 2017-May: 308–315, 2017. doi: 10.1109/IJCNN.2017.7965870.
+
+G. Perry, E. T. Rolls, and S. M. Stringer. Continuous transformation learning of translation invariant representations. Experimental Brain Research, 204(2):255–270, 2010. ISSN 00144819. doi: 10.1007/s00221-010-2309-0.
+
+Marc’Aurelio Ranzato, Christopher Poultney, Sumit Chopra, and Yann LeCun. Efficient Learning of Sparse Representations with an Energy-based Model. In Proceedings of the 19th International Conference on Neural Information Processing Systems, NIPS’06, pp. 1137–1144, Cambridge, MA, USA, 2006. MIT Press. URL http://dl.acm.org/citation.cfm?id= 2976456.2976599.
+
+Kihyuk Sohn, Honglak Lee, and Xinchen Yan. Learning Structured Output Representation using Deep Conditional Generative Models. In C Cortes, N D Lawrence, D D Lee, M Sugiyama, and R Garnett (eds.), Advances in Neural Information Processing Systems 28, pp. 3483–3491. Curran Associates, Inc., 2015.
+
+Masahiro Suzuki, Kotaro Nakayama, and Yutaka Matsuo. Joint multimodal learning with deep generative models. pp. 1–12, 2017.
+
+Sebastian Thrun, Wolfram Burgard, and Dieter Fox. Probabilistic Robotics. MIT Press, Cambridge, Mass., 2005. ISBN 9780262201629.
+
+Udacity. Self-Driving Car: Annotated Driving Dataset, 2016. URL https://github.com/ udacity/self-driving-car/tree/master/annotations.
+
+Ramakrishna Vedantam, Ian Fischer, Jonathan Huang, and Kevin Murphy. Generative Models of Visually Grounded Imagination. pp. 1–21, 2017. URL http://arxiv.org/abs/1705. 10762.
+
+Weiran Wang, Xinchen Yan, Honglak Lee, and Karen Livescu. Deep Variational Canonical Correlation Analysis. 1, 2016. URL http://arxiv.org/abs/1610.03454.
+
+Han Xiao, Kashif Rasul, and Roland Vollgraf. Fashion-MNIST: a Novel Image Dataset for Benchmarking Machine Learning Algorithms. pp. 1–6, 2017. URL http://arxiv.org/abs/ 1708.07747.
+
+# APPENDIX
+
+# 6.1 EXTENSION TO THREE MODALITIES
+
+The proposed, as well as approach by Suzuki et al. (2017), can be extended to multiple modalities $\mathcal { M } = \{ a , b , c \}$ . The conditional marginal log-likelihood of $a$ can be written as
+
+$$
+\begin{array} { r } { \log p ( a | b , c ) { = } \mathcal { L } _ { \widetilde { \mathrm { M } } _ { \mathrm { a } } } { + } \mathrm { D } _ { \mathrm { K L } } ( q ( z | \mathcal { M } ) \Vert p ( z | \mathcal { M } ) ) { \geq } \mathcal { L } _ { \widetilde { \mathrm { M } } _ { \mathrm { a } } } . } \end{array}
+$$
+
+# 6.1.1 JMVAE FOR THREE MODALITIES
+
+The VI between a set of distributions $\mathcal { M }$ can be written as $\begin{array} { r } { - \mathbb { E } _ { p ( \mathcal { M } ) } \sum _ { m \in \mathcal { M } } \log p ( m | \mathcal { M } \setminus m ) } \end{array}$ , which leads to an expression of maximizing the ELBO of negative VI (c.f. Suzuki et al. (2017)). Following this approach, the log-likelihood $L _ { 3 \mathrm { M } }$ can be expressed by the ELBOs, by utilizing Eq. 14, of their conditionals and KL divergence:
+
+$$
+\begin{array} { r l } & { L _ { \mathrm { 3 M } } = \log p ( a | b , c ) + \log ( p ( b | a , c ) ) + \log ( p ( c | b , c ) ) } \\ & { \qquad \geq \mathcal { L } _ { \widetilde { \mathrm { M } } _ { \mathrm { a } } } + \mathcal { L } _ { \widetilde { \mathrm { M } } _ { \mathrm { b } } } + \mathcal { L } _ { \widetilde { \mathrm { M } } _ { \mathrm { c } } } } \\ & { \qquad \geq \mathcal { L } _ { \widetilde { \mathrm { J } } } - \mathrm { D } _ { \mathrm { K L } } ( q ( z | a , b , c ) \| p ( z | b , c ) ) } \\ & { \qquad - \mathrm { D } _ { \mathrm { K L } } ( q ( z | a , b , c ) \| p ( z | a , c ) ) - \mathrm { D } _ { \mathrm { K L } } ( q ( z | a , b , c ) \| p ( z | b , c ) ) } \end{array}
+$$
+
+with $\mathcal { L } _ { \widetilde { \mathrm { J } } }$ being the joint ELBO of a joint probability $p ( \mathcal { M } )$ which expression is analog to Eq. 2.
+
+# 6.1.2 $\mathbf { M } ^ { 2 } \mathbf { V } \mathbf { A } \mathbf { E }$ FOR THREE MODALITIES
+
+Applying the proposed scheme to the joint log-likelihood of three modalities results in the following expression:
+
+$$
+\begin{array} { r l } & { L _ { 3 \mathrm { M } ^ { 2 } } } \\ & { = 3 / 3 \log p ( a , b , c ) = 1 / 3 \log p ( a , b , c ) ^ { 3 } } \\ & { = 3 / 3 \log p ( a , b , c ) p ( a , b , c ) p ( a , b , c ) } \\ & { = 1 / 3 \log p ( a , b ) p ( b , c ) p ( a , c ) p ( a | b , c ) p ( b | a , c ) p ( c | a , b ) } \\ & { = 1 / 3 ( \log ( p ( a , b ) ) + \log ( p ( b , c ) ) + \log ( p ( a , c ) ) } \\ & { \quad + \log p ( a | b , c ) + \log p ( b | a , c ) + \log p ( c | a , b ) ) } \\ & { = 1 / 3 ( 2 / 2 ( \log p ( a , b ) + \log p ( b , c ) + \log p ( a , c ) ) + L _ { 3 \mathrm { M } } ) } \\ & { = 1 / 6 \big ( \log p ( a , b ) ^ { 2 } + \log p ( b , c ) ^ { 2 } + \log p ( a , c ) ^ { 2 } \big ) + L _ { 3 \mathrm { M } / 3 } } \\ & { = 1 / 6 \big ( L _ { \mathrm { M } ^ { 2 } \mathrm { ~ * } } + L _ { \mathrm { M } _ { \mathrm { M } ^ { 2 } \mathrm { s } } } + L _ { \mathrm { M } ^ { 2 } \mathrm { s } } \big ) + 1 / 3 L _ { 3 \mathrm { M } } } \end{array}
+$$
+
+From here on, one can substitute all log-likelihoods given the expressions in Sec. 3 and ??, to derive the ELBO L3M2 .
+
+# 6.1.3 ${ \bf M } ^ { 2 }$ VAE DERIVATION
+
+$$
+\begin{array} { r l } & { L _ { \mathrm { M } ^ { 2 } , \boldsymbol { \mathcal { M } } } = \log p ( \boldsymbol { \mathcal { M } } ) \stackrel { \mathrm { m u l } ~ , 1 } { = } \stackrel { | \mathcal { M } | / | \mathcal { M } | } { | \mathcal { M } | } \log p ( \boldsymbol { \mathcal { M } } ) \stackrel { \log . \mathrm { m u l } . } { = } 1 / | \mathcal { M } | \log p ( \boldsymbol { \mathcal { M } } ) \stackrel { | \mathcal { M } | } { = } } \\ & { \stackrel { \mathrm { B a y e s } ~ } { = } 1 / | \mathcal { M } | \displaystyle \sum _ { m \in \mathcal { M } } \log p ( \boldsymbol { \mathcal { M } } \setminus m ) p ( m | \mathcal { M } \setminus m ) } \\ & { \stackrel { \mathrm { l o g . a d d } } { = } 1 / | \mathcal { M } | \displaystyle \sum _ { m \in \mathcal { M } } \log p ( \boldsymbol { \mathcal { M } } \setminus m ) + \log p ( m | \mathcal { M } \setminus m ) } \end{array}
+$$
+
+The expression $\begin{array} { r } { \sum _ { m \in \mathcal { M } } \log p ( m | \mathcal { M } \setminus m ) } \end{array}$ is the general form of the marginal log-likelihood for the variation of information (VI), as introduced by Suzuki et al. (2017) for the JMVAE, for any set $\mathcal { M }$ . Thus, it can be directly substituted with $L _ { \mathrm { M } _ { \mathcal { M } } }$ . The expression $\textstyle \sum _ { m \in { \mathcal { M } } } \log p ( { \mathcal { M } } \setminus m )$ is the combination of all joint log-likelihoods of the subsets of $\mathcal { M }$ which have one less element. Therefore, this term can be rewritten as
+
+$$
+\sum _ { m \in \mathcal { M } } \log p ( \mathcal { M } \setminus m ) = \sum _ { \widetilde { m } \in \widetilde { \mathcal { M } } } \log p ( \widetilde { m } )
+$$
+
+with $\widetilde { \mathcal { M } } = \{ m | m \in \mathcal { P } ( \mathcal { M } ) , | m | = | \mathcal { M } | - 1 \}$ Finally, $\log p ( \widetilde { m } )$ can be substituted by $L _ { \mathrm { M } ^ { 2 } \widetilde { m } }$ without loss of generality. However, it is worth noticing that substitution stops at the end of recursion and therefore, all final expressions $\log p ( \widetilde { m } ) \forall | \widetilde { m } | \equiv 1$ remain. $\boxed { \begin{array} { r l } \end{array} }$
+
+# 6.1.4 NETWORK ARCHITECTURE
+
+We designed all VAEs such that the latent space prior is given by a Gaussian with unit variance. Furthermore, all VAEs sample from a Gaussian variational distribution that is parametrized by the encoder networks. A summary of all architectures used in this paper can be seen in Tbl. 2. The reconstruction loss for calculating the evidence lower bound was performed by binary cross-entropy (BCE) for the e-MNIST and root-mean-squared error (RMS) for the MoG experiment.
+
+Furthermore, the CVAE for training the e-MNIST dataset is designed as depicted in Tbl. 3.
+
+Table 2: Various VAE architectures and optimizers for the e-MNIST and MoG experiments. $\mathrm { { u m / m m } }$ stand for uni- and multi-modal while fc refers to fully-connected layers.   
+
+<table><tr><td>Issue</td><td>VAE</td><td>Optimizer</td><td colspan="2">VAEarchitecture</td><td></td></tr><tr><td>e-MNIST</td><td>JMVAE-Z.</td><td>adam</td><td>encoder decoder</td><td>fc 2x784-2x128-2x64-concat-64-2 (ReLU) fc 2x64-2x128-2x786 (tanh)</td><td rowspan="3"></td></tr><tr><td>e-MNIST</td><td>tVAE</td><td>adam</td><td>um enc. mm enc. decoder</td><td>fc 784-128-64-2 (ReLU) fc 2x784-2x128-2x64-concat-64-2 (ReLU) fc 2x64-2x128-2x786 (tanh)</td></tr><tr><td>e-MNIST</td><td>M²VAE</td><td>adam</td><td>um enc. mm enc. decoder</td><td>fc 784-128-64-2 (ReLU) fc 2x784-2x128-2x64-concat-64-2 (ReLU) fc 2x64-2x128-2x786 (tanh)</td></tr><tr><td>MoG</td><td>JMVAE-Z.</td><td>rmsprop</td><td>encoder decoder</td><td>fc 2x2-2x128-concat-64-2 (ReLU) fc 2x128-2x2 (tanh)</td><td rowspan="2"></td></tr><tr><td>MoG</td><td>tVAE</td><td>rmsprop</td><td>um enc. mm enc. decoder</td><td>fc 2x2-2x128-2x2 (ReLU) fc 2x2-2x128-concat-64-2 (ReLU) fc 2x128-2x2 (tanh)</td></tr><tr><td>MoG</td><td>M²VAE</td><td>rmsprop</td><td>um enc. mm enc. decoder</td><td></td><td>fc 2-128-2 (ReLU) fc 2x2-2x128-concat-64-2 (ReLU) fc 2x128-2x2 (tanh)</td></tr></table>
+
+Table 3: CVAE architecture for each dataset MNIST and fashion-MNIST. The label as one-hotvector is concatenated after the convolution layers and fed into the fully-connected (fc) layers. For convolutional architectures the numbers in parenthesis indicate strides, while padding is always same.   
+
+<table><tr><td>encoder decoder</td><td>conv1x2x2-64x2x2(2)-64x3x3-64x3x3-concatlabelC-fc 128-2 concat label C-fc 128-deconv reverse of encoder (ReLU)</td></tr></table>
+
+# CVAE architecture

parse/train/rJl8FoRcY7/rJl8FoRcY7_content_list.json

@@ -0,0 +1,1472 @@
+[
+    {
+        "type": "text",
+        "text": "DEEP GENERATIVE MODELS FOR LEARNING COHERENT LATENT REPRESENTATIONS FROM MULTIMODAL DATA ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            821,
+            171
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            195,
+            398,
+            223
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            261,
+            544,
+            275
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The application of multi-modal generative models by means of a Variational Auto Encoder (VAE) is an upcoming research topic for sensor fusion and bi-directional modality exchange. This contribution gives insights into the learned joint latent representation and shows that expressiveness and coherence are decisive properties for multi-modal datasets. Furthermore, we propose a multi-modal VAE derived from the full joint marginal log-likelihood that is able to learn the most meaningful representation for ambiguous observations. Since the properties of multi-modal sensor setups are essential for our approach but hardly available, we also propose a technique to generate correlated datasets from uni-modal ones. ",
+        "bbox": [
+            233,
+            290,
+            764,
+            415
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            438,
+            362,
+            454
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Auto Encoder (AE), Variational Auto Encoder (VAE), and more recently Disentangled Variational Auto Encoder ( $\\beta$ -VAE) have a considerable impact on the field of data-driven leaning of generative models. Furthermore, recent investigations have shown the fruitful applicability to deep reinforcement learning (DRL) as well as bi-directionally exchange of multi-modal data. VAEs tend to encode the data into latent space features that are (ideally) linearly separable as shown by Higgins et al. (2017a). They also allow the discovery of generative joint models (e.g. Suzuki et al. (2017)), as well as zero-shot domain transfer in DRL as shown by Higgins et al. (2017b). ",
+        "bbox": [
+            174,
+            469,
+            825,
+            568
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "However, a good generative model should not just generate good data and achieve a good quantitative score, but also gives a coherent and expressive latent space representation. This property is decisive for multi-modal approaches if the data shows correlation, as it is the case for every sensor setup designed for sensor fusion. With this contribution, we investigate the characteristic of the latent space as well as the quantitative features for existing multi-modal VAEs. Furthermore, we propose a novel approach to build and train a novel multi-modal VAE $( \\mathbf { M } ^ { 2 } \\mathbf { V } \\mathbf { A } \\mathbf { E } )$ which comprises the complete marginal joint log-likelihood without simplifying assumptions. As our objective is the consideration of raw multi-modal sensor data, we also propose an approach to generate correlated multi-modal datasets from available uni-modal ones. Lastly, we draw connections to in-place sensor fusion and epistemic (ambiguity-resolving) active-sensing. ",
+        "bbox": [
+            174,
+            574,
+            825,
+            713
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Section 2 comprises the related work on multi-modal VAEs. Our comprehensive approach (i.e. $\\mathbf { M } ^ { 2 } \\mathbf { V A E } )$ is given in Sec. 3. Furthermore, we describe multi-modal datasets as well as the generation of correlated sets in Sec. 4 which are evaluated in Sec. 5. Finally, we conclude our work in Sec. 6. ",
+        "bbox": [
+            176,
+            719,
+            825,
+            762
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            780,
+            367,
+            797
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Variational auto encoder (VAE) combine neural networks with variational inference to allow unsupervised learning of complicated distributions according to the graphical model shown in Figure 1 (left). A $D _ { a }$ -dimensional observation $a$ is modeled in terms of a $D _ { z }$ -dimensional latent vector $z$ using a probabilistic decoder $p _ { \\theta _ { \\mathrm { a } } } ( z )$ with parameters $\\theta$ . To generate the corresponding embedding $z$ from observation $a$ , a probabilistic encoder network with $q _ { \\phi _ { \\mathrm { a } } } ( z )$ is being provided which parametrizes the posterior distribution from which $z$ is sampled. The encoder and decoder, given by neural networks, are trained jointly to bring $a$ close to an $a ^ { \\prime }$ under the constraint that an approximate distribution needs to be close to a prior $p ( z )$ and hence inference is basically learned during training. ",
+        "bbox": [
+            174,
+            811,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/3bdbe14ee048385f34f6f5509401d5d87873c034b014b26b98b4566ce55a17fd.jpg",
+        "image_caption": [
+            "Figure 1: Evolution of full uni-, bi-, and tri-modal VAEs comprising all modality permutations "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            303,
+            98,
+            683,
+            219
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The specific objective of VAEs is the maximization of the marginal distribution $\\begin{array} { r l } { p ( a ) } & { { } = } \\end{array}$ $\\textstyle { \\int p _ { \\theta } ( { \\dot { a } } | z ) p ( z ) \\operatorname { d } { \\dot { a } } }$ . Because this distribution is intractable, the model is instead trained via stochastic gradient variational Bayes (SGVB) by maximizing the evidence lower bound (ELBO) $\\mathcal { L }$ of the marginal log-likelihood $\\log p ( a ) : = L _ { \\mathrm { a } }$ as ",
+        "bbox": [
+            173,
+            276,
+            825,
+            333
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0206c556226106a1dcf097c4f20848bb9ae28a29a08ef5ea5c825c87ebdb3d1a.jpg",
+        "text": "$$\n\\begin{array} { r } { L _ { \\mathrm { a } } \\ge \\mathcal L = \\underbrace { - \\mathrm { D } _ { \\mathrm { K L } } \\big ( q _ { \\phi } ( z | a ) \\| p ( z ) \\big ) } _ { \\mathrm { R e g u l a r i z a t i o n } } + \\underbrace { { \\mathbb E } _ { q _ { \\phi } ( z | a ) } \\log \\bigl ( p _ { \\theta } ( a | z ) \\bigr ) } _ { \\mathrm { R e c o n s t r u c t i o n } } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            310,
+            340,
+            687,
+            378
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "This approach proposed by Kingma & Welling (2013) is used in settings where only a single modality $a$ is present in order to find a latent encoding $z$ (c.f. Figure 1 (left)). ",
+        "bbox": [
+            174,
+            386,
+            823,
+            415
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In the following chapters, we give a briefly comprise related work by means of multi-modal VAEs. Further, we stress the concept of two joint multi-modal approaches to derive the later proposed variational Auto Encoder (VAE). ",
+        "bbox": [
+            174,
+            420,
+            825,
+            463
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 MULTI-MODAL AUTO ENCODER ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            481,
+            439,
+            496
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Given a set of modalities $\\mathcal { M } = \\{ a , b , c , \\ldots \\}$ , multi-modal variants of Variational Auto Encoders (VAE) have been applied to train generative models for multi-directional reconstruction (i.e. generation of missing data) or feature extraction. Variants are conditional VAEs (CVAE) and conditional multi-modal autoencoders (CMMA), with the lack in bi-directional reconstruction (Sohn et al. (2015); Pandey & Dukkipati (2017)). BiVCCA by Wang et al. (2016) trains two VAEs together with interacting inference networks to facilitate two-way reconstruction with the lack of directly modeling the joint distribution. Models, that are derived from the variation of information (VI) with the objective to estimate the joint distribution with the capabilities of multi-directional reconstruction were recently introduced by Suzuki et al. (2017). Vedantam et al. (2017) introduce another objective for the bi-modal VAE, which they call the triplet ELBO (tVAE). Furthermore, multi-modal stacked Auto Encoders (AE) are a variant of combining the latent spaces of various AEs ( Larochelle et al. (2007); Ranzato et al. (2006)) which can also be applied to the reconstruction of missing modalities (Ngiam et al. (2011); Cadena et al. (2016)). However, while Suzuki et al. (2017) and Vedantam et al. (2017) argue that training of the full multi-modal VAE is intractable, because of the $2 ^ { | { \\mathcal { M } } | } - 1$ modality subsets of inference networks, we show that training the full joint model estimates the most expressive latent embeddings. ",
+        "bbox": [
+            173,
+            507,
+            825,
+            731
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1.1 JOINT MULTI-MODAL VARIATIONAL AUTO ENCODER ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            747,
+            601,
+            762
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "When more than one modality is available, e.g. $a$ and $b$ as shown in Figure 1 (mid.), the derivation of the ELBO ${ \\mathcal { L } } _ { \\mathrm { J } }$ for a marginal joint log-likelihood $\\log p ( a ) : = L _ { \\mathbf { J } }$ is straight forward: ",
+        "bbox": [
+            174,
+            771,
+            825,
+            801
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b22b4673f7b877219c6fb45c2063b4d8f64ef497b6225a32dc19ebb5adc1ccf2.jpg",
+        "text": "$$\n\\begin{array} { r } { L _ { \\textup { J } } \\geq \\mathcal L _ { \\textup I } = \\underbrace { - \\textup D _ { \\mathrm { K L } } ( q _ { \\phi _ { \\Delta } } ( z | a , b ) \\| p ( z ) ) } _ { \\mathrm { R e g u l a r i z a t i o n } } + \\underbrace { \\mathbb E _ { q _ { \\phi _ { \\Delta } } ( z | a , b ) } \\log ( p _ { \\theta _ { \\mathrm { a } } } ( a | z ) ) } _ { \\mathrm { R e c o n s t r u c t i o n ~ w r t ~ } , a } + \\underbrace { \\mathbb E _ { q _ { \\phi _ { \\Delta } } ( z | a , b ) } \\log ( p _ { \\theta _ { \\mathrm { b } } } ( b | z ) ) } _ { \\mathrm { R e c o n s t r u c t i o n ~ w r t ~ } , b } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            186,
+            808,
+            792,
+            847
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "However, it is not clear how to perform inference if the dataset consists of samples lacking from modalities (e.g. for samples $i$ and $k$ : $( a _ { i } , \\boldsymbol { \\mathcal { O } } )$ and $( \\emptyset , b _ { k } ) )$ ). Ngiam et al. (2011) propose training of a bimodal deep auto encoder using an augmented dataset with additional examples that have only a single-modality as input. We, therefore, name the resulting model of Eq. 2 joint multi-modal VAE-Zero (JMVAE-Zero). ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1.2 JOINT MULTI-MODAL VARIATIONAL AUTO ENCODER FROM VARIATION OFINFORMATION",
+        "bbox": [
+            174,
+            103,
+            748,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "While the former approach cannot directly be applied to missing modalities, Suzuki et al. (2017) propose a joint multi-modal VAE (JMVAE) that is trained via two uni-modal encoders and a bimodal en-/decoder which share one objective function derived from the variation of information (VI) of the marginal conditional log-likelihoods $\\log p ( a | b ) p ( b | a ) = : L _ { \\mathrm { M } }$ by optimizing the ELBO ${ \\mathcal { L } } _ { \\mathrm { M } }$ : ",
+        "bbox": [
+            174,
+            141,
+            825,
+            212
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/22d1fd6251058940551cb7b826a4349f54edc8396cdb0a155432c5baa7fc77a0.jpg",
+        "text": "$$\nL _ { \\mathrm { M } } \\ge \\mathcal { L } _ { \\mathrm { M } } \\ge \\mathcal { L } _ { \\mathrm { J } } - \\underbrace { \\mathrm { D } _ { \\mathrm { K L } } \\big ( q _ { \\phi _ { \\mathrm { a b } } } ( z | a , b ) \\| q _ { \\phi _ { \\mathrm { b } } } ( z | b ) \\big ) } _ { \\mathrm { U n i m o d a l ~ P D F ~ f u t i n g ~ o f ~ e n c o d e r ~ b } } - \\underbrace { \\mathrm { D } _ { \\mathrm { K L } } \\big ( q _ { \\phi _ { \\mathrm { a b } } } ( z | a , b ) \\| q _ { \\phi _ { \\mathrm { a } } } ( z | a ) \\big ) } _ { \\mathrm { U n i m o d a l ~ P D F ~ f i t i n g ~ o f ~ e n c o d e r ~ a ~ } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            250,
+            218,
+            748,
+            256
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Therefore, uni-modal encoders are trained, so that their distributions $q _ { \\phi _ { a } }$ and $q _ { \\phi _ { b } }$ are close to a multimodal encoder $q _ { \\phi _ { \\mathrm { a b } } }$ in order to build a coherent posterior distribution. The introduced regularization by Suzuki et al. (2017) puts learning pressure on the uni-modal encoders just by the distributions’ shape, disregarding reconstruction capabilities and the prior $p ( z )$ . Furthermore, one can show that deriving the ELBO from the VI for a set of $\\mathcal { M }$ observable modalities, always leads to an expression of the ELBO that allows only training of $\\widetilde { \\mathcal { M } } = \\{ m | m \\in \\mathcal { P } ( \\mathcal { M } ) , | m | = | \\mathcal { M } | - 1 \\}$ modality combinations. This leads to the fact that for instance in a tri-modal setup, as shown in Fig. 1 (right), one can derive three bi-modal encoders from the VI, but no uni-modal ones. ",
+        "bbox": [
+            173,
+            262,
+            825,
+            377
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 MULTI-MODAL VARIATIONAL AUTO ENCODER APPROACH",
+        "text_level": 1,
+        "bbox": [
+            174,
+            397,
+            694,
+            414
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "While the objective of Wang et al. (2016), Ngiam et al. (2011), Suzuki et al. (2017), and Vedantam et al. (2017) is to exchange modalities bi-directionally (e.g. $a  b ^ { \\prime }$ ), our primary concern is twofold: First, find a meaningful posterior distribution where the sampled statistics of an encoder network allows inference about further actions. Second, find an expression to jointly train all $2 ^ { | { \\mathcal { M } } | } { - } 1$ permutations of modality encoders. ",
+        "bbox": [
+            174,
+            428,
+            825,
+            500
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "By successively applying logarithm and Bayes rules, we derive the ELBO for the multi-modal VAE $( \\dot { \\mathbf { M } } ^ { 2 } \\mathbf { V } \\mathbf { A } \\mathbf { E } )$ as follows: First, given the independent set of observable modalities $\\mathcal { M } = \\{ a , b , c , \\ldots \\}$ , its marginal log-likelihood $\\dot { \\log { p ( \\mathcal { M } ) } } = : \\dot { L _ { \\mathrm { M } ^ { 2 } } }$ is multiplied by the cardinality of the set as the neutral element $1 = | \\mathcal { M } | / | \\mathcal { M } |$ . Second, applying logarithm multiplication rule, the nominator is written as the argument’s exponent. Third, Bayes rule is applied to each term wrt. the remaining observable modalities to derive their conditionals. Further, we bootstrap the derivation technique in a bi- and tri-modal (c.f. tri-modal case in Sec. 6.1) case to illustrate the advantages. By excessively applying the scheme until convergence of the mathematical expression, it leads for a bi-modal set $\\mathcal { M } = \\{ a , b \\}$ to the following result: ",
+        "bbox": [
+            173,
+            506,
+            825,
+            632
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/349e3d907b73dd88abf225daf2dd32e8b27078167f4670426dceb1d7e624f4fd.jpg",
+        "text": "$$\n\\begin{array} { r l } & { L _ { \\mathrm { M } ^ { 2 } } = 2 / 2 \\log p ( a , b ) = 1 / 2 \\log p ( a , b ) ^ { 2 } = 1 / 2 \\log p ( a , b ) p ( a , b ) = 1 / 2 \\log p ( b ) p ( a | b ) p ( b | a ) p ( a ) } \\\\ & { \\qquad = 1 / 2 ( \\log p ( a ) + \\log p ( b | a ) + \\log p ( a | b ) + \\log p ( b ) ) = 1 / 2 ( L _ { \\mathrm { a } } + L _ { \\mathrm { M } } + L _ { \\mathrm { b } } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            183,
+            637,
+            794,
+            678
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "This term can be written as inequality wrt. each ELBO of the marginals $L _ { \\mathrm { a } } , L _ { \\mathrm { b } }$ and conditionals $L _ { \\mathrm { M } }$ : ",
+        "bbox": [
+            174,
+            688,
+            825,
+            717
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/436a3efab78cc870341eed5db6bd293963397b19f8125e5ba57933f78be003b0.jpg",
+        "text": "$$\n\\begin{array} { r l } & { 2 L _ { \\mathsf { M } ^ { 2 } } \\geq 2 \\mathcal { L } _ { \\mathsf { M } ^ { 2 } } = \\mathcal { L } _ { \\mathsf { a } } + \\mathcal { L } _ { \\mathsf { b } } + \\mathcal { L } _ { \\mathsf { M } } = } \\\\ & { \\ - \\beta _ { \\mathsf { a } } \\mathrm { D } _ { \\mathrm { K L } } ( q _ { \\phi _ { \\mathsf { a } } } ( z | a ) \\| p ( z ) ) + \\mathbb { E } _ { q _ { \\phi _ { \\mathsf { a } } } ( z | a ) } \\log ( p _ { \\theta _ { \\mathsf { a } } } ( a | z ) ) } \\\\ & { \\ - \\beta _ { \\mathsf { b } } \\mathrm { D } _ { \\mathrm { K L } } ( q _ { \\phi _ { \\mathsf { b } } } ( z | b ) \\| p ( z ) ) + \\mathbb { E } _ { q _ { \\phi _ { \\mathsf { b } } } ( z | b ) } \\log ( p _ { \\theta _ { \\mathsf { b } } } ( b | z ) ) } \\\\ & { \\ + \\mathbb { E } _ { q _ { \\phi _ { \\mathsf { a b } } } ( z | a , b ) } \\log ( p _ { \\theta _ { \\mathsf { a } } } ( a | z ) ) + \\mathbb { E } _ { q _ { \\phi _ { \\mathsf { a b } } } ( z | a , b ) } \\log ( p _ { \\theta _ { \\mathsf { b } } } ( b | z ) ) - \\beta _ { \\mathsf { a b } } \\mathrm { D } _ { \\mathrm { K L } } ( q _ { \\phi _ { \\mathsf { a b } } } ( z | a , b ) \\| p ( z ) ) } \\\\ & { \\ - \\ \\alpha \\mathrm { D } _ { \\mathrm { K L } } ( q _ { \\phi _ { \\mathsf { a b } } } ( z | a , b ) \\| q _ { \\phi _ { \\mathsf { a } } } ( z | a ) ) - \\alpha \\mathrm { D } _ { \\mathrm { K L } } ( q _ { \\phi _ { \\mathsf { a b } } } ( z | a , b ) \\| q _ { \\phi _ { \\mathsf { b } } } ( z | b ) ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            215,
+            722,
+            781,
+            823
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Equation 6 is substituted by all formerly derived ELBO expressions lead to the combination of the uni-modal VAEs wrt. a and b (c.f. Eq. 7 to 8) and the JMVAE comprising the VAE wrt. the joint modality ab (c.f. Eq. 9) and mutual latent space (c.f. Eq. 10). Equation 7 and 8 have the effect that their regularizers care about the uni-modal distribution to deviate not too much from the common prior while their reconstruction term shapes the underlying embedding of the mutual latent space. We further apply the concept of $\\beta$ -VAE (Higgins et al. (2016; 2017a); Burgess et al. (2018)) to the regularizers via $\\beta _ { * }$ and adopt the factor $\\alpha$ from Suzuki et al. (2017) for the mutual regularizer. ",
+        "bbox": [
+            173,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "However, while $\\beta$ -VAE have the property to disentangle the latent space, our main concern is the balance between the input and the latent space using a constant normalized factor $\\beta _ { \\mathrm { n o r m } } = \\beta _ { * } D _ { * } / D _ { z }$ . ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "If the derivation, which we leave out for the sake of brevity, is applied to the log-likelihood LM2M of a set $\\mathcal { M }$ , one can show that it results into a recursive form consisting of JMVAEs’ and ${ \\bf M } ^ { 2 }$ VAEs’ log-likelihood terms ",
+        "bbox": [
+            174,
+            138,
+            823,
+            184
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b6b1c2e8a832191e3420f948e58acc99635dc58c9a538d9e1918694d08f9c43b.jpg",
+        "text": "$$\nL _ { \\mathrm { M } ^ { 2 } , \\mathrm { M } } = \\frac { 1 } { | \\mathcal { M } | } \\left( L _ { \\mathrm { M } , \\mathrm { M } } + \\sum _ { \\widetilde { m } \\in \\widetilde { \\mathcal { M } } } L _ { \\mathrm { M } ^ { 2 } _ { \\widetilde { m } } } \\right) \\geq \\frac { 1 } { | \\mathcal { M } | } \\left( \\mathcal { L } _ { \\mathrm { M } , \\mathrm { M } } + \\sum _ { \\widetilde { m } \\in \\widetilde { \\mathcal { M } } } \\mathcal { L } _ { \\mathrm { M } ^ { 2 } _ { \\widetilde { m } } } \\right) = : \\mathcal { L } _ { \\mathrm { M } ^ { 2 } , \\mathrm { M } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            212,
+            190,
+            758,
+            242
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "While the derivation of Eq. 11 is given in Sec 6.1.3, the properties are as follows: ",
+        "bbox": [
+            173,
+            256,
+            707,
+            272
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "• the $\\mathbf { M } ^ { 2 } \\mathbf { V A E }$ consist out of $2 ^ { | { \\mathcal { M } } | } - 1$ encoders and $| { \\mathcal { M } } |$ decoders comprising all modality combinations   \n• while it also allows the bi-directional exchange of modalities, it further allows the setup of arbitrary modality combinations having 1 to $| { \\mathcal { M } } |$ modalities   \nsubsets of minor cardinality are weighted less and have a therefore minor impact in shaping the overall posterior distribution (vice versa, the major subsets dominate the shaping and the minor sets adapt to it)   \n• all encoder/decoder networks can jointly be trained using SGVB ",
+        "bbox": [
+            215,
+            284,
+            825,
+            416
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 DATA SETS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            435,
+            300,
+            453
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "It is quite common in the multi-modal VAE community to model a bi-modal dataset as follows (Wang et al. (2016); Ngiam et al. (2011); Suzuki et al. (2017); Vedantam et al. (2017)): The first modality $a$ denotes the raw data and $b$ denotes the label (e.g. the digits’ images and labels as onehot vector wrt. the MNIST dataset). This is a rather artificial assumption and only sufficient when the objective is within a semi-supervised training framework. Real multi-modal data does not show this behavior as there are commonly multiple raw data inputs. Unfortunately, only complex multimodal datasets of heterogeneous sensor setups exist (Ofli et al. (2013); Udacity (2016); Kragh et al. (2017)), which makes a comprehensive evaluation for VAEs futile. On the other hand, creating own multi-modal datasets is exhaustive since training generative models either demand dense sampling or supervised signals to form a consistent latent manifold (Bengio et al. (2012)). ",
+        "bbox": [
+            173,
+            468,
+            825,
+            608
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "While na¨ıve consolidation of non-coherently datasets does not meet the conditions of data continuity, as discussed later, we propose a consolidation technique by sampling from superimposed latent spaces of various uni-modal trained CVAEs in Sec. 4.1. This approach allows the generation of multi-modal datasets from distinct and disconnected uni-modal sets. Second, we propose and bi-modal mixture of Gaussians (MoG) dataset to show particular behaviors of the various VAE approaches in Sec. 4.2. ",
+        "bbox": [
+            174,
+            614,
+            825,
+            698
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 MULTI-MODAL DATA GENERATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            717,
+            460,
+            731
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Perry et al. (2010) state that Hebbian learning relies on the fact that the same objects are continuously transformed to their nearest neighbor in the observable space. Higgins et al. (2016) adopted this approach to their assumptions, that this notion can be generalized within the latent manifold learning. Further, neither a coherent manifold nor a proper factorization of the latent space can be trained if these assumptions are not fulfilled by the dataset. In summary, this means that observed data has to have the property of continues transformation wrt. to their properties (e.g. position and shape of an object), such that a small deviation of the observations results in proportional deviations in the latent space. We adopt this assumption for multi-modal datasets where observations should correlate if the same quantity is observed, such that a small deviation in the common latent representation between all modalities conducts a proportional impact in all observations. This becomes an actual fundamental requirement for any multi-modal dataset, as correlation and coherence are within the objective of multi-modal sensor fusion. In the following, we propose a technique to generate new multi-modal datasets, given different uni-modal enclosed sets which meet the former conditions. ",
+        "bbox": [
+            174,
+            743,
+            825,
+            922
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "A valuable property of the VAE’s learned posterior distribution is, that it matches the desired prior quite sufficiently if only a single class is observed. This characteristic can be found again in the conditional VAE (CVAE) Kingma et al. (2014); Sohn et al. (2015) as it’s training is supported by the ground truth labels of the observations. Thus, it actually builds non-related posterior distribution for each class label, where every distribution matches a given prior. Furthermore, we adopt the idea of $\\beta$ -VAE Higgins et al. (2017b) which learns disentangled and factorized latent representations. Combining the properties of both advantages allows the superimposing of latent manifolds from various uni-modal encoders as shown in Fig. 2 (Top-Right). Now, latent samples can be drawn from the posterior to operate all CVAE encoders, with the desired label, to generate continues multi-modal data. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            242
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To test the approach we consolidate MNIST (LeCun Yann et al. (1998)) and fashion-MNIST (Xiao et al. (2017)) to an entangled-MNIST (e-MNIST) set by sampling from the prior (i.e. $z \\sim \\mathcal { N } ( 0 , \\mathbf { I } ) )$ to generate observation tuples from the corresponding encoder networks $p _ { \\theta _ { a } } ( a | z , C )$ and $p _ { \\theta _ { b } } ( b | z , C )$ with class label $C$ . The network architecture is explained in Sec. 3. To avoid artifacts, only samples from within $2 \\sigma$ of the prior are obtained. ",
+        "bbox": [
+            174,
+            250,
+            825,
+            319
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Furthermore, we train a bi-modal JMVAE on the newly generated data to depict properties of the different datasets. We are aware of the fact that consolidation of uni-modal datasets cannot be achieved easily since continuity is hardly measurable. Therefore, na¨ıve consolidation results in a mixed dataset (i.e. mixed-MNIST) as shown in Fig. 2. To mimic this behavior and to achieve a fair comparison of the ELBO, we shuffle the generated fashion-MNIST per class label of e-MNIST to generate an equivalent mixed-e-MNIST (me-MNIST) set. ",
+        "bbox": [
+            174,
+            325,
+            825,
+            410
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "As shown in Fig. 2 (bottom), the JMVAE’s latent space reveals that for m-MNIST single clusters share the same mean as the best representative of a single label, but the variance of any uni-modal trained encoder remains orthogonal. Thus, the continuity in the observations does not correlate with each other by any means. On the other hand, the e-MNIST set with continues samples shows the desired behavior of multi-modal datasets as the JMVAE trains a coherent distribution for all uniand multi-modal encoders. These observations show that our proposed approach for generating new entangled datasets meet the formulated requirements of multi-modal datasets. ",
+        "bbox": [
+            174,
+            416,
+            825,
+            515
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 MOG-EXAMPLE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            546,
+            328,
+            560
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We investigate a Mixture-of-Gaussians (MoG) distribution, as depicted in Fig. 3, as bi-modal observations to mimic the output of e.g. feature extractors or classifiers. While they commonly already provide linear separable observations, we focus on ambiguity resolving properties of the VAE in particular. ",
+        "bbox": [
+            174,
+            579,
+            823,
+            635
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The bi-modal $( a , b )$ observations of Mixture-of-Gaussians have ten classes $( 0 , \\ldots , 9 )$ each. $a$ ’s observations are organized on a grid where (5,6,7) and (0,8) result in ambiguous observations by sharing the same mean. $b$ ’s observations are organized on a circle where (0,9) have ambiguous mean values. ",
+        "bbox": [
+            176,
+            641,
+            823,
+            684
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This rather artificial experiment has the purpose to depict and evaluate ambiguous resolving properties of the VAEs. However, data of multi-modal sensor setups for complementary fusion show similar behavior, as various modalities are rectified to achieve a complete view of the scene (e.g. vision and grope to rectify objects). In that case, various dependencies of the generative process, given the class labels as factorized latent state representation $\\boldsymbol { z } = ( z _ { 0 } , \\ldots , z _ { 9 } )$ , are possible. This is mimicked by the MoG-Experiment, in a simplified assumption, as: $p ( a , b | z )$ , $p ( a | z _ { 1 } , \\ldots , z _ { 4 } , z _ { 9 } )$ , and $p ( b | z _ { 1 } , \\dots , z _ { 8 } )$ . ",
+        "bbox": [
+            174,
+            690,
+            825,
+            790
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            824,
+            326,
+            840
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We apply the datasets explained in Sec. 4 to test and depict the capabilities of the $\\mathbf { M } ^ { 2 } \\mathbf { V } \\mathbf { A } \\mathbf { E }$ . First, we investigate the MoG data comprehensively. Second, we evaluate the ELBO of various approaches to the e-MNIST dataset. The VAEs are compared qualitatively, by visualizing the latent space, and quantitatively by performing lower bound tests $\\mathcal { L } _ { \\widetilde { \\mathcal { M } } }$ for every subset ${ \\widetilde { \\mathcal { M } } } \\subseteq { \\mathcal { M } }$ wrt. to the decoding ",
+        "bbox": [
+            174,
+            864,
+            823,
+            925
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/3fde56fef4ef0e262a8c7a57e4df4fa4876cb81377bafb36d490b67353ceb3bc.jpg",
+        "image_caption": [
+            "Figure 2: Top-Left: Depiction of na¨ıve mixed MNIST (m-MNIST) vs. proposed entangled MNIST (e-MNIST). m-MNIST is pairwise plotted with the closest match of MNIST digits according to the mean-squared-error. The corresponding fashion-MNIST samples show no continuity nor correlation (despite the intended class correlation). e-MNIST shows the desired entanglement for changes of a single latent space factor. Top-Right: Latent space of the CVAE for the modalities $a$ (MNIST) and $b$ (fashion-MNIST). Bottom: Latent space of a trained JMVAE (c.f. Sec. 6.1.4). m-MNIST shows clear orthogonalization between modalities of the same class and segregation between classes (colorization is wrt. the CVAE legend). e-MNIST shows a coherently learned latent space between the uni- and multi-modal encoders. Thus, the JMVAE learns the correlation inside the dataset sufficiently $( \\mathcal { L } _ { a , b | \\mathrm { m e - M N I S T } } = - 2 0 4 . 4 8$ vs. $\\mathcal { L } _ { a , b | \\mathrm { e - M N I S T } } = - 1 9 9 . 2 3 )$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            207,
+            99,
+            794,
+            428
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/a7223c8789eeaabca99004d5056ba2ab10424657bc3719f8d4f7ef0b1004cc14.jpg",
+        "image_caption": [
+            "Figure 3: MoG input signals with for the modalities $a$ and $b$ . The depicted observations are sampled for the corresponding modality for each class. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            349,
+            614,
+            650,
+            731
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "of all modalities $p _ { \\theta _ { \\mathcal { M } } }$ ",
+        "bbox": [
+            173,
+            814,
+            318,
+            829
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/47ad7828d09756d49b4a7aeaa6ee868a68679d4e336601b571acde198e571e83.jpg",
+        "text": "$$\n\\mathcal { L } _ { \\widetilde { M } } = \\mathbb { E } _ { q _ { \\phi _ { \\widetilde { M } } } ( z | \\widetilde { M } ) } \\log \\frac { p _ { \\theta _ { \\mathcal { M } } } ( \\mathcal { M } | z ) p ( z ) } { q _ { \\phi _ { \\widetilde { M } } } \\Big ( z | \\widetilde { \\mathcal { M } } \\Big ) }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            369,
+            847,
+            627,
+            890
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "with $p ( z ) = \\mathcal { N } ( z ; \\mathbf { 0 } , \\mathbf { I } )$ . All VAE architectures can be found in Sec. 6.1.4. ",
+        "bbox": [
+            173,
+            909,
+            656,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/6c7f440aa21a2e2bfe8569e53318502b9458bb7b263a152ca1eb5d56572af077.jpg",
+        "image_caption": [
+            "Figure 4: Latent space embeddings of the bi-modal MoG dataset by the three encoder networks of the $\\mathbf { M } ^ { 2 } \\mathbf { V } \\mathbf { A } \\mathbf { E }$ . Classes and ELBO colorization is depicted for various parameter settings of $\\beta _ { * }$ and $\\alpha$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            94,
+            805,
+            448
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 MOG-EXPERIMENT ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            518,
+            351,
+            534
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We evaluate the latent space with the premise in mind, that a good generative model should not just generate good data but also gives a good latent representation $z$ . ",
+        "bbox": [
+            174,
+            547,
+            823,
+            575
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1.1 PARAMETRIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            597,
+            362,
+            611
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We first investigate the impact of the parameter set $( \\beta _ { * } , \\alpha )$ on the $\\mathbf { M } ^ { 2 } \\mathbf { V } \\mathbf { A } \\mathbf { E }$ to find a latent space representation, which suits our needs to learn actions from it. ",
+        "bbox": [
+            176,
+            623,
+            823,
+            651
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "As the $\\alpha$ parameter controls the mutual connection of all encoders in latent space, we found that a direct connection (i.e. $\\alpha = 1 .$ ) puts too much learning pressure on matching the mutual latent distributions between uni- and multi-modal encoders. Thus, classes which should be separated in the multi-modal latent space collapse to the mean distributions of the uni-modal encoders. For $\\alpha \\lessapprox 1 0 ^ { - 2 }$ , the encoders are able to find an expressive latent space distribution by means of separable collapsed classes of uni-modal encoders, and expanded classes of multi-modal around it (c.f. Fig. 4 top/left). ",
+        "bbox": [
+            174,
+            659,
+            825,
+            756
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "By the findings of Higgins et al. (2017b), high $\\beta$ values result in highly entangled factors in latent space whereas small normalized $\\beta _ { \\mathrm { n o r m } } \\lessapprox 1 0 ^ { - 2 }$ show pretty robust disentanglement in all their test cases. The impact of $\\beta$ shows similar behavior on the $\\mathbf { M } ^ { 2 } \\mathbf { V A E }$ and thus, we chose small $\\beta$ values of $\\beta _ { \\mathrm { { n o r m } } } = 1 0 ^ { - 2 }$ to relax the learning pressure caused by the prior. While the over optimization wrt. to the prior leads to a fuzzy generation of data $p ( \\mathcal { M } | z )$ and collapse in latent space, high relaxation $( \\beta _ { \\mathrm { { n o r m } } } \\ll 1 0 ^ { - 3 } ,$ ) causes loss of expressiveness between uni- and multi-modal encoding of a single class by means of the difference in the ELBO. ",
+        "bbox": [
+            174,
+            762,
+            825,
+            861
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "It is worth noticing, that diverging $\\beta$ parameters between multi- and uni-modal regularization (e.g. $\\beta _ { \\mathrm { a b } } \\ll \\beta _ { \\mathrm { a } }$ or vice versa) results in lower ELBOs, but for the sake of expressiveness of latent embedding and the ELBO between encoders’ embeddings. We argue that learning pressure should be applied equally to all encoders so that they experience a similar learning impact. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Another observation results from the fact, that the reconstruction loss of the $\\mathbf { M } ^ { 2 } \\mathbf { V } \\mathbf { A } \\mathbf { E }$ ’s objective causes learning of mean representatives of classes in the observation space. This causes the artifact, that if for instance three classes exist in the output space, where one represents the overall mean, and an uni-modal encoder only sees the collapse of classes to that particular mean value, the latent encoding of this uni-modal encoder will collapse to the same mean as well. However, while it is not longer separable (not even non-linearly) in latent space by its mean value, the ELBO for the observation drives up and gives, therefore, evidence about the embedding quality. This insight might be fruitful in terms of epistemic (ambiguity-resolving) tasks, where for instance an unsupervised reinforcement learning approach could use the ELBO as a signal to learn epistemic exploration. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            229
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.1.2 COMPARISION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            250,
+            328,
+            263
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/3ca44be7de39faa13d9ece6ac3a693d3b122b7582779c1af651ee299e04ecff7.jpg",
+        "image_caption": [
+            "Figure 5: Bi-modal latent space embeddings by the three multi-modal VAEs JMVAE-Zero (left), tVAE (mid.), and ${ \\bf M } ^ { 2 }$ VAE (right). The bi-modal input signals are an arrangement of the MoG distributions with ambiguities wrt. their mean values. The ELBO (colorization wrt. Figure 4) is estimated by Eq. 12 and is depicted qualitatively, as it can only be compared between encoders of the same approach. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            281,
+            825,
+            544
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Comparing the three approaches to estimate the multi-modal marginal log-likelihood by maximizing the ELBO, one can see from Fig. 5 that the most coherent latent space distribution was learned by the proposed $\\mathbf { M } ^ { 2 } \\mathbf { V } \\mathbf { A } \\mathbf { E }$ . ",
+        "bbox": [
+            174,
+            651,
+            825,
+            693
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "While the JMVAE-Zero learned similarities between $q _ { \\phi _ { \\mathrm { a b } } }$ and $q _ { \\phi _ { \\mathrm { a } } }$ , it learned a complete new embedding for the classes (1,2) with $q _ { \\phi _ { \\mathrm { b } } }$ (denoted by $( \\mathbb { S } )$ ). Furthermore, the ELBO per embedding allows no conclusion between the embeddings of the various encoders. ",
+        "bbox": [
+            174,
+            700,
+            823,
+            742
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The tVAE founds a much more coherent embedding between the encoders. This was achieved by the fact, that first the full multi-modal VAE, consisting out of the encoder $q _ { \\phi _ { \\mathrm { a b } } }$ and two decoder $p _ { \\theta _ { \\mathrm { a } } }$ and $p _ { \\theta _ { \\mathrm { b } } }$ , was trained. Second, the decoder weights are pinned to train the remaining uni-modal networks which enforces coherence. However, the ELBO per embedding also does not allow any direct conclusion between the embeddings of the various encoders. This is depicted by $( \\sim )$ , where the multi-modal encoder $q _ { \\phi _ { \\mathrm { a b } } }$ produces embeddings of higher energy than these of the uni-modal ones. This can happen as there is no regularizer which enforces the variational distribution of the encoders to match each other and thus, the KL-divergence may differ between the models for similar encodings. ",
+        "bbox": [
+            173,
+            750,
+            825,
+            875
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The $\\mathbf { M } ^ { 2 } \\mathbf { V } \\mathbf { A } \\mathbf { E }$ , on the other hand, enforces the encoders inherently to approximate the same posterior distribution which can be seen by the strong coherence between all embeddings. Furthermore, classes which are separated in the multi-modal latent embedding collapse to the mean values in the uni-modal ones as denoted by $( + )$ and $( - )$ . This behavior is also rendered by the ELBO. As the $\\mathbf { M } ^ { 2 } \\mathbf { V } \\mathbf { A } \\mathbf { E }$ makes ambiguous embeddings, the reconstruction loss drives up (c.f. $( * )$ and $( / ) ,$ ). ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The embeddings also show an interesting fact about the class (0): As this class is only ambiguously detectable in the uni-modal case, all VAEs learn a linear separable and therefore unambiguous embedding if both modalities make an observation of this class (denoted by $( - )$ for the $\\mathbf { M } ^ { 2 } \\mathbf { V } \\mathbf { A } \\mathbf { E } )$ . ",
+        "bbox": [
+            176,
+            138,
+            823,
+            181
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.2 IN-PLACE SENSOR FUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            200,
+            401,
+            215
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Further, we introduce the concept of in-place sensor fusion using multi-modal VAEs. This approach is applicable in distributed active-sensing tasks where the latent space representation $z$ of observations $\\mathcal { M } ^ { \\prime }$ (i.e. an object or point of interest was observed by a set of modalities) can be interpreted as inverse sensor model (c.f. Thrun et al. (2005)). This compressed information can be efficiently transmitted between all sensing agents and also be updated as follows: $z$ can be unfolded to the original observation using the VAE’s decoder networks and combined with any new observation $m$ to update the information in-place $z \\to z ^ { * }$ via ",
+        "bbox": [
+            173,
+            227,
+            825,
+            325
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f670154006204a8ebb20c8279e6f61ac3b3a2db1cb45cabf394fb8e3ce0e6141.jpg",
+        "text": "$$\nq _ { \\phi _ { m \\perp } M ^ { \\prime } } ( z ^ { * } | m , \\mathcal { M } ^ { \\prime } ) \\quad \\mathrm { { w i t h } } \\quad \\mathcal { M } ^ { \\prime } = \\bigcup _ { m ^ { \\prime } i n \\mathcal { M } ^ { \\prime } } p _ { \\theta _ { m ^ { \\prime } } } ( m ^ { \\prime } | z ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            313,
+            334,
+            684,
+            369
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "However, a necessary requirement of Eq. 13 is that auto re-encoding (i.e. $z  z$ via $q _ { \\phi _ { \\mathcal { M ^ { \\prime } } } } ( z | \\mathcal { M } ^ { \\prime } ) )$ does not manipulate the information comprised by $z$ in an unrecoverable way (e.g. label-switching). Thus, we assume that VAEs tend to have a natural denoising characteristic (despite the explicit denoising Auto Encoders) which should re-encode any $z$ in a better version of its own by means of the reconstruction loss wrt. $z$ . This behavior is shown in Fig. 6 where we underlay the latent representation with the reconstruction loss of every particular $z$ . One can see the learned discrimination of the latent space by means of high entropy separating the clusters vicinity. Furthermore, initial $z$ values are auto re-encoded which draw the trajectories along their path in latent space. The observable properties of the VAE are that every seed converges to a fixed-point while performing descending steps on the latent space manifold. However, this statement is only valid in general for the proposed $\\mathbf { M } ^ { 2 } \\mathrm { V A E }$ , as the JMVAE-Zero and tVAE learn no or only similar coherent latent spaces between the encoder networks. Thus, seeds may be attracted by wrong attractors which makes these approach not sufficient for in-place sensor fusion. ",
+        "bbox": [
+            173,
+            377,
+            825,
+            558
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/cd3afdd90f3c152430a31819ed88e5a41c5c82109378a3c0c2f71c49657f00d2.jpg",
+        "image_caption": [
+            "Figure 6: From top to bottom: JMVAE-Zero, tVAE, and ${ \\bf M } ^ { 2 }$ VAE. Left: Latent space representation with class colorization. Right: Corresponding colorization of the latent space for every $z$ obtained by auto re-encoding. White dots denote randomly drawn seeds which auto re-encoding steps are represented by the black trajectory. See Fig. 5 for legends. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            575,
+            818,
+            840
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.3 E-MNIST EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            380,
+            117
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "For this experiment, we estimated the ELBO by Eq. 12 to evaluate the performance of models JMVAE-Zero, tVAE, and $\\mathbf { M } ^ { 2 } \\mathbf { V } \\mathbf { A } \\mathbf { E }$ . We chose the model wrt. to the evaluation in Fig. 4 with $\\beta _ { \\mathrm { n o r m } } ~ = ~ 0 . 0 1$ which is $\\beta _ { * } \\approx 4$ for the given MNIST image dimension of $D _ { a } \\ = \\ | | \\bar { ( 2 8 , 2 8 , 1 ) } | |$ and $D _ { z } = 2$ . However, Tbl. 1 shows quantitatively and Fig. 7 depicts qualitatively that the proposed $\\mathbf { M } ^ { 2 } \\mathbf { V } \\mathbf { A } \\mathbf { E }$ reaches the highest ELBO value, as well as it learns the most expressive latent space distribution. Furthermore, by sampling from the latent space for data generation, the $\\mathbf { M } ^ { 2 } \\mathbf { V } \\mathbf { A } \\mathbf { E }$ reveals crisp reconstructions in comparison to the other approaches. ",
+        "bbox": [
+            174,
+            130,
+            823,
+            186
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/df6b12454a306f78dd7cc6b3a05f71b22b5e57662f6fae07263b327c90493f64.jpg",
+        "table_caption": [
+            "Table 1: Evidence lower bound test for uni- and multi-modal setups of the VAEs (higher is better). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"3\">M²VAE</td><td colspan=\"3\">tVAE</td><td colspan=\"3\">JMVAE-Zero</td></tr><tr><td>La,b</td><td>La</td><td>Lb</td><td>La.b</td><td>La</td><td>Lb</td><td>La,b</td><td>La</td><td>Lb</td></tr><tr><td>-10.75</td><td>-10.91</td><td>-16.01</td><td>-23.6</td><td>-101.28</td><td>-88.75</td><td>-24.19</td><td>-131.05</td><td>-99.71</td></tr></table>",
+        "bbox": [
+            179,
+            231,
+            820,
+            273
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/42bb0c94e113d1a4888761a38cf9b5cf7d34394b3ad721f22fd9ce8a0c19353f.jpg",
+        "image_caption": [
+            "Figure 7: From top to bottom: JMVAE-Zero, tVAE, and $\\mathbf { M } ^ { 2 } \\mathbf { V } \\mathbf { A } \\mathbf { E }$ . Left: Latent space representation with class colorization. Right: Reconstruction from latent space by applying the corresponding decoder networks. $z$ is sampled linearly within $2 \\sigma$ of the prior for all figures. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            308,
+            825,
+            609
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            686,
+            825,
+            728
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            751,
+            318,
+            767
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This work presents a novel multi-modal Variational Auto Encoder which is derived from the complete marginal joint log-likelihood. We showed that this expression can jointly be trained on an Mixture-of-Gaussian dataset with ambiguous observations, as well as on a complex dataset derived from MNIST and fashion-MNIST. Furthermore, we formulated requirements and characteristics for multi-modal data for sensor fusion and derived a technique to learn new datasets, namely the proposed entangled-MNIST, which suffice these requirements. Lastly, we developed the idea of in-place sensor fusion in distributed, active sensing scenarios and formulated the requirements, by means of auto re-encoding, to VAEs. This revealed the properties of VAEs, that they tend to denoise the observable data which leads to an attractor behavior in latent space. However, we performed all qualitative evaluations of the latent space with the premise in mind, that a good generative model should not just generate good data but also gives a good latent representation. This does also correlate with the quantitative behaviors, as our proposed model achieved the highest ELBO values. Future work will concentrate on the integration of the ambiguous resolving characteristics to an epistemic-exploration scenario. ",
+        "bbox": [
+            174,
+            784,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            159
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            175,
+            326,
+            188
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "This research was supported by ’CITEC’ (EXC 277) at Bielefeld University and the Federal Ministry of Education and Research (57388272). The responsibility for the content of this publication lies with the author. ",
+        "bbox": [
+            176,
+            198,
+            825,
+            241
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            261,
+            285,
+            276
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yoshua Bengio, Aaron Courville, and Pascal Vincent. Representation Learning: A Review and New Perspectives. (1993):1–30, 2012. ISSN 15324435. doi: 10.1145/1756006.1756025. URL http://arxiv.org/abs/1206.5538.   \nChristopher P. Burgess, Irina Higgins, Arka Pal, Loic Matthey, Nick Watters, Guillaume Desjardins, and Alexander Lerchner. Understanding disentangling in $\\beta$ -VAE. (Nips), 2018. URL http: //arxiv.org/abs/1804.03599.   \nCesar Cadena, Anthony Dick, and Ian D Reid. Multi-modal Auto-Encoders as Joint Estimators for Robotics Scene Understanding. In Nancy Amato, Siddhartha Srinivasa, Nora Ayanian, and Scott Kiundersma (eds.), Robotics: Science and System XIII, Cambridge, 2016. MIT Press. doi: 10.15607/RSS.2016.XII.041.   \nIrina Higgins, Loic Matthey, Xavier Glorot, Arka Pal, Benigno Uria, Charles Blundell, Shakir Mohamed, and Alexander Lerchner. Early Visual Concept Learning with Unsupervised Deep Learning. 2016. URL http://arxiv.org/abs/1606.05579.   \nIrina Higgins, Loic Matthey, Arka Pal, Christopher Burgess, Xavier Glorot, Matthew Botvinick, Shakir Mohamed, Alexander Lerchner, and Google Deepmind. beta-VAE: Learning Basic Visual Concepts with a Constrained Variational Framework. Iclr, (July):1–13, 2017a. URL https: //openreview.net/forum?id $=$ Sy2fzU9gl.   \nIrina Higgins, Arka Pal, Andrei A. Rusu, Loic Matthey, Christopher P Burgess, Alexander Pritzel, Matthew Botvinick, Charles Blundell, and Alexander Lerchner. DARLA: Improving Zero-Shot Transfer in Reinforcement Learning. 2017b. ISSN 1938-7228. URL http://arxiv.org/ abs/1707.08475.   \nDiederik P Kingma and Max Welling. Auto-Encoding Variational Bayes. CoRR, abs/1312.6, 2013. URL http://arxiv.org/abs/1312.6114.   \nDiederik P. Kingma, Danilo J. Rezende, Shakir Mohamed, and Max Welling. Semi-Supervised Learning with Deep Generative Models. pp. 1–9, 2014. ISSN 10495258. URL http: //arxiv.org/abs/1406.5298.   \nMikkel Fly Kragh, Peter Christiansen, Morten Stigaard Laursen, Morten Larsen, Kim Arild Steen, Ole Green, Henrik Karstoft, and Rasmus Nyholm Jørgensen. FieldSAFE: Dataset for Obstacle Detection in Agriculture. Sensors, 17(11), 2017.   \nHugo Larochelle, Dumitru Erhan, Aaron Courville, James Bergstra, and Yoshua Bengio. An Empirical Evaluation of Deep Architectures on Problems with Many Factors of Variation. In Proceedings of the 24th International Conference on Machine Learning, ICML ’07, pp. 473–480, New York, NY, USA, 2007. ACM. ISBN 978-1-59593-793-3. doi: 10.1145/1273496.1273556. URL http://doi.acm.org/10.1145/1273496.1273556.   \nLeCun Yann, Cortes Corinna, and Burges Christopher. THE MNIST DATABASE of handwritten digits. The Courant Institute of Mathematical Sciences, 1998.   \nJiquan Ngiam, Aditya Khosla, Mingyu Kim, Juhan Nam, Honglak Lee, and Andrew Y Ng. Multimodal Deep Learning. Proceedings of The 28th International Conference on Machine Learning (ICML), 2011. ISSN 9781450306195. doi: 10.1145/2647868.2654931. ",
+        "bbox": [
+            169,
+            276,
+            826,
+            922
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ferda Ofli, Rizwan Chaudhry, Gregorij Kurillo, Rene Vidal, and Ruzena Bajcsy. Berkeley MHAD: A comprehensive Multimodal Human Action Database. In Proceedings of IEEE Workshop on Applications of Computer Vision, 2013. ISBN 9781467350532. doi: 10.1109/WACV.2013.6474999. ",
+        "bbox": [
+            176,
+            103,
+            821,
+            146
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Gaurav Pandey and Ambedkar Dukkipati. Variational methods for conditional multimodal deep learning. Proceedings of the International Joint Conference on Neural Networks, 2017-May: 308–315, 2017. doi: 10.1109/IJCNN.2017.7965870. ",
+        "bbox": [
+            176,
+            152,
+            821,
+            195
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "G. Perry, E. T. Rolls, and S. M. Stringer. Continuous transformation learning of translation invariant representations. Experimental Brain Research, 204(2):255–270, 2010. ISSN 00144819. doi: 10.1007/s00221-010-2309-0. ",
+        "bbox": [
+            178,
+            202,
+            821,
+            244
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Marc’Aurelio Ranzato, Christopher Poultney, Sumit Chopra, and Yann LeCun. Efficient Learning of Sparse Representations with an Energy-based Model. In Proceedings of the 19th International Conference on Neural Information Processing Systems, NIPS’06, pp. 1137–1144, Cambridge, MA, USA, 2006. MIT Press. URL http://dl.acm.org/citation.cfm?id= 2976456.2976599. ",
+        "bbox": [
+            173,
+            251,
+            825,
+            321
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kihyuk Sohn, Honglak Lee, and Xinchen Yan. Learning Structured Output Representation using Deep Conditional Generative Models. In C Cortes, N D Lawrence, D D Lee, M Sugiyama, and R Garnett (eds.), Advances in Neural Information Processing Systems 28, pp. 3483–3491. Curran Associates, Inc., 2015. ",
+        "bbox": [
+            174,
+            329,
+            825,
+            386
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Masahiro Suzuki, Kotaro Nakayama, and Yutaka Matsuo. Joint multimodal learning with deep generative models. pp. 1–12, 2017. ",
+        "bbox": [
+            171,
+            392,
+            823,
+            421
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sebastian Thrun, Wolfram Burgard, and Dieter Fox. Probabilistic Robotics. MIT Press, Cambridge, Mass., 2005. ISBN 9780262201629. ",
+        "bbox": [
+            173,
+            428,
+            821,
+            457
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Udacity. Self-Driving Car: Annotated Driving Dataset, 2016. URL https://github.com/ udacity/self-driving-car/tree/master/annotations. ",
+        "bbox": [
+            173,
+            463,
+            821,
+            493
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ramakrishna Vedantam, Ian Fischer, Jonathan Huang, and Kevin Murphy. Generative Models of Visually Grounded Imagination. pp. 1–21, 2017. URL http://arxiv.org/abs/1705. 10762. ",
+        "bbox": [
+            173,
+            500,
+            823,
+            541
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Weiran Wang, Xinchen Yan, Honglak Lee, and Karen Livescu. Deep Variational Canonical Correlation Analysis. 1, 2016. URL http://arxiv.org/abs/1610.03454. ",
+        "bbox": [
+            173,
+            549,
+            821,
+            579
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Han Xiao, Kashif Rasul, and Roland Vollgraf. Fashion-MNIST: a Novel Image Dataset for Benchmarking Machine Learning Algorithms. pp. 1–6, 2017. URL http://arxiv.org/abs/ 1708.07747. ",
+        "bbox": [
+            174,
+            585,
+            825,
+            627
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            650,
+            281,
+            666
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "6.1 EXTENSION TO THREE MODALITIES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            681,
+            464,
+            695
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The proposed, as well as approach by Suzuki et al. (2017), can be extended to multiple modalities $\\mathcal { M } = \\{ a , b , c \\}$ . The conditional marginal log-likelihood of $a$ can be written as ",
+        "bbox": [
+            174,
+            707,
+            823,
+            734
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4d527b6b6e19e36aa14a0f2e75bfed6ed49f733925544527672e8377a5a079cd.jpg",
+        "text": "$$\n\\begin{array} { r } { \\log p ( a | b , c ) { = } \\mathcal { L } _ { \\widetilde { \\mathrm { M } } _ { \\mathrm { a } } } { + } \\mathrm { D } _ { \\mathrm { K L } } ( q ( z | \\mathcal { M } ) \\Vert p ( z | \\mathcal { M } ) ) { \\geq } \\mathcal { L } _ { \\widetilde { \\mathrm { M } } _ { \\mathrm { a } } } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            325,
+            737,
+            669,
+            757
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "6.1.1 JMVAE FOR THREE MODALITIES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            765,
+            460,
+            780
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The VI between a set of distributions $\\mathcal { M }$ can be written as $\\begin{array} { r } { - \\mathbb { E } _ { p ( \\mathcal { M } ) } \\sum _ { m \\in \\mathcal { M } } \\log p ( m | \\mathcal { M } \\setminus m ) } \\end{array}$ , which leads to an expression of maximizing the ELBO of negative VI (c.f. Suzuki et al. (2017)). Following this approach, the log-likelihood $L _ { 3 \\mathrm { M } }$ can be expressed by the ELBOs, by utilizing Eq. 14, of their conditionals and KL divergence: ",
+        "bbox": [
+            174,
+            789,
+            825,
+            844
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/18351dcfb4a59c88dbe281c9331b5011cadf4651a3adbd92b1c3fb97bafb9fdd.jpg",
+        "text": "$$\n\\begin{array} { r l } & { L _ { \\mathrm { 3 M } } = \\log p ( a | b , c ) + \\log ( p ( b | a , c ) ) + \\log ( p ( c | b , c ) ) } \\\\ & { \\qquad \\geq \\mathcal { L } _ { \\widetilde { \\mathrm { M } } _ { \\mathrm { a } } } + \\mathcal { L } _ { \\widetilde { \\mathrm { M } } _ { \\mathrm { b } } } + \\mathcal { L } _ { \\widetilde { \\mathrm { M } } _ { \\mathrm { c } } } } \\\\ & { \\qquad \\geq \\mathcal { L } _ { \\widetilde { \\mathrm { J } } } - \\mathrm { D } _ { \\mathrm { K L } } ( q ( z | a , b , c ) \\| p ( z | b , c ) ) } \\\\ & { \\qquad - \\mathrm { D } _ { \\mathrm { K L } } ( q ( z | a , b , c ) \\| p ( z | a , c ) ) - \\mathrm { D } _ { \\mathrm { K L } } ( q ( z | a , b , c ) \\| p ( z | b , c ) ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            294,
+            845,
+            702,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "with $\\mathcal { L } _ { \\widetilde { \\mathrm { J } } }$ being the joint ELBO of a joint probability $p ( \\mathcal { M } )$ which expression is analog to Eq. 2. ",
+        "bbox": [
+            171,
+            103,
+            794,
+            119
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "6.1.2 $\\mathbf { M } ^ { 2 } \\mathbf { V } \\mathbf { A } \\mathbf { E }$ FOR THREE MODALITIES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            135,
+            460,
+            150
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Applying the proposed scheme to the joint log-likelihood of three modalities results in the following expression: ",
+        "bbox": [
+            176,
+            159,
+            823,
+            188
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d881db35c22fe4796322befe0608dfa8638126012acc3af26408f3f50a5a964c.jpg",
+        "text": "$$\n\\begin{array} { r l } & { L _ { 3 \\mathrm { M } ^ { 2 } } } \\\\ & { = 3 / 3 \\log p ( a , b , c ) = 1 / 3 \\log p ( a , b , c ) ^ { 3 } } \\\\ & { = 3 / 3 \\log p ( a , b , c ) p ( a , b , c ) p ( a , b , c ) } \\\\ & { = 1 / 3 \\log p ( a , b ) p ( b , c ) p ( a , c ) p ( a | b , c ) p ( b | a , c ) p ( c | a , b ) } \\\\ & { = 1 / 3 ( \\log ( p ( a , b ) ) + \\log ( p ( b , c ) ) + \\log ( p ( a , c ) ) } \\\\ & { \\quad + \\log p ( a | b , c ) + \\log p ( b | a , c ) + \\log p ( c | a , b ) ) } \\\\ & { = 1 / 3 ( 2 / 2 ( \\log p ( a , b ) + \\log p ( b , c ) + \\log p ( a , c ) ) + L _ { 3 \\mathrm { M } } ) } \\\\ & { = 1 / 6 \\big ( \\log p ( a , b ) ^ { 2 } + \\log p ( b , c ) ^ { 2 } + \\log p ( a , c ) ^ { 2 } \\big ) + L _ { 3 \\mathrm { M } / 3 } } \\\\ & { = 1 / 6 \\big ( L _ { \\mathrm { M } ^ { 2 } \\mathrm { ~ * } } + L _ { \\mathrm { M } _ { \\mathrm { M } ^ { 2 } \\mathrm { s } } } + L _ { \\mathrm { M } ^ { 2 } \\mathrm { s } } \\big ) + 1 / 3 L _ { 3 \\mathrm { M } } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            269,
+            194,
+            629,
+            364
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "From here on, one can substitute all log-likelihoods given the expressions in Sec. 3 and ??, to derive the ELBO L3M2 . ",
+        "bbox": [
+            173,
+            367,
+            825,
+            397
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "6.1.3 ${ \\bf M } ^ { 2 }$ VAE DERIVATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            411,
+            377,
+            428
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1f62f088926753f829ccf7a827a2c1257fe71322081e06afc9f8e206a343424a.jpg",
+        "text": "$$\n\\begin{array} { r l } & { L _ { \\mathrm { M } ^ { 2 } , \\boldsymbol { \\mathcal { M } } } = \\log p ( \\boldsymbol { \\mathcal { M } } ) \\stackrel { \\mathrm { m u l } ~ , 1 } { = } \\stackrel { | \\mathcal { M } | / | \\mathcal { M } | } { | \\mathcal { M } | } \\log p ( \\boldsymbol { \\mathcal { M } } ) \\stackrel { \\log . \\mathrm { m u l } . } { = } 1 / | \\mathcal { M } | \\log p ( \\boldsymbol { \\mathcal { M } } ) \\stackrel { | \\mathcal { M } | } { = } } \\\\ & { \\stackrel { \\mathrm { B a y e s } ~ } { = } 1 / | \\mathcal { M } | \\displaystyle \\sum _ { m \\in \\mathcal { M } } \\log p ( \\boldsymbol { \\mathcal { M } } \\setminus m ) p ( m | \\mathcal { M } \\setminus m ) } \\\\ & { \\stackrel { \\mathrm { l o g . a d d } } { = } 1 / | \\mathcal { M } | \\displaystyle \\sum _ { m \\in \\mathcal { M } } \\log p ( \\boldsymbol { \\mathcal { M } } \\setminus m ) + \\log p ( m | \\mathcal { M } \\setminus m ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            264,
+            441,
+            732,
+            541
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The expression $\\begin{array} { r } { \\sum _ { m \\in \\mathcal { M } } \\log p ( m | \\mathcal { M } \\setminus m ) } \\end{array}$ is the general form of the marginal log-likelihood for the variation of information (VI), as introduced by Suzuki et al. (2017) for the JMVAE, for any set $\\mathcal { M }$ . Thus, it can be directly substituted with $L _ { \\mathrm { M } _ { \\mathcal { M } } }$ . The expression $\\textstyle \\sum _ { m \\in { \\mathcal { M } } } \\log p ( { \\mathcal { M } } \\setminus m )$ is the combination of all joint log-likelihoods of the subsets of $\\mathcal { M }$ which have one less element. Therefore, this term can be rewritten as ",
+        "bbox": [
+            173,
+            546,
+            825,
+            616
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/734b3f2e45c57a9858588470ab9577023fbac4dde6a1f83b27133112dee197d6.jpg",
+        "text": "$$\n\\sum _ { m \\in \\mathcal { M } } \\log p ( \\mathcal { M } \\setminus m ) = \\sum _ { \\widetilde { m } \\in \\widetilde { \\mathcal { M } } } \\log p ( \\widetilde { m } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            370,
+            621,
+            627,
+            657
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "with $\\widetilde { \\mathcal { M } } = \\{ m | m \\in \\mathcal { P } ( \\mathcal { M } ) , | m | = | \\mathcal { M } | - 1 \\}$ Finally, $\\log p ( \\widetilde { m } )$ can be substituted by $L _ { \\mathrm { M } ^ { 2 } \\widetilde { m } }$ without loss of generality. However, it is worth noticing that substitution stops at the end of recursion and therefore, all final expressions $\\log p ( \\widetilde { m } ) \\forall | \\widetilde { m } | \\equiv 1$ remain. $\\boxed { \\begin{array} { r l } \\end{array} }$ ",
+        "bbox": [
+            174,
+            666,
+            825,
+            712
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "6.1.4 NETWORK ARCHITECTURE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            727,
+            416,
+            741
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We designed all VAEs such that the latent space prior is given by a Gaussian with unit variance. Furthermore, all VAEs sample from a Gaussian variational distribution that is parametrized by the encoder networks. A summary of all architectures used in this paper can be seen in Tbl. 2. The reconstruction loss for calculating the evidence lower bound was performed by binary cross-entropy (BCE) for the e-MNIST and root-mean-squared error (RMS) for the MoG experiment. ",
+        "bbox": [
+            173,
+            751,
+            826,
+            821
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Furthermore, the CVAE for training the e-MNIST dataset is designed as depicted in Tbl. 3. ",
+        "bbox": [
+            169,
+            827,
+            769,
+            843
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/fdbeba8a2836a3b9cd904ccba31ec6840aad774c457e22e8595e38ba0b612625.jpg",
+        "table_caption": [
+            "Table 2: Various VAE architectures and optimizers for the e-MNIST and MoG experiments. $\\mathrm { { u m / m m } }$ stand for uni- and multi-modal while fc refers to fully-connected layers. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Issue</td><td>VAE</td><td>Optimizer</td><td colspan=\"2\">VAEarchitecture</td><td></td></tr><tr><td>e-MNIST</td><td>JMVAE-Z.</td><td>adam</td><td>encoder decoder</td><td>fc 2x784-2x128-2x64-concat-64-2 (ReLU) fc 2x64-2x128-2x786 (tanh)</td><td rowspan=\"3\"></td></tr><tr><td>e-MNIST</td><td>tVAE</td><td>adam</td><td>um enc. mm enc. decoder</td><td>fc 784-128-64-2 (ReLU) fc 2x784-2x128-2x64-concat-64-2 (ReLU) fc 2x64-2x128-2x786 (tanh)</td></tr><tr><td>e-MNIST</td><td>M²VAE</td><td>adam</td><td>um enc. mm enc. decoder</td><td>fc 784-128-64-2 (ReLU) fc 2x784-2x128-2x64-concat-64-2 (ReLU) fc 2x64-2x128-2x786 (tanh)</td></tr><tr><td>MoG</td><td>JMVAE-Z.</td><td>rmsprop</td><td>encoder decoder</td><td>fc 2x2-2x128-concat-64-2 (ReLU) fc 2x128-2x2 (tanh)</td><td rowspan=\"2\"></td></tr><tr><td>MoG</td><td>tVAE</td><td>rmsprop</td><td>um enc. mm enc. decoder</td><td>fc 2x2-2x128-2x2 (ReLU) fc 2x2-2x128-concat-64-2 (ReLU) fc 2x128-2x2 (tanh)</td></tr><tr><td>MoG</td><td>M²VAE</td><td>rmsprop</td><td>um enc. mm enc. decoder</td><td></td><td>fc 2-128-2 (ReLU) fc 2x2-2x128-concat-64-2 (ReLU) fc 2x128-2x2 (tanh)</td></tr></table>",
+        "bbox": [
+            174,
+            246,
+            823,
+            488
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/7618f0844bb08e90c8c832311556d30cd3388a9d1f05f2b308b5e19c74816fd5.jpg",
+        "table_caption": [
+            "Table 3: CVAE architecture for each dataset MNIST and fashion-MNIST. The label as one-hotvector is concatenated after the convolution layers and fed into the fully-connected (fc) layers. For convolutional architectures the numbers in parenthesis indicate strides, while padding is always same. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>encoder decoder</td><td>conv1x2x2-64x2x2(2)-64x3x3-64x3x3-concatlabelC-fc 128-2 concat label C-fc 128-deconv reverse of encoder (ReLU)</td></tr></table>",
+        "bbox": [
+            246,
+            786,
+            750,
+            814
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "CVAE architecture ",
+        "text_level": 1,
+        "bbox": [
+            465,
+            772,
+            602,
+            785
+        ],
+        "page_idx": 13
+    }
+]