Add files using upload-large-folder tool

parse/train/P6_q1BRxY8Q/P6_q1BRxY8Q.md

@@ -0,0 +1,346 @@
+# LEARNING SAFE MULTI-AGENT CONTROL WITH DECENTRALIZED NEURAL BARRIER CERTIFICATES
+
+Zengyi ${ \bf { Q } i n } ^ { 1 }$ , Kaiqing Zhang2, Yuxiao Chen3, Jingkai Chen1 and Chuchu Fan1
+
+1Massachusetts Institute of Technology 2University of Illinois Urbana-Champaign 3California Institute of Technology {qinzy, chuchu}@mit.edu
+
+# ABSTRACT
+
+We study the multi-agent safe control problem where agents should avoid collisions to static obstacles and collisions with each other while reaching their goals. Our core idea is to learn the multi-agent control policy jointly with learning the control barrier functions as safety certificates. We propose a new joint-learning framework that can be implemented in a decentralized fashion, which can adapt to an arbitrarily large number of agents. Building upon this framework, we further improve the scalability by incorporating neural network architectures that are invariant to the quantity and permutation of neighboring agents. In addition, we propose a new spontaneous policy refinement method to further enforce the certificate condition during testing. We provide extensive experiments to demonstrate that our method significantly outperforms other leading multi-agent control approaches in terms of maintaining safety and completing original tasks. Our approach also shows substantial generalization capability in that the control policy can be trained with 8 agents in one scenario, while being used on other scenarios with up to 1024 agents in complex multi-agent environments and dynamics. Videos and source code can be found on the website1.
+
+# 1 INTRODUCTION
+
+Machine learning (ML) has created unprecedented opportunities for achieving full autonomy. However, learning-based methods in autonomous systems (AS) can and do fail due to the lack of formal guarantees and limited generalization capability, which poses significant challenges for developing safety-critical AS, especially large-scale multi-agent AS, that are provably dependable.
+
+On the other side, safety certificates (Chang et al. (2019); Jin et al. (2020); Choi et al. (2020)), which widely exist in control theory and formal methods, serve as proofs for the satisfaction of the desired properties of a system, under certain control policies. For example, once found, a Control Barrier Function (CBF) ensures that the closed-loop system always stays inside some safe set (Wieland & Allgower, 2007; Ames et al., 2014) with a CBF Quadratic Programming (QP) supervisory controller. ¨ However, it is extremely difficult to synthesize CBF by hand for complex dynamic systems, which stems a growing interest in learning-based CBF (Saveriano & Lee, 2020; Srinivasan et al., 2020; Jin et al., 2020; Boffi et al., 2020; Taylor et al., 2020; Robey et al., 2020). However, all of these studies only concern single-agent systems. How to develop learning-based approaches for safe multi-agent control that are both provably dependable and scalable remains open.
+
+In multi-agent control, there is a constant dilemma: centralized control strategies can hardly scale to a large number of agents, while decentralized control without coordination often misses safety and performance guarantees. In this work, we propose a novel learning framework that jointly designs multi-agent control policies and safety certificate from data, which can be implemented in a decentralized fashion and scalable to an arbitrary number of agents. Specifically, we first introduce the notion of decentralized CBF as safety certificates, then propose the framework of learning decentralized CBF, with generalization error guarantees. The decentralized CBF can be seen as a contract among agents, which allows agents to learn a mutual agreement with each other on how to avoid collisions. Once such a controller is achieved through the joint-learning framework, it can be applied on an arbitrarily number of agents and in scenarios that are different from the training scenarios, which resolves the fundamental scalability issue in multi-agent control. We also propose several effective techniques in Section 4 to make such a learning process even more scalable and practical, which are then validated extensively in Section 5.
+
+Experimental results are indeed promising. We study both 2D and 3D safe multi-agent control problems, each with several distinct environments and complex nonholonomic dynamics. Our jointlearning framework performs exceptionally well: our control policies trained on scenarios with 8 agents can be used on up to 1024 agents while maintaining low collision rates, which has notably pushed the boundary of learning-based safe multi-agent control. Speaking of which, 1024 is not the limit of our approach but rather due to the limited computational capability of our laptop used for the experiments. We also compare our approach with both leading learning-based methods (Lowe et al., 2017; Zhang & Bastani, 2019; Liu et al., 2020) and traditional planning methods (Ma et al., 2019; Fan et al., 2020). Our approach outperforms all the other approaches in terms of both completing the tasks and maintaining safety.
+
+Contributions. Our main contributions are three-fold: 1) We propose the first framework to jointly learning safe multi-agent control policies and CBF certificates, in a decentralized fashion. 2) We present several techniques that make the learning framework more effective and scalable for practical multi-agent systems, including the use of quantity-permutation invariant neural network architectures in learning to handle the permutation of neighbouring agents. 3) We demonstrate via extensive experiments that our method significantly outperforms other leading methods, and has exceptional generalization capability to unseen scenarios and an arbitrary number of agents, even in quite complex multi-agent environments such as ground robots and drones. The video that demonstrates the outstanding performance of our method can be found in the supplementary material.
+
+Related Work. Learning-Based Safe Control via CBF. Barrier certificates (Prajna et al., 2007) and CBF (Wieland & Allgower, 2007) is a well-known effective tool for guaranteeing the safety ¨ of nonlinear dynamic systems. However, the existing methods for constructing CBFs either rely on specific problem structures (Chen et al., 2017b) or do not scale well (Mitchell et al., 2005). Recently, there has been an increasing interest in learning-based and data-driven safe control via CBFs, which primarily consist of two categories: learning CBFs from data (Saveriano & Lee, 2020; Srinivasan et al., 2020; Jin et al., 2020; Boffi et al., 2020), and CBF-based approach for controlling unknown systems (Wang et al., 2017; 2018; Cheng et al., 2019; Taylor et al., 2020). Our work is more pertinent to the former and is complementary to the latter, which usually assumes that the CBF is provided. None of these learning-enabled approaches, however, has addressed the multi-agent setting.
+
+Multi-Agent Safety Certificates and Collision Avoidance. Restricted to holonomic systems, guaranteeing safety in multi-agent systems has been approached by limiting the velocities of the agents (Van den Berg et al., 2008; Alonso-Mora et al., 2013). Later, Borrmann et al. (2015) Wang et al. (2017) have proposed the framework of multi-agent $C B F$ to generate collision-free controllers, with either perfectly known system dynamics (Borrmann et al., 2015), or with worst-case uncertainty bounds (Wang et al., 2017). Recently, Chen et al. (2020) has proposed a decentralized controller synthesized approach under this CBF framework, which is scalable to an arbitrary number of agents. However, in Chen et al. (2020) the CBF controller relies on online integration of the dynamics under the backup strategy, which can be computationally challenging for complex systems. Due to space limit, we omit other non-learning multi-agent control methods but acknowledge their importance.
+
+Safe Multi-Agent (Reinforcement) Learning (MARL). Safety concerns have drawn increasing attention in MARL, especially with the applications to safety-critical multi-agent systems (Zhang & Bastani, 2019; Qie et al., 2019; Shalev-Shwartz et al., 2016). Under the CBF framework, Cheng et al. (2020) considered the setting with unknown system dynamics, and proposed to design robust multiagent CBFs based on the learned dynamics. This mirrors the second category mentioned above in single-agent learning-based safe control, which is perpendicular to our focus. RL approaches have also been applied for multi-agent collision avoidance (Chen et al., 2017a; Lowe et al., 2017; Everett et al., 2018; Zhang et al., 2018). Nonetheless, no formal guarantees of safety were established in these works. One exception is Zhang & Bastani (2019), which proposed a multi-agent model predictive shielding algorithm that provably guarantees safety for any policy learned from MARL, which differs from our multi-agent CBF-based approach. More importantly, none of these MARLbased approaches scale to a massive number of, e.g., thousands of agents, as our approach does. The most scalable MARL platform, to the best of our knowledge, is Zheng et al. (2017), which may handle a comparable scale of agents as ours, but with discrete state-action spaces. This is in contrast to our continuous-space models that can model practical control systems such as robots and drones.
+
+# 2 PRELIMINARIES
+
+# 2.1 CONTROL BARRIER FUNCTIONS AS SAFETY CERTIFICATES
+
+One common approach for (single-agent) safety certificate is via control barrier functions (Ames et al., 2014), which can enforce the states of dynamic systems to stay in the safe set. Specifically, let $S \subset \mathbb { R } ^ { n }$ be the state space, ${ \cal S } _ { d } \subset { \cal S }$ is the dangerous set, $\mathcal { S } _ { s } = \mathcal { S } \backslash \check { \mathcal { S } } _ { d }$ is the safe set, which contains the set of initial conditions $S _ { 0 } \subset S _ { s }$ . Also define the space of control actions as $\mathcal { U } \subset \mathbb { R } ^ { m }$ . For a dynamic system $\dot { s } ( t ) = f ( s ( t ) , u ( t ) )$ , a control barrier function $h : \mathbb { R } ^ { n } \mapsto \mathbb { R }$ satisfies:
+
+$$
+( \forall s \in S _ { 0 } , h ( s ) \geq 0 ) \bigwedge ( \forall s \in S _ { d } , h ( s ) < 0 ) \bigwedge ( \forall s \in \{ s \mid h ( s ) \geq 0 \} , \nabla s h \cdot f ( s , u ) + \alpha ( h ) \geq 0 ) ,
+$$
+
+where $\alpha ( \cdot )$ is a class- $\mathcal { \kappa }$ function, i.e., $\alpha ( \cdot )$ is strictly increasing and satisfies $\alpha ( 0 ) = 0$ . For a control policy $\pi : S  \mathcal { U }$ and CBF $h$ , it is proved in Ames et al. (2014) that if $s ( 0 ) \in \{ s \mid h ( s ) \geq 0 \}$ and the three conditions in (1) are satisfied with $u = \pi ( x )$ , then $s ( t ) \in \{ s \mid h ( s ) \geq 0 \}$ for $\forall t \in [ 0 , \infty )$ , which means the state would never enter the dangerous set $\textstyle { S _ { d } }$ under $\pi$ .
+
+# 2.2 SAFETY OF MULTI-AGENT DYNAMIC SYSTEMS
+
+Consider a multi-agent system with $N$ agents, the joint state of which at time $t$ is denoted by $s ( t ) =$ $\{ s _ { 1 } ( t ) , s _ { 2 } ( t ) , \cdot \cdot \cdot , \bar { s } _ { N } ( t ) \}$ where $s _ { i } ( t ) \ \bar { \in } \ S _ { i } \ \subset \ \bar { \mathbb { R } } ^ { n }$ denotes the state of agent $i$ at time $t$ . The dynamics of agent $i$ is $\begin{array} { r } { \dot { s } _ { i } ( t ) = f _ { i } ( s _ { i } ( t ) , u _ { i } ( t ) ) } \end{array}$ where $u _ { i } ( t ) \in \mathcal { U } _ { i } \subset \mathbb { R } ^ { m }$ is the control action of agent $i$ . The overall state space and input space are denoted as ${ \cal { S } } \doteq \bigcirc _ { i = 1 } ^ { N } { \cal { S } } _ { i }$ , $\mathcal { U } \doteq \bigotimes _ { i = 1 } ^ { N } \mathcal { U } _ { i }$ . For each agent $i$ , we define $\mathcal { N } _ { i } ( t )$ as the set of its neighborhood agents at time $t$ . Let $o _ { i } ( t ) \in \mathbb { R } ^ { n \times | \mathcal { N } _ { i } ( t ) | }$ be the local observation of agent $i$ , which is the states of $| \mathcal { N } _ { i } ( t ) |$ neighborhood agents. Notice that the dimension of $o _ { i } ( t )$ is not fixed and depends on the quantity of neighboring agents. We assume that the safety of agent $i$ is jointly determined by $s _ { i }$ and $o _ { i }$ . Let $\mathcal { O } _ { i }$ be the set of all possible observations and $\mathcal { X } _ { i } : = \mathcal { S } _ { i } \times \mathcal { O } _ { i }$ be the state-observation space that contains the safe set $\mathcal { X } _ { i , s }$ , dangerous set $\mathcal { X } _ { i , d }$ and initial conditions $\mathcal { X } _ { i , 0 } \subset \mathcal { X } _ { i , s }$ . Let $d : \mathcal { X } _ { i }  \mathbb { R }$ describe the minimum distance from agent $i$ to other agents that it observes, $d ( s _ { i } , o _ { i } ) < \kappa _ { s }$ implies collision. Then $\mathcal { X } _ { i , s } = \{ ( s _ { i } , o _ { i } ) | d ( s _ { i } , o _ { i } ) \geq \kappa _ { s } \}$ and $\mathcal { X } _ { i , d } = \{ ( s _ { i } , o _ { i } ) | d ( s _ { i } , o _ { i } ) < \kappa _ { s } \}$ . Let $\bar { d } _ { i } : \mathcal { S }  \mathbb { R }$ be the lifting of $d$ from $\mathcal { X } _ { i }$ to $s$ , which is welldefined since there is a surjection from $s$ to $\mathcal { X } _ { i }$ . Then define $\mathcal { S } _ { s } \doteq \{ s \in \mathcal { S } | \forall i = 1 , . . . , N , \bar { d } _ { i } ( s ) \ge$ $\kappa _ { s } \}$ . The safety of a multi-agent system can be formally defined as follows:
+
+Definition 1 (Safety of Multi-Agent Systems). If the state-observation satisfies $d ( s _ { i } , o _ { i } ) \geq \kappa _ { s }$ for agent $i$ and time $t ,$ , then agent $i$ is safe at time $t$ . If for $\forall i$ , agent $i$ is safe at time $t$ , then the multi-agent system is safe at time $t$ , and $s \in \var S _ { s }$ .
+
+A main objective of this paper is to learn the control policy $\pi _ { i } ( s _ { i } ( t ) , o _ { i } ( t ) )$ for $\forall i$ such that the multi-agent system is safe. The control policy is decentralized (i.e., each agent has its own control policy and there does not exist a central controller to coordinate all the agents). In this way, our decentralized approach has the hope to scale to very a large number of agents.
+
+# 3 LEARNING FRAMEWORK FOR MULTI-AGENT DECENTRALIZED CBF
+
+# 3.1 DECENTRALIZED CONTROL BARRIER FUNCTIONS
+
+For a multi-agent dynamic system, the most na¨ıve CBF would be a centralized function taking into account the cross production of all agents’ states, which leads to an exponential blow-up in the state space and difficulties in modeling systems with an arbitrary number of agents. Instead, we consider a decentralized control barrier function $h _ { i } : \mathcal { X } _ { i } \mapsto \mathbb { R }$ :
+
+$$
+\begin{array} { r l } & { \left( \forall \left( s _ { i } , o _ { i } \right) \in \mathcal { X } _ { i , 0 } , h _ { i } ( s _ { i } , o _ { i } ) \geq 0 \right) \bigwedge \left( \forall \left( s _ { i } , o _ { i } \right) \in \mathcal { X } _ { i , d } , h _ { i } ( s _ { i } , o _ { i } ) < 0 \right) \bigwedge } \\ & { \left( \forall \left( s _ { i } , o _ { i } \right) \in \{ ( s _ { i } , o _ { i } ) \ \vert \ h _ { i } ( s _ { i } , o _ { i } ) \geq 0 \} , \nabla _ { s _ { i } } h _ { i } \cdot f _ { i } ( s _ { i } , u _ { i } ) + \nabla _ { o _ { i } } h _ { i } \cdot \dot { o _ { i } } ( t ) + \alpha \left( h _ { i } \right) \geq 0 \right) } \end{array}
+$$
+
+where ${ \dot { o } } _ { i } ( t )$ is the time derivative of the observation, which depends on the behavior of other agents. Although there is no explicit expression of this term, it can be evaluated and incorporated in the learning process. Note that the CBF $h _ { i } ( s _ { i } , o _ { i } )$ is local in the sense that it only depends on the local state $s _ { i }$ and observation $o _ { i }$ . We refer to the three conditions in (2) as decentralized CBF conditions. The following proposition shows that satisfying (2) guarantees the safety of the multi-agent system.
+
+Proposition 1 (Multi-Agent Safety Certificates with Decentralized CBF). If for $\forall i$ , the initial stateobservation $( s _ { i } ( 0 ) , o _ { i } ( 0 ) ) \in \{ ( s _ { i } , o _ { i } ) \mid h _ { i } ( s _ { i } , o _ { i } ) \geq 0 \}$ and the decentralized CBF conditions in (2) are satisfied, then $\forall i$ and $\forall t$ , $( s _ { i } ( t ) , o _ { i } ( t ) ) \in \{ ( s _ { i } , o _ { i } ) \mid h _ { i } ( s _ { i } , o _ { i } ) \geq 0 \}$ , which implies the state would never enter $\mathcal { X } _ { i , d }$ for any agent $i$ . Thus, by Definition $^ { l }$ , the multi-agent system is safe.
+
+The proof of Proposition 1 is provided in the supplementary material. The key insight of Proposition 1 is that for the whole multi-agent system, the CBFs can be applied in a decentralized fashion for each agent. Since $h _ { i } ( s _ { i } , o _ { i } ) ~ \geq ~ 0$ is invariant, by definition of $h _ { i }$ , $h _ { i } ( s _ { i } , o _ { i } ) ~ > ~ 0 ~ \implies$ $\bar { d } _ { i } ( s ) \geq \kappa _ { s }$ , which means agent $i$ never gets closer than $\kappa _ { s }$ to all its neighborhood agents. Therefore, $\forall i , h _ { i } ( s _ { i } , o _ { i } ) \geq 0$ implies that $\forall i , \bar { d _ { i } } \bar { ( s ) } \geq \kappa _ { s }$ , which by definition also means $s \in \var S _ { s }$ , and the multi-agent system is safe as defined in Definition 1.
+
+Notice that an agent only needs to care about its local information, and if all agents respect the same form of contract (i.e., the decentralized CBF conditions), the whole multi-agent system will be safe. The fact that global safety can be guaranteed by decentralized CBF is of great importance since it reveals that a centralized controller that coordinates all agents is not necessary to achieve safety. A centralized control policy has to deal with the dimension explosion when the number of agents grow, while a decentralized design can significantly improve the scalability to a large number of agents.
+
+# 3.2 LEARNING FRAMEWORK
+
+From Proposition 1, we know that if we can jointly learn the control policy $\pi _ { i } ( s _ { i } , o _ { i } )$ and control barrier function $h _ { i } ( s _ { i } , o _ { i } )$ such that the decentralized CBF conditions in (2) are satisfied, then the multiagent system is guaranteed to be safe. Next we formulate the optimization objective for the joint learning of $\pi _ { i } ( s _ { i } , o _ { i } )$ and $h _ { i } ( s _ { i } , o _ { i } )$ . Let $T \subset \mathbb { R } _ { + }$ be the time interval and $\tau _ { i } = \mathsf { \bar { \{ } }  s _ { i } ( t ) , o _ { i } ( t ) \} _ { t \in T }$ be a trajectory of state and observation of agent $i$ . Let $\mathcal { T } _ { i }$ be the set of all possible trajectories of agent $i$ . Let $\mathcal { H } _ { i }$ and $\nu _ { i }$ be the function classes of $h _ { i }$ and $\pi _ { i }$ . Define the function $y _ { i } : \mathcal { T } _ { i } \times \mathcal { H } _ { i } \times \mathcal { V } _ { i } \mapsto \mathbb { R }$ as:
+
+$$
+y _ { i } ( \tau _ { i } , h _ { i } , \pi _ { i } ) : = \operatorname* { m i n } \Big \{ \operatorname* { i n f } _ { \chi _ { i , 0 } \cap \tau _ { i } } h _ { i } ( s _ { i } , o _ { i } ) , \ \operatorname* { i n f } _ { \chi _ { i , d } \cap \tau _ { i } } - h _ { i } ( s _ { i } , o _ { i } ) , \ \operatorname* { i n f } _ { \chi _ { i , h } \cap \tau _ { i } } ( \dot { h } _ { i } + \alpha \left( h _ { i } \right) ) \Big \} .
+$$
+
+The set $\mathcal { X } _ { i , h } : = \{ ( s _ { i } , o _ { i } ) ~ | ~ h _ { i } ( s _ { i } , o _ { i } ) \geq 0 \}$ . Notice that the third item on the right side of Equation (3) depends on both the control policy and CBF, since $\begin{array} { r } { \dot { h } _ { i } = \nabla _ { s _ { i } } h _ { i } \cdot f _ { i } ( s _ { i } , u _ { i } ) + \nabla _ { o _ { i } } h _ { i } \cdot \dot { o _ { i } } ( t ) , u _ { i } = } \end{array}$ $\pi _ { i } ( s _ { i } , o _ { i } )$ . It is clear that if we can find $h _ { i }$ and $\pi _ { i } ( s _ { i } , o _ { i } )$ such that $y _ { i } ( \tau _ { i } , h _ { i } , \pi _ { i } ) > 0$ for $\forall \tau _ { i } \in \mathcal T _ { i }$ and $\forall i$ , then the conditions in (2) are satisfied. For each agent $i$ , assume that we are given $z _ { i }$ i.i.d trajectories $\{ \tau _ { i } ^ { 1 } , \tau _ { i } ^ { 2 } , \cdot \cdot \cdot , \tau _ { i } ^ { z _ { i } } \}$ drawn from distribution $\mathcal { D } _ { i }$ during training. We solve the objective:
+
+$\mathrm { F o r ~ a l l ~ } i , \mathrm { ~ f i n d ~ } h _ { i } \in \mathcal { H } _ { i } \mathrm { ~ a n d ~ } \pi _ { i } \in \mathcal { V } _ { i } , \quad \mathrm { ~ s . t . ~ } \quad y _ { i } ( \tau _ { i } ^ { j } , h _ { i } , \pi _ { i } ) \geq \gamma , \forall j = 1 , 2 , \cdots z _ { i } ,$ (4) where $\gamma > 0$ is a margin for the satisfaction of the CBF condition in (2). Following standard results from statistical learning theory, it is possible to establish the generalization guarantees of the solution to (4) to unseen data drawn from $\mathcal { D } _ { i }$ . See a detailed statement of the results in Appendix B. The bound depends on the richness of the function classes, the margin $\gamma$ , as well as the number of samples used in (4). However, we note that such a generalization bound is only with respect to the open-loop data drawn from $\mathcal { D } _ { i }$ , the training data distribution, not to the closed-loop data in the testing when the learned controller is deployed. It is known to be challenging to handle the distribution shift between the training and testing due to the closed-loop effect. See, e.g., a recent result along this line in the context of imitation learning (Tu et al., 2021). We leave a systematic treatment of this closed-loop generalization guarantee for learning CBF in our future work. Finally, we note that in our experiments, we solve (4) and update the controller in an iterative fashion: run the closed-loop system with a certain controller to sample training data online and formulate (4), then update the controller by the solution of (4). We run the system using the updated controller and re-generate new samples to solve for a new controller. At the steady stage of this iterative process, the training and testing distribution shift becomes negligible, which validates the use of the generalization bounds given in Proposition 3. See more details of this implementation in Section 4.1, and more discussion on this point in the Remark in Appendix B.
+
+![](images/2cf2e0500786ab6b46aec406431650ab39920e349ff09f2f3ef205e2125f6607.jpg)  
+Figure 1: The computational graph of the control-certificate jointly learning framework in multi-agent systems. Only the graph for agent $_ { i }$ is shown because agents have the same graph and the computation is decentralized.
+
+Besides the generalization guarantee, there also exists several other gaps between the formulation in (4) and the practical implementation. First, (4) does not provide a concrete way of designing loss functions to realize the optimization objectives. Second, there are still $N$ pairs of functions $( h _ { i } , \pi _ { i } )$ to be learned. Unfortunately, the dimension of the input $o _ { i }$ of the functions $h _ { i } , \ \pi _ { i }$ are different for each agent $i$ , and will even change over time in practice, as the proximity of other agents is timevarying, leading to time-varying local observations. To scale to an arbitrary number of agents, $h _ { i }$ and $\pi _ { i }$ should be invariant to the quantity and permutation of neighbourhood agents. Third, (4) does not provide ways to deal with scenarios where the decentralized CBF conditions are not (strictly) satisfied, i.e., where problem (4) is not even feasible, which may very likely occur when the system becomes too complex or the function classes are not rich enough. To this end, we propose effective approaches to solving these issues, facilitating the scalable learning of safe multi-agent control in practice, as to be introduced next.
+
+# 4 SCALABLE LEARNING OF DECENTRALIZED CBF IN PRACTICE
+
+Following the theory in Section 3, we consider the practical learning of safe multi-agent control with neural barrier certificates, i.e., using neural networks for $\mathcal { H }$ and $\nu$ . We will present the formulation of loss functions in Section 4.1, which corresponds to the objective in (4). Section 4.2 presents the neural network architecture of $h _ { i }$ and $\pi _ { i }$ , which are invariant to the quantity and permutation of neighboring agents. Section 4.3 demonstrates a spontaneous policy refinement method that enables the control policy to satisfy the decentralized CBF conditions as possible as it could during testing.
+
+# 4.1 LOSS FUNCTIONS OF JOINTLY LEARNING CONTROLLERS AND BARRIER CERTIFICATES
+
+Based on Section 3.2. the main idea is to jointly learn the control policies and control barrier functions in multi-agent systems. During training, the CBFs regulate the control policies to satisfy the decentralized CBF conditions (2) so that the learned policies are safe. All agents are put into a single environment to generate experiences, which are combined to minimize the empirical loss function $\mathcal { L } ^ { c } = \Sigma _ { i } \mathcal { L } _ { i } ^ { c }$ , where $\mathcal { L } _ { i } ^ { c }$ is the loss function for agent $i$ formulated as:
+
+$$
+\begin{array} { r l } & { \mathcal { L } _ { i } ^ { c } ( \boldsymbol { \theta } _ { i } , \boldsymbol { \omega } _ { i } ) = \displaystyle \sum _ { s _ { i } \in \mathcal { X } _ { i , 0 } } \operatorname* { m a x } \Big ( 0 , \gamma - h _ { i } ^ { \theta _ { i } } ( s _ { i } , \boldsymbol { \omega } _ { i } ) \Big ) + \displaystyle \sum _ { s _ { i } \in \mathcal { X } _ { i , d } } \operatorname* { m a x } \Big ( 0 , \gamma + h _ { i } ^ { \theta _ { i } } ( s _ { i } , \boldsymbol { \omega } _ { i } ) \Big ) } \\ & { \quad \quad \quad + \displaystyle \sum _ { s _ { i } \in \mathcal { X } _ { i , h } } \operatorname* { m a x } \Big ( 0 , \gamma - \nabla s _ { i } h _ { i } ^ { \theta _ { i } } \cdot f _ { i } \big ( s _ { i } , \pi _ { i } ^ { \omega _ { i } } \big ( s _ { i } , \boldsymbol { \sigma } _ { i } \big ) \big ) - \nabla _ { \boldsymbol { \sigma } _ { i } } h _ { i } ^ { \theta _ { i } } \cdot \dot { \boldsymbol { \sigma } _ { i } } - \alpha \big ( h _ { i } ^ { \theta _ { i } } \big ) \Big ) , } \end{array}
+$$
+
+where $\gamma$ is the margin defined in Section 3.2. We choose $\gamma = 1 0 ^ { - 2 }$ in implementation. $\theta _ { i }$ and $\omega _ { i }$ are neural network parameters. On the right side of Equation (7), the three items enforce the three CBF conditions respectively. Directly computing the third term could be challenging since we need to evaluate $\dot { o } _ { i }$ , which is the time derivative of the observation. Instead, we approximate $\dot { h } ( s _ { i } , o _ { i } ) = \nabla _ { s _ { i } } h _ { i } ^ { \theta _ { i } } \cdot f _ { i } \left( s _ { i } , \pi _ { i } ^ { \omega _ { i } } \ ( s _ { i } , o _ { i } ) \right) + \nabla _ { o _ { i } } h _ { i } ^ { \theta _ { i } } \cdot \dot { o } _ { i }$ numerically by $\begin{array} { r } { \dot { h } ( s _ { i } , o _ { i } ) = [ h ( s _ { i } ( t + \Delta t ) , o _ { i } ( t + } \end{array}$ $\Delta t ) ) - h ( s _ { i } ( t ) , o _ { i } ( t ) ) ] / \Delta t$ . For the class- $\mathcal { \kappa }$ function $\alpha ( \cdot )$ , we simply choose a linear function $\alpha ( h ) = \lambda h$ . Note that $\mathcal { L } ^ { c }$ mainly considers safety instead of goal reaching. To train a safe control policy $\pi _ { i } ( s _ { i } , o _ { i } )$ that can drive the agent to the goal state, we also minimize the distance between $u _ { i }$ and $u _ { i } ^ { g }$ , where $\dot { u } _ { i } ^ { g }$ is the reference control input computed by classical approaches (e.g., LQR and PID controllers) to reach the goal. The goal reaching loss $\dot { \mathcal { L } ^ { g } } = \Sigma _ { i } \mathcal { L } _ { i } ^ { g }$ , where $\mathcal { L } _ { i } ^ { g }$ is formulated as $\begin{array} { r } { \mathcal { L } _ { i } ^ { g } ( \omega _ { i } ) = \sum _ { s _ { i } \in \mathcal { X } } | | \pi _ { i } ^ { \omega _ { i } } ( s _ { i } , o _ { i } ^ { \overline { { \it \Delta } } } ) - u _ { i } ^ { g } ( s _ { i } ) | | _ { 2 } } \end{array}$ . The final loss function $\mathcal { L } = \mathcal { L } ^ { c } + \eta \mathcal { L } ^ { g }$ , where $\eta$ is a balance weight that is set to 0.1 in our experiments. We present the computational graph in Figure 1 to help understand the information flow.
+
+In training, all agents are put into the specific environment, which is not necessarily the same as the testing environment, to collect state-observation pairs $( s _ { i } , o _ { i } )$ under their current policies with probability $1 - \iota$ and random policies with probability $\iota$ , where $\iota$ is set to be 0.05 in our experiment. The collected $( s _ { i } , o _ { i } )$ are stored as a temporary dataset and in every step of policy update, 128 $( s _ { i } , o _ { i } )$ are randomly sampled from the temporary dataset to calculate the total loss $\mathcal { L }$ . We minimize $\mathcal { L }$ by applying stochastic gradient descent with learning rate $1 0 ^ { - 3 }$ and weight decay $1 0 ^ { - 6 }$ to $\theta _ { i }$ and $\omega _ { i }$ , which are the parameters of the CBF and control policies. Note that the gradients are computed by back-propagation rather than policy gradients because $\mathcal { L }$ is differentiable w.r.t. $\theta _ { i }$ and $\omega _ { i }$ .
+
+![](images/73409133d23e71e870a6c83ffdff633b35b6e1879626af756ba84a6c9f82ed5b.jpg)  
+Figure 2: Neural network architecture of the control policy. The blue part indicates the quantity-permutation invariant observation encoder, which maps $o _ { i } ( t ) \in \mathbb { R } ^ { \bar { n } \times | \mathcal { N } _ { i } ( t ) | }$ with time-varying dimension to a fixed length vector. The network takes the state $s _ { i }$ and local observation $o _ { i }$ as input to compute a control action $u _ { i }$ . The neural network of the decentralized CBF $h _ { i }$ has a similar architecture except that the output is a scalar.
+
+Iterative Data Collection and Training. It is important to note that we did not use a fixed set of state-observation pairs to train the decentralized CBF and controllers. Instead, we adopted an on-policy training strategy, where the training data are collected by running the current system. The collected state-observation pairs are stored in temporary dataset that is used to calculate the loss terms and update the decentralized CBF and controllers via gradient descent. Then the updated controllers are used to run the system and re-generate new state-observation pairs as training data. The iterative data collection and training is performed until the loss converges. Such a training process is crucial for generalizing to testing scenarios. More discussion on this point can be found in the Remark in Appendix B.
+
+# 4.2 QUANTITY-PERMUTATION INVARIANT OBSERVATION ENCODER
+
+Recall that in Section 3.1, we define $o _ { i }$ as the local observation of agent $i$ . $o _ { i }$ contains the states of neighboring agents and its dimension can change dynamically. In order to scale to an arbitrary number of agents, there are two pivotal principles of designing the neural network architectures of $h _ { i } ( s _ { i } , o _ { i } )$ and $\pi _ { i } ( s _ { i } , o _ { i } )$ . First, the architecture should be able to dynamically adapt to the changing quantity of observed agents that affects the dimension of $o _ { i }$ . Second, the architecture should be invariant to the permutation of observed agents, which should not affect the output of $h _ { i }$ or $\pi _ { i }$ . All these challenges arise from encoding the local observation $o _ { i }$ . Inspired by PointNet (Qi et al., 2017), we leverage the max pooling layer to build the quantity-permutation invariant observation encoder.
+
+Let us start with a simple example with input observation $o _ { i } ( t ) \in \mathbb { R } ^ { n \times | \mathcal { N } _ { i } ( t ) | }$ , where $n$ is the dimension of state and $\tilde { \mathcal { N } _ { i } } ( t )$ is the set of the neighboring agents at time $t$ . $n$ is fixed while $\mathcal { N } _ { i } ( t )$ can change from time to time. The permutation of the columns of $o _ { i }$ is also dynamic. Denote the weight matrix as $W \in \mathbb { R } ^ { p \times n }$ and the element-wise ReLU activation function as $\sigma ( \cdot )$ . Define the row-wise max pooling operation as $\operatorname { R o w M a x } ( \cdot )$ , which takes a matrix as input and outputs the maximum value of each row. Consider the following mapping $\rho : \mathbb { R } ^ { n \times | \mathcal { N } _ { i } ( t ) | } \mapsto \mathbb { R } ^ { p }$ formulated as
+
+$$
+\rho ( o _ { i } ) = \operatorname { R o w M a x } ( \sigma ( W o _ { i } ) ) ,
+$$
+
+where $\rho$ maps a matrix $o _ { i }$ whose column has dynamic dimension and permutation to a fixed length feature vector $\rho ( o _ { i } ) \in \mathbb { R } ^ { p }$ . The dimension of $\rho ( o _ { i } )$ remains the same even if the number of columns of $o _ { i } ( t )$ , which is $| \mathcal { N } _ { i } ( t ) |$ , change over time. The network architecture of the control policy is shown in Figure 2, which uses the $\mathrm { R o w M a x } ( \cdot )$ operation. The network of the control barrier function is similar except that the output is a scalar instead of a vector.
+
+# 4.3 SPONTANEOUS ONLINE POLICY REFINEMENT
+
+We propose a spontaneous online policy refinement approach that produces even safer control policies in testing than the neural network has actually learned during training. When the model dynamics or environment settings are too complex and exceed the capability of the control policy, the decentralized CBF conditions can be violated at some points along the trajectories. Thanks to the control barrier function jointly learned with the control policy, we are able to refine the control input $u _ { i }$ online by minimizing the violation of the decentralized CBF conditions. That is, the learned CBF can serve as a guidance on generating updated $u _ { i }$ in unseen scenarios to guarantee safety. This is also a standard technique used in (non-learning) CBF control where the CBF $h$ is usually computed first using optimization methods like Sum-of-Squares, then the control inputs $u$ are computed online using $h$ by solving quadratic programming problems $\mathrm { { X u } }$ et al., 2017; Ames et al., 2017). In the experiments, we also study the effects of such an online policy refinement step.
+
+![](images/2a5edc93a08085c0cc589150119378875506631f2552df14036df51b6e598770.jpg)  
+Figure 3: Illustrations of the 2D environments used in the experiments. The Navigation and Predator-Prey environments are adopted from the multi-agent particle environment (Lowe et al., 2017). The Nested-Rings environment is adopted from Rodr´ıguez-Seda et al. (2014).
+
+Given the state $s _ { i }$ , local observation $o _ { i }$ , and action $u _ { i }$ computed by the control policy, consider the scenario where the third CBF condition is violated, which means $\nabla _ { s _ { i } } h _ { i } \cdot f _ { i } ( s _ { i } , u _ { i } ) + \nabla _ { o _ { i } } h _ { i } \cdot \dot { o } _ { i } +$ $\alpha ( h _ { i } ) < 0$ when $h _ { i } \geq 0$ . Let $e _ { i } \in \mathbb { R } ^ { m }$ be an increment of the action $u _ { i }$ . Define $\phi ( e _ { i } ) : \mathbb { R } ^ { m } \mapsto \mathbb { R }$ as
+
+$$
+\begin{array} { r } { \phi ( e _ { i } ) = \operatorname* { m a x } ( 0 , - \nabla _ { s _ { i } } h _ { i } \cdot f _ { i } ( s _ { i } , u _ { i } + e _ { i } ) - \nabla _ { o _ { i } } h _ { i } \cdot \dot { o } _ { i } - \alpha ( h _ { i } ) ) + \mu | | e _ { i } | | _ { 2 } ^ { 2 } . } \end{array}
+$$
+
+If the first term on the right side of Equation (9) is 0, then the third CBF condition is satisfied. We can enforce the satisfaction in every timestep of testing (after $u _ { i }$ is computed by the neural network controller) by finding an $e _ { i }$ that minimizes $\phi ( e _ { i } )$ . $\mu$ is a regularization factor that punishes large $e _ { i }$ . We set $\mu = 1$ in implementation and observed that in our experiment, a fixed $\mu$ is sufficient to make sure the $| | u _ { i } + e _ { i } | |$ do not exceed the constraint on control input bound. When evaluating on new scenarios and the constraints is violated, one can dynamically increase $\mu$ to strengthen the penalty. For every timestep during testing, we initialize $e _ { i }$ to zero and check the value of $\phi ( e _ { i } )$ . $\phi ( e _ { i } ) > 0$ indicates that the control policy is not good enough to satisfy the decentralized CBF conditions. Then we iteratively refine $e _ { i }$ by $\boldsymbol { e } _ { i } = \boldsymbol { e } _ { i } - \nabla _ { e } \phi ( \boldsymbol { e } _ { i } )$ until $\phi ( { \bf \dot { e } } _ { i } ) - \mu | | e _ { i } | | _ { 2 } ^ { 2 } = 0$ or the maximum allowed iteration is exceeded. The final control input is $u _ { i } = u _ { i } + e _ { i }$ . Such a refinement can flexibly refine the control input to satisfy the decentralized CBF conditions as much as possible.
+
+# 5 EXPERIMENTAL RESULTS
+
+Baseline Approaches. The baseline approaches we compare with include: MAMPS (Zhang & Bastani, 2019), PIC (Liu et al., 2020) and MADDPG (Lowe et al., 2017). For the drone tasks, we also compare with model-based planning method S2M2 (Chen et al., 2021). A brief description of each method is as follows. MAMPS leverages the model dynamics to iteratively switch to safe control policies when the learned policies are unsafe. PIC proposes the permutation-invariant critic to enhance the performance of multi-agent RL. We incorporate the safety reward to its reward function and denote this safe version of PIC as PIC-Safe. The safety reward is -1 when the agent enters the dangerous set. MADDPG is a pioneering work on multi-agent RL, and MADDPG-Safe is obtained by adding the safety reward to the reward function that is similar to PIC-Safe. S2M2 is a state-of-the-art model-based multi-agent safe motion planner. When directly planning all agents fails, S2M2 evenly divides the agent group to smaller partitions for replanning until paths that are collision-free for each partition are found. The agents then follow the generated paths using PID or LQR controllers.
+
+For each task, the environment model is the same for all the methods. The exact model dynamics are visible to model-based methods including MAMPS, S2M2 and our methods, and invisible to the model-free MADDPG and PIC. Since the model-free methods do not have access to model dynamics but instead the simulators, they are more data-demanding. The number of state-observation pairs to train MADDPG and PIC is $\mathrm { 1 0 ^ { 3 } }$ times more than that of model-based learning methods to make sure they converge to their best performance. When training the RL-based methods, the control action computed by LQR for goal-reaching is also fed to the agent as one of the inputs to the actor network. So the RL agents can learn to use LQR as a reference for goal-reaching.
+
+![](images/50fbdd9c300a659a85fe25c2c9616c3c2237d6bceffd4a2ae76b42fb2b699c31.jpg)  
+Figure 4: Safety rate and reward in the 2D tasks. Results are taken after each method converged and are averaged over 10 independent trials.
+
+![](images/a71b2e4a0ce411f7b7f486c70bbe2a5e26169f65ba8903b9286935c19e9cc13d.jpg)  
+Figure 5: Environments and results of 3D tasks. In Maze and Tunnel, the initial and target locations of each drone are randomly chosen. The drones start from the initial locations and aim to reach the targets without collision. The results are taken after each method converged and are averaged over 10 independent trials.
+
+Evaluation Criteria. Since the primal focus of this paper is the safety of multi-agent systems, $\frac { 1 } { N } \Sigma _ { i = 1 } ^ { N } \mathbb { E } _ { t \in T } [ \mathbb { I } ( ( s _ { i } ( t ) , o _ { i } ( t ) ) \in \mathcal { X } _ { s } ) ]$ when ewhere $\mathbb { I } ( \cdot )$ ating the methods. The safety rate is calculated asis the indicator function that is 1 when its argument is true or 0 otherwise. The observation $o _ { i }$ contains the states of other agents within the observation radius, which is 10 times the safe distance. The safe distance is set to be the diagonal length of the bounding box of the agent. In addition to the safety rate, we also calculate the average reward that considers how good the task is accomplished. The agent is given a $+ 1 0$ reward if it reaches the goal and a $^ { - 1 }$ reward if it enters the dangerous set. Note that the agent might enter the dangerous set for many times before reaching the goal. The upper-bound of the total reward for an agent is $+ 1 0$ , which is attained when the agent successfully reaches the goal and always stays in the safe set.
+
+Ground Robots. We consider three tasks illustrated in Figure 3. In the Navigation task, each agent starts from a random location and aims to reach a random goal. In the Predator-Prey task, the preys aim to gather the food while avoid being caught by the predators chasing the preys. We only consider the safety of preys but not predators. In the Nested-Rings task, the agents aim to follow the reference trajectories while avoid collision. In order for the RL-based agents to follow the rings trajectory, we also give the agents a negative reward proportional to the distance to the nearest point on the rings. When adding more agents to an environment, we will also enlarge the area of the environment to ensure the overall density of agents remains similar.
+
+![](images/af4194e3a8a320a4b7fceebc942fdcc50750c4cf8ad7733e701a1a7f13292501.jpg)  
+Figure 6: Generalization capability of MDBC in the 3D tasks. MDBC can be trained with 8 agent in one environment and generalize to 1024 agents in another environment in testing.
+
+Figure 4 demonstrates that when the number of agents grows (e.g., 32 agents), our approach (MDBC) can still maintain a high safety rate and average reward, while other methods have much worse performance. However, our method still cannot guarantee that the agents are $1 0 0 \%$ safe. The failure is mainly because we cannot make sure the decentralized CBF conditions are satisfied for every state-observation pair in testing even if they are satisfied on all training samples due to the generalization error. We also show the generalization capability of MDBC with up to 1024 in the appendix and also visualization results in the supplementary materials.
+
+Drones. We experiment with 3D drones whose dynamics are even more complex. Figure 5 demonstrates the environments and the results of each approach. Similar to the results of ground robots, when there are a large number of agents (e.g., 32 agents), our method can still maintain a high reward and safety rate, while other methods have worse performance. Figure 6 shows the generalization capability of our method across different environments and number of agents. For each experiment, we train 8 agents during training, but test with up to 1024 agents. The extra agents are added by copying the neural network parameters of the trained 8 agents. Results show that our method has remarkable generalization capability to diverse
+
+![](images/3dfefbc3ed9a75996845b4cb2ce3ebc641bcee6123d967bc25b8573a2d1e63cd.jpg)  
+Figure 7: Illustration of the Maze environment with 1024 drones. Videos can be found in the supplementary material.
+
+scenarios. Another related work Chen et al. (2020) can also handle the safe multi-drone control problem via CBF, but their CBF is handcrafted and based on quadratic programming to solve the $u _ { i }$ . Their paper only reported the results on two agents, and for 32 agents it would take more than 70 hours for a single run of evaluation (7000 steps and 36 seconds per step). By contrast, our method only takes $\sim 2 0 0 s$ for a single run of evaluation with 32 agents, showing a significant advantage in computational efficiency. For both the ground robot and drone experiments, we provide video demonstrations in the supplementary material.
+
+# 6 CONCLUSION
+
+This paper presents a novel approach of learning safe multi-agent control via jointly learning the decentralized control barrier functions as safety certificates. We provide the theoretical generalization bound, as well as the effective techniques to realize the learning framework in practice. Experiments show that our method significantly outperforms previous methods by being able to scale to an arbitrary number of agents, and demonstrates remarkable generalization capabilities to unseen and complex multi-agent environments.
+
+# 7 ACKNOWLEDGEMENT
+
+The authors would like to thank Nikolai Matni for the valuable discussions. The authors acknowledge support from the DARPA Assured Autonomy under contract FA8750-19-C-0089. The views, opinions and/or findings expressed are those of the authors and should not be interpreted as representing the official views or policies of the Department of Defense or the U.S. Government.
+
+# REFERENCES
+
+Javier Alonso-Mora, Andreas Breitenmoser, Martin Rufli, Paul Beardsley, and Roland Siegwart. Optimal reciprocal collision avoidance for multiple non-holonomic robots. In Distributed Autonomous Robotic Systems, pp. 203–216. Springer, 2013.
+
+Aaron D Ames, Jessy W Grizzle, and Paulo Tabuada. Control barrier function based quadratic programs with application to adaptive cruise control. In Decision and Control (CDC), 2014 IEEE 53rd Annual Conference on, pp. 6271–6278. IEEE, 2014.
+
+Aaron D Ames, Xiangru Xu, Jessy W Grizzle, and Paulo Tabuada. Control barrier function based quadratic programs for safety critical systems. IEEE Transactions on Automatic Control, 62(8): 3861–3876, 2017.
+
+Nicholas M Boffi, Stephen Tu, Nikolai Matni, Jean-Jacques E Slotine, and Vikas Sindhwani. Learning stability certificates from data. arXiv preprint arXiv:2008.05952, 2020.
+
+Urs Borrmann, Li Wang, Aaron D Ames, and Magnus Egerstedt. Control barrier certificates for safe swarm behavior. IFAC-Papers-OnLine, 48(27):68–73, 2015.
+
+Ya-Chien Chang, Nima Roohi, and Sicun Gao. Neural lyapunov control. In Advances in Neural Information Processing Systems, pp. 3245–3254, 2019.
+
+Jingkai Chen, Jiaoyang Li, Chuchu Fan, and Brian C. Williams. Scalable and safe multi-agent motion planning with nonlinear dynamics and bounded disturbances. In Proceedings of the ThirtyFifth AAAI Conference on Artificial Intelligence (AAAI 2021), 2021.
+
+Yu Fan Chen, Michael Everett, Miao Liu, and Jonathan P How. Socially aware motion planning with deep reinforcement learning. In IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), pp. 1343–1350. IEEE, 2017a.
+
+Yuxiao Chen, Huei Peng, and Jessy Grizzle. Obstacle avoidance for low-speed autonomous vehicles with barrier function. IEEE Transactions on Control Systems Technology, 26(1):194–206, 2017b.
+
+Yuxiao Chen, Andrew Singletary, and Aaron D Ames. Guaranteed obstacle avoidance for multirobot operations with limited actuation: a control barrier function approach. IEEE Control Systems Letters, 5(1):127–132, 2020.
+
+Richard Cheng, Gabor Orosz, Richard M Murray, and Joel W Burdick. End-to-end safe reinforce- ´ ment learning through barrier functions for safety-critical continuous control tasks. In AAAI Conference on Artificial Intelligence, volume 33, pp. 3387–3395, 2019.
+
+Richard Cheng, Mohammad Javad Khojasteh, Aaron D Ames, and Joel W Burdick. Safe multi-agent interaction through robust control barrier functions with learned uncertainties. arXiv preprint arXiv:2004.05273, 2020.
+
+Jason Choi, Fernando Castaneda, Claire J Tomlin, and Koushil Sreenath. Reinforcement learning ˜ for safety-critical control under model uncertainty, using control lyapunov functions and control barrier functions. arXiv preprint arXiv:2004.07584, 2020.
+
+Michael Everett, Yu Fan Chen, and Jonathan P How. Motion planning among dynamic, decisionmaking agents with deep reinforcement learning. In IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), pp. 3052–3059. IEEE, 2018.
+
+Chuchu Fan, Kristina Miller, and Sayan Mitra. Fast and guaranteed safe controller synthesis for nonlinear vehicle models. In Shuvendu K. Lahiri and Chao Wang (eds.), Computer Aided Verification, pp. 629–652, Cham, 2020. Springer International Publishing.
+
+Paul Glotfelter, Jorge Cortes, and Magnus Egerstedt. Nonsmooth barrier functions with applications ´ to multi-robot systems. IEEE control systems letters, 1(2):310–315, 2017.
+
+Wanxin Jin, Zhaoran Wang, Zhuoran Yang, and Shaoshuai Mou. Neural certificates for safe control policies. arXiv preprint arXiv:2006.08465, 2020.
+
+Iou-Jen Liu, Raymond A Yeh, and Alexander G Schwing. Pic: permutation invariant critic for multi-agent deep reinforcement learning. In Conference on Robot Learning, pp. 590–602, 2020.
+
+Ryan Lowe, Yi I Wu, Aviv Tamar, Jean Harb, OpenAI Pieter Abbeel, and Igor Mordatch. Multiagent actor-critic for mixed cooperative-competitive environments. In Advances in Neural Information Processing Systems, pp. 6379–6390, 2017.
+
+Hang Ma, Daniel Harabor, Peter. J Stuckey, Jiaoyang Li, and Sven Koenig. Searching with consistent prioritization for multi-agent path finding. AAAI 2019 : Thirty-Third AAAI Conference on Artificial Intelligence, 33(1):7643–7650, 2019.
+
+Ian M Mitchell, Alexandre M Bayen, and Claire J Tomlin. A time-dependent hamilton-jacobi formulation of reachable sets for continuous dynamic games. IEEE Transactions on automatic control, 50(7):947–957, 2005.
+
+Stephen Prajna, Ali Jadbabaie, and George J Pappas. A framework for worst-case and stochastic safety verification using barrier certificates. IEEE Transactions on Automatic Control, 52(8): 1415–1428, 2007.
+
+Charles R. Qi, Hao Su, Kaichun Mo, and Leonidas J. Guibas. Pointnet: Deep learning on point sets for 3d classification and segmentation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), July 2017.
+
+Han Qie, Dianxi Shi, Tianlong Shen, Xinhai Xu, Yuan Li, and Liujing Wang. Joint optimization of multi-UAV target assignment and path planning based on multi-agent reinforcement learning. IEEE Access, 7:146264–146272, 2019.
+
+Alexander Robey, Haimin Hu, Lars Lindemann, Hanwen Zhang, Dimos V Dimarogonas, Stephen Tu, and Nikolai Matni. Learning control barrier functions from expert demonstrations. arXiv preprint arXiv:2004.03315, 2020.
+
+Erick J. Rodr´ıguez-Seda, Chinpei Tang, Mark W. Spong, and Dusan M. Stipanovi ˇ c. Trajectory ´ tracking with collision avoidance for nonholonomic vehicles with acceleration constraints and limited sensing. The International Journal of Robotics Research, 33(12):1569–1592, 2014.
+
+Matteo Saveriano and Dongheui Lee. Learning barrier functions for constrained motion planning with dynamical systems. arXiv preprint arXiv:2003.11500, 2020.
+
+Shai Shalev-Shwartz, Shaked Shammah, and Amnon Shashua. Safe, multi-agent, reinforcement learning for autonomous driving. arXiv preprint arXiv:1610.03295, 2016.
+
+Nathan Srebro, Karthik Sridharan, and Ambuj Tewari. Smoothness, low noise and fast rates. In Advances in Neural Information Processing Systems 23, pp. 2199–2207, 2010.
+
+Mohit Srinivasan, Amogh Dabholkar, Samuel Coogan, and Patricio Vela. Synthesis of control barrier functions using a supervised machine learning approach. arXiv preprint arXiv:2003.04950, 2020.
+
+Andrew Taylor, Andrew Singletary, Yisong Yue, and Aaron Ames. Learning for safety-critical control with control barrier functions. In Learning for Dynamics and Control, pp. 708–717, 2020.
+
+Stephen Tu, Alexander Robey, and Nikolai Matni. Closing the closed-loop distribution shift in safe imitation learning. arXiv preprint arXiv:2102.09161, 2021.
+
+Jur Van den Berg, Ming Lin, and Dinesh Manocha. Reciprocal velocity obstacles for real-time multi-agent navigation. In IEEE International Conference on Robotics and Automation (ICRA), pp. 1928–1935. IEEE, 2008.
+
+Li Wang, Aaron D Ames, and Magnus Egerstedt. Safety barrier certificates for collisions-free multirobot systems. IEEE Transactions on Robotics, 33(3):661–674, 2017.
+
+Li Wang, Evangelos A Theodorou, and Magnus Egerstedt. Safe learning of quadrotor dynamics using barrier certificates. In IEEE International Conference on Robotics and Automation (ICRA), pp. 2460–2465. IEEE, 2018.
+
+Peter Wieland and Frank Allgower. Constructive safety using control barrier functions. ¨ IFAC Proceedings Volumes, 40(12):462–467, 2007.
+
+Xiangru Xu, Jessy W Grizzle, Paulo Tabuada, and Aaron D Ames. Correctness guarantees for the composition of lane keeping and adaptive cruise control. IEEE Transactions on Automation Science and Engineering, 15(3):1216–1229, 2017.
+
+Kaiqing Zhang, Zhuoran Yang, Han Liu, Tong Zhang, and Tamer Basar. Fully decentralized multiagent reinforcement learning with networked agents. In International Conference on Machine Learning, pp. 5872–5881, 2018.
+
+Wenbo Zhang and Osbert Bastani. Mamps: Safe multi-agent reinforcement learning via model predictive shielding. arXiv preprint arXiv:1910.12639, 2019.
+
+Lianmin Zheng, Jiacheng Yang, Han Cai, Weinan Zhang, Jun Wang, and Yong Yu. Magent: A many-agent reinforcement learning platform for artificial collective intelligence. arXiv preprint arXiv:1712.00600, 2017.
+
+# A PROOF OF PROPOSITION 1
+
+Since $\dot { h } _ { i } = \nabla _ { s _ { i } } h _ { i } \cdot f _ { i } ( s _ { i } , u _ { i } ) + \nabla _ { o _ { i } } h _ { i } \cdot \dot { o _ { i } } ( t )$ , the satisfaction of (2) implies:
+
+$$
+\begin{array} { r l r } & { \forall \left( s _ { i } , o _ { i } \right) \in \mathcal { X } _ { i , 0 } , } & { h _ { i } ( s _ { i } , o _ { i } ) \geq 0 } \\ & { \forall \left( s _ { i } , o _ { i } \right) \in \mathcal { X } _ { i , d } , } & { h _ { i } ( s _ { i } , o _ { i } ) < 0 } \\ & { \forall \left( s _ { i } , o _ { i } \right) \in \left\{ \left( s _ { i } , o _ { i } \right) \bigm | h _ { i } ( s _ { i } , o _ { i } ) \geq 0 \right\} , } & { h _ { i } + \alpha \left( h _ { i } \right) \geq 0 . } \end{array}
+$$
+
+The initial condition $( s _ { i } ( 0 ) , o _ { i } ( 0 ) ) \in \{ ( s _ { i } , o _ { i } ) \mid h _ { i } ( s _ { i } , o _ { i } ) \geq 0 \}$ means that $h _ { i } \geq 0$ at time $t = 0$ . Since $\dot { h } _ { i } + \alpha \left( h _ { i } \right) \geq 0$ , $h _ { i }$ will stay non-negative, which is proved in Section 2 of Ames et al. (2014). This means that $( s _ { i } ( t ) , o _ { i } ( t ) ) \notin \mathcal { X } _ { i , d }$ for $\forall t > 0$ . Thus for $\forall i$ and $\forall t > 0$ , agent $i$ would not enter the dangerous set, and the whole multi-agent system is safe by Definition 1. □
+
+Remark. Since the input dimension and permutation of $h _ { i }$ can change with time, the time derivative of $h _ { i }$ does not exist everywhere but almost everywhere. In fact, in the safety guarantee provided by Proposition 1, we do not require the time derivative of $h _ { i }$ to exist everywhere. The $h _ { i }$ can also be non-smooth. Based on (2) of Glotfelter et al. (2017), we can define $\dot { h } _ { i }$ as the generalized gradient that always exists when $h _ { i }$ is non-smooth and the time derivative exists almost everywhere. Then based on Theorem 2 of Glotfelter et al. (2017), as long as the CBF conditions are satisfied under the generalized gradient, then $h _ { i }$ is a valid CBF and the safety can be guaranteed.
+
+Global CBF from decentralized CBFs. In addition to Proposition 1, another way to prove the global safety of the multi-agent system under the decentralized CBFs is to construct the global CBF $h _ { g } : S \mapsto \mathbb { R }$ from individual CBFs by taking the minimum, as is in:
+
+$$
+h _ { g } ( s ) : = \operatorname* { m i n } \{ h _ { 1 } ( s \downarrow s _ { 1 } , s \downarrow \ o _ { 1 } ) , h _ { 2 } ( s \downarrow s _ { 2 } , s \downarrow \ o _ { 2 } ) , \cdot \cdot \cdot \ , h _ { N } ( s \downarrow s _ { N } , s \downarrow \ o _ { N } ) \} ,
+$$
+
+where $s \downarrow s _ { i }$ is the projection of the global state onto the state of agent $i$ and $s \downarrow o _ { i }$ is the projection of the global state to the observation of agent $i$ . Then the following proposition guarantees the global safety of the multi-agent system.
+
+Proposition 2. If (10) is satisfied for every agent $i$ , then the global CBF $h _ { g } ( s )$ satisfies:
+
+$$
+\begin{array} { l r } { \forall s \in S _ { 0 } , } & { h _ { g } ( s ) \geq 0 } \\ { \forall s \in S _ { d } , } & { h _ { g } ( s ) < 0 } \\ { \forall s \in \left\{ s \mid h _ { g } ( s ) \geq 0 \right\} , } & { \dot { h } _ { g } + \alpha \left( h _ { g } \right) \geq 0 , } \end{array}
+$$
+
+where $S _ { 0 } = \{ s \in \mathcal { S } | \forall i , ( s \downarrow s _ { i } , s \downarrow o _ { i } ) \in \mathcal { X } _ { i , 0 } \}$ and $S _ { d } = \{ s \in \mathcal { S } | \exists i , ( s \downarrow s _ { i } , s \downarrow o _ { i } ) \in \mathcal { X } _ { i , d } \}$ . Then $\forall t > 0 , h _ { g } ( s ( t ) ) \geq 0$ and $s \not \in S _ { d }$ , which means the multi-agent system is globally safe.
+
+Proof. Let us first prove that the satisfaction of (10) implies the satisfaction of (12). By definition of $ { \boldsymbol { S } } _ { 0 }$ , when $s \in S _ { 0 }$ , we have $\forall i , ( s \downarrow s _ { i } , s \downarrow o _ { i } ) \in \mathcal { X } _ { i , 0 }$ , which means $\forall i , h _ { i } ( s \downarrow s _ { i } , s \downarrow o _ { i } ) \geq 0$ . Thus $h _ { g } ( s ) = \operatorname* { m i n } _ { i } \{ h _ { i } ( s \downarrow s _ { i } , s \downarrow o _ { i } ) \} \geq 0$ . When $s \in S _ { d }$ , we have $\exists i , ( s \downarrow s _ { i } , s \downarrow o _ { i } ) \in \mathcal { X } _ { i , d } .$ , which means $\exists i , h _ { i } ( s \downarrow s , s \downarrow o _ { i } ) \ : < \ : 0$ . Thus $h _ { g } ( s ) = \mathrm { m i n } _ { i } \{ h _ { i } ( s \downarrow s _ { i } , s \downarrow o _ { i } ) \} < 0$ . When $s \in \{ s \mid h _ { g } ( s ) \geq 0 \}$ , we have $\forall i , ( s \downarrow \ s _ { i } , s \downarrow \ o _ { i } ) \in \{ ( s \downarrow \ s _ { i } , s \downarrow \ o _ { i } ) \mid h _ { i } ( s \downarrow \ s _ { i } , s \downarrow \ o _ { i } ) \geq 0 \}$ . So $\forall i , \dot { h } _ { i } + \alpha \left( h _ { i } \right) \geq 0 .$ Let $i ^ { * } = \arg \operatorname* { m i n } _ { i } \{ h _ { i } ( s \downarrow s _ { i } , s \downarrow o _ { i } ) \}$ . Then $h _ { g } ( s ) = h _ { i ^ { * } } ( s \downarrow s _ { i ^ { * } } , s \downarrow o _ { i ^ { * } } )$ and $\begin{array} { r } { \dot { h } _ { g } + \alpha \left( h _ { g } \right) = \dot { h } _ { i ^ { * } } + \alpha \left( h _ { i ^ { * } } \right) \ge 0 } \end{array}$ . Hence the satisfaction of (10) implies the satisfaction of (12). Then based on Section 2 of Ames et al. (2014), we have $h _ { g } ( s ( t ) ) \geq 0 , \forall t > 0$ . This means $s ( t ) \notin S _ { d } , \forall t > 0$ , and the multi-agent system is globally safe. □
+
+# B GENERALIZATION ERROR BOUND OF THE DECENTRALIZED CBF
+
+To answer how well the learned $\pi _ { i } ( s _ { i } , o _ { i } )$ and $h _ { i } ( s _ { i } , o _ { i } )$ can generalize to unseen scenarios, we will provide a generalization bound with probabilistic guarantees. We denote the solution to (4) as $\hat { h } _ { i }$ and $\hat { \pi } _ { i }$ . Denote the Rademacher complexity of the function class of $y _ { i }$ as $\mathcal { R } _ { z _ { i } } ( \mathcal { V } _ { i } )$ , whose definition could be found in Appendix B. Also we define $\epsilon _ { i }$ as the probability that the decentralized CBF conditions are violated for agent $i$ over randomly sampled trajectories (not necessarily the samples encountered in training). Under such definition, $\epsilon _ { i }$ measures the generalization error and can be expressed as $\boldsymbol { \epsilon } _ { i } ~ = ~ \mathbb { P } _ { \tau _ { i } \sim \mathcal { D } _ { i } } \left[ y _ { i } ( \tau _ { i } , \hat { h } _ { i } , \hat { u } _ { i } ) \leq 0 \right]$ . Then we have Proposition 3 that provides generalization guarantees for all the learned $\hat { h } _ { i }$ and $\hat { \pi } _ { i }$ .
+
+Proposition 3 (Generalization Error Bound of Learning Decentralized CBF). Assume that $| y | \le b$ and (4) is feasible. Let $\hat { h } _ { i }$ and $\hat { u } _ { i }$ be the solutions to (4) and $\mu$ be a universal positive constant vector. Recall that $N$ is the number of agents. Then, for any $\delta \in ( \dot { 0 } , 1 )$ the following statement holds:
+
+$$
+\mathbb { P } \left[ \bigcap _ { i = 1 } ^ { N } \left( \epsilon _ { i } \leq \mu _ { i } \frac { \log ^ { 3 } z _ { i } } { \gamma ^ { 2 } } \mathcal { R } _ { z _ { i } } ^ { 2 } ( \mathcal { V } _ { i } ) + \mu _ { i } \frac { \log \left( N \log \left( 4 b / \gamma \right) / \delta \right) } { z _ { i } } \right) \right] \geq 1 - \delta .
+$$
+
+Proof. Note that $\epsilon _ { i } = \mathbb { P } _ { \tau _ { i } \sim \mathcal { D } _ { i } } \left[ y _ { i } ( \tau _ { i } , \hat { h } _ { i } , \hat { u } _ { i } ) \leq 0 \right] = \mathbb { E } _ { \tau _ { i } \sim \mathcal { D } _ { i } } \left[ \mathbb { I } \left( y _ { i } ( \tau _ { i } , \hat { h } _ { i } , \hat { u } _ { i } ) \leq 0 \right) \right]$ . Under zero empirical loss, using the Theorem 5 in Srebro et al. (2010), for any $\begin{array} { r } { \frac { \delta } { N } > 0 } \end{array}$ , the following statement holds with probability at least $\textstyle 1 - { \frac { \delta } { N } }$ :
+
+$$
+\epsilon _ { i } \le \mu _ { i } \frac { \log ^ { 3 } z _ { i } } { \gamma ^ { 2 } } \mathcal { R } _ { z _ { i } } ^ { 2 } ( \mathscr { V } _ { i } ) + \mu _ { i } \frac { \log ( N \log ( 4 b / \gamma ) / \delta ) } { z _ { i } }
+$$
+
+where $\mu _ { i } > 0$ is some universal constant. By taking the union bound over all $N$ agents, the following statement holds with probability at least $\begin{array} { r } { ( 1 - \frac { \delta } { N } ) ^ { \widetilde { N } } } \end{array}$ :
+
+$$
+\bigcap _ { i = 1 } ^ { N } \left( \epsilon _ { i } \leq \mu _ { i } \frac { \log ^ { 3 } z _ { i } } { \gamma ^ { 2 } } \mathcal { R } _ { z _ { i } } ^ { 2 } ( \mathcal { Y } _ { i } ) + \mu _ { i } \frac { \log ( N \log ( 4 b / \gamma ) / \delta ) } { z _ { i } } \right) .
+$$
+
+Since $\begin{array} { r } { ( 1 - \frac { \delta } { N } ) ^ { N } > 1 - \delta } \end{array}$ for $\delta \in ( 0 , 1 )$ , we have:
+
+$$
+\mathbb { P } \left[ \bigcap _ { i = 1 } ^ { N } \left( \epsilon _ { i } \leq \mu _ { i } \frac { \log ^ { 3 } z _ { i } } { \gamma ^ { 2 } } \mathcal { R } _ { z _ { i } } ^ { 2 } ( \mathcal { V } _ { i } ) + \mu _ { i } \frac { \log \left( N \log \left( 4 b / \gamma \right) / \delta \right) } { z _ { i } } \right) \right] \geq 1 - \delta ,
+$$
+
+which completes the proof.
+
+The Rademacher complexity $\mathcal { R } _ { z _ { i } } ( \mathcal { V } _ { i } )$ is defined as:
+
+$$
+\mathcal { R } _ { z _ { i } } ( y _ { i } ) : = \operatorname* { s u p } _ { \tau _ { i } ^ { 1 } , \cdots \tau _ { i } ^ { z _ { i } } \sim \mathcal { D } _ { i } } \mathbb { E } _ { \xi \sim \mathrm { ~ U n i f ~ } ( \{ \pm 1 \} ^ { z _ { i } } ) } \operatorname* { s u p } _ { h _ { i } \in \mathcal { H } _ { i } , \pi _ { i } \in \mathcal { V } _ { i } } \frac { 1 } { z _ { i } } \bigg | \sum _ { j = 1 } ^ { z _ { i } } \xi _ { j } y _ { i } ( \tau _ { i } ^ { j } , h _ { i } , \pi _ { i } ) \bigg | ,
+$$
+
+where $\xi \in \mathbb { R } ^ { z _ { i } }$ is a random vector and $\xi _ { j }$ denotes its $j ^ { t h }$ element. $\mathcal { R } _ { z _ { i } } ( \mathcal { V } _ { i } )$ characterizes the richness of function class $\mathcal { \mathrm { V } } _ { i }$ .
+
+The left side of Equation (6) is the probability that the generalization error $\epsilon _ { i }$ is upper bounded for all the $N$ agents. Equation (6) claims that the generalization error is bounded for all agents with high probability $1 - \delta$ . Similar to the discussions in Section 4 in Boffi et al. (2020), for specific function classes of $\mathcal { H } _ { i }$ and $\nu _ { i }$ , such as Lipschitz parametric function or Reproducing kernel Hilbert space function classes, the Rademacher complexity of the function classes can be further bounded, leading to vanishing generalization errors as the number of samples $z _ { i }$ increases. Such derivations are standard, and are thus omitted as they are not the focus of the present paper.
+
+Remark. The generalization guarantee in Proposition 3 requires that the testing and training trajectories are drawn from the same distribution. Since in testing the trajectories come from the closed-loop (controller-in-the-loop) system, we should ensure that the training trajectories are also from the closed-loop system. Thus, in our implementation, the training data are not uniformly sampled from the state-observation space. Instead, the samples are drawn online under the current control policy, which is a solution to (4) using previously learned controller. We then use the updated controller to sample new data to formulate (4), and solve for an updated controller accordingly. In the experiments, we iterate this process until it converges. This way, at the steady stage of this process, the training and testing distribution shift becomes almost negligible, and the generalization results in Proposition 3 can thus be used. We leave a systematic analysis on the generalization and convergence of this iterative process in our future work.
+
+# C MODEL DYNAMICS
+
+In the experiment section of our main paper, we use the 2D ground robots and 3D drones. For ground robots, we use a double integrator model with state $s _ { i } = [ x _ { i } , y _ { i } , v _ { x , i } , v _ { y , i } ]$ for the navigation and predator-prey tasks, and the model from Rodr´ıguez-Seda et al. (2014) for the nested rings task. For drones, we use the following dynamics:
+
+$$
+s _ { i } = \left[ \begin{array} { c } { x _ { i } } \\ { y _ { i } } \\ { z _ { i } } \\ { v _ { x , i } } \\ { v _ { y , i } } \\ { v _ { z , i } } \\ { \theta _ { x , i } } \\ { \theta _ { y , i } } \end{array} \right] , \quad \frac { d s _ { i } } { d t } = \left[ \begin{array} { c } { v _ { x , i } } \\ { v _ { y , i } } \\ { v _ { z , i } } \\ { g t a n ( \theta _ { x , i } ) } \\ { g t a n ( \theta _ { y , i } ) } \\ { a _ { z , i } } \\ { \omega _ { x , i } } \\ { \omega _ { y , i } } \end{array} \right] , \quad u _ { i } = \left[ \begin{array} { c } { \omega _ { x , i } } \\ { \omega _ { y , i } } \\ { \omega _ { z , i } } \\ { a _ { z , i } } \end{array} \right] .
+$$
+
+# D SUPPLEMENTARY EXPERIMENT
+
+For 3D drones we have shown the generalization capability to 1024 agents even when our method is trained with 8 agents (Figure 6). For 2D ground robots we have similar results that were omitted in the main paper due to space limitations. We present the results in Figure 8 as below. Our method demonstrates the exceptional generalization capability to testing scenarios where the number of agents is significantly greater than that in training. The safety rate and average reward remain high even when the number of agents grow exponentially.
+
+![](images/d0cc583c7a048e567f1be3f06eb01a963a84541b2a058e58ac7823aa2b33e7b4.jpg)  
+Figure 8: Generalization capability of our method in the 2D tasks. Our method is trained with 8 agents and tested with up to 1024 agents.
+
+Ablation Study on Online Policy Refinement. In Section 4.3, we introduced a test-time policy refinement method. Here we study the effect of this method on our performance and present the results in Table 1. It is shown that even without the OPR, the safety rate is still promising. The OPR further improved the safety rate. The steps requiring OPR in testing only accounts for a small proportion $( < \bar { 1 } 7 \% )$ ) of the total steps. The proportion gradually becomes saturated and does not significantly increase as the number of agents grow.
+
+Table 1: Effect of online policy refinement (OPR). Proportion of OPR stands for the proportion of steps that OPR is performed in testing.   
+
+<table><tr><td rowspan="2">Environment</td><td rowspan="2">Config</td><td colspan="4">Safety Rate</td><td colspan="4">Proportion of OPR</td></tr><tr><td>4 Agents</td><td>8 Agents</td><td>32 Agents</td><td>1024 Agents</td><td>4Agents</td><td>8 Agents</td><td>32 Agents</td><td>1024 Agents</td></tr><tr><td rowspan="2">Maze</td><td>w/OPR</td><td>0.9999</td><td>0.9999</td><td>0.9987</td><td>0.9956</td><td>0.0149</td><td>0.0958</td><td>0.1423</td><td>0.1655</td></tr><tr><td>w/o OPR</td><td>0.9999</td><td>0.9999</td><td>0.9869</td><td>0.9741</td><td>0</td><td>0</td><td>0</td><td>0</td></tr><tr><td rowspan="2">Tunnel</td><td>w/ OPR</td><td>0.9999</td><td>0.9998</td><td>0.9988</td><td>0.9946</td><td>0.0117</td><td>0.0729</td><td>0.1271</td><td>0.1493</td></tr><tr><td>w/o OPR</td><td>0.9999</td><td>0.9992</td><td>0.9866</td><td>0.9727</td><td>0</td><td>0</td><td>0</td><td>0</td></tr></table>
+
+![](images/a2476d166c29be82a1f28efde51668c338c4eb7481d37ad88d77338b419b7055.jpg)  
+Figure 9: Visualization of the learned CBF in the Maze environment with 2 agents. The red area is where the distance between agents is less that the safe threshold.
+
+Visualization of the Learned CBF. To have a better understanding of the learned decentralized CBF, we provide a visualization in Figure 9. The CBF is learned in the Maze environment with two agents, in order to simplify the interpretation. The relative distance is defined in the 3D Euclidean space. The relative velocity is the negative time derivative of the relative distance. When the relative velocity is positive, the two agents are getting close to each other. From Figure 9, we know that the learned CBF is negative on the dangerous states (the red area) and the potentially dangerous states (the top-right area), where the agents are moving towards each other. The CBF is positive only when the states are sufficiently safe (the bottom-right area).

parse/train/SJeYe0NtvH/SJeYe0NtvH.md

@@ -0,0 +1,422 @@
+# NEURAL TEXT DEGENERATION WITH UNLIKELIHOOD TRAINING
+
+Sean Welleck1,2∗ Ilia Kulikov1,2∗ Stephen Roller2 Emily Dinan2
+
+Kyunghyun Cho1,2,3 & Jason Weston1,2 1New York University, 2Facebook AI Research, 3CIFAR Azrieli Global Scholar
+
+# ABSTRACT
+
+Neural text generation is a key tool in natural language applications, but it is well known there are major problems at its core. In particular, standard likelihood training and decoding leads to dull and repetitive outputs (Holtzman et al., 2019). While some post-hoc fixes have been proposed, in particular top- $k$ and nucleus sampling, they do not address the fact that the token-level probabilities predicted by the model are poor. In this paper we show that the likelihood objective itself is at fault, resulting in a model that assigns too much probability to sequences containing repeats and frequent words, unlike those from the human training distribution. We propose a new objective, unlikelihood training, which forces unlikely generations to be assigned lower probability by the model. We show that both token and sequence level unlikelihood training give less repetitive, less dull text while maintaining perplexity, giving superior generations using standard greedy or beam search. According to human evaluations, our approach with standard beam search also outperforms the currently popular decoding methods of nucleus sampling or beam blocking, thus providing a strong alternative to existing techniques.
+
+# 1 INTRODUCTION
+
+Neural text generation is a vital tool in a wide range of natural language applications. However, the standard approach – training a sequence to sequence model, e.g. Transformer (Vaswani et al., 2017), to maximize log-likelihood and approximately decoding the most likely sequence – is known to be flawed. Generated text in open-ended applications such as language modeling or dialogue has been observed to be dull, with high frequency tokens used too often and interesting content words used too rarely (Holtzman et al., 2019; Dinan et al., 2019). Moreover, the models repeat themselves at the token, phrase, and sentence levels, and statistics comparing a set of human-generated utterances and model-generated responses indicate a discrepancy between the human and model word distributions. This does not appear to be rectified by training on more data (Radford et al., 2019). Recent fixes involve modifying the decoding strategy using sampling or more sophisticated beam search variants. However, these decoding strategies do not address the core issue: the model’s underlying sequence probabilities are clearly not correct.
+
+Several reasons for exactly why neural text is degenerate have been posited, with the cause currently unknown. Possible candidates include the problem being (i) a by-product of the model architecture, e.g. the Transformer architecture preferring repeats (Holtzman et al., 2019; Vig, 2018), (ii) an intrinsic property of human language (Holtzman et al., 2019) rather than a modeling deficiency, or that (iii) a training objective relying on fixed corpora cannot take into account the real goal of using the language (Choi, 2018). Our work shows that, while the above may be factors, a primary factor is the use of the likelihood objective itself, as we demonstrate that degeneration is alleviated if we replace the likelihood objective with our proposal.
+
+While low perplexity in the limit should lead to predicting the correct next target word, there are two major flaws of the likelihood objective: (i) it pays relatively little attention to the argmax or the top of the ranked list of next token probabilities, instead optimizing the likelihood of the entire distribution;
+
+(ii) it is not focused on optimizing sequence generation, only on producing the next token. The first issue means that greedy or beam search decoding, which rely on the top of the list to generate, are not optimized – there is a discrepancy between maximizing the log-probability of a ground-truth token and ensuring the rank of the ground-truth token to be one. The second issue means that during sequence generation, any imperfection in next token prediction leads to error accumulation that is not addressed by likelihood training.
+
+In this work, we introduce unlikelihood training, an approach that addresses the two aforementioned issues. It combines two types of updates: a likelihood update on the true target tokens so that they are assigned high probability, and an unlikelihood update on tokens that are otherwise assigned too high a probability. We can collect these unlikely token candidates either during next-token prediction or from generated sequences, allowing us to train at both the token and sequence levels. Both token and sequence level unlikelihood training are shown to improve metrics that measure dullness and repetition of the model, while maintaining performance in other metrics such as perplexity or token accuracy compared to the maximum likelihood baseline. Finally, we assess our models using human evaluations. We find that our generations have vastly improved quality compared to likelihood trained models when both models use beam search decoding. Moreover, our approach when using beam search also significantly improves over likelihood trained models using either beam blocking or nucleus sampling, thus outperforming the current state-of-the-art.
+
+# 2 RELATED WORK
+
+Neural Text Degeneration Recently, several papers have observed various forms of neural text degeneration, especially in open-ended generation tasks. In dialogue, it has been shown that there is a mismatch between model and human word distributions, where generative models are more likely to output frequent words, but less likely to produce rare words compared to humans. For example, this was observed across all generative models submitted to the ConvAI2 NeurIPS 2018 competition (Dinan et al., 2019). In language modeling, the work of Holtzman et al. (2019) highlighted problems with the word frequency distribution and level of repetition in model generations compared to human text. These issues are not remedied by simply increasing the amount of the training data; e.g. largescale GPT-2 language models (Radford et al., 2019) display the same issues.
+
+Improved Decoding Algorithms Several methods have been proposed to rectify these issues. The primary ones involve changing the decoding method to a sophisticated beam search variant or to stochastic decoding, e.g. sampling. Different variants of beam search have been explored (Li et al., 2016; Vijayakumar et al., 2018; Kulikov et al., 2018; Holtzman et al., 2018) which can decrease a model’s level of repetition by selecting candidates that are unlike previously chosen ones. Separately, hard or soft beam blocking has been investigated (Paulus et al., 2017; Klein et al., 2017), whereby previously generated $n$ -grams are blocked from subsequent generation. This approach is often used in dialogue generation, fixing some token or phrase level repetitions but removing repetitions that would naturally occur in human text.
+
+The second major approach is that of sampling from the model at generation time. Top $k$ -sampling (Fan et al., 2018) and nucleus sampling (Holtzman et al., 2019) are two methods that sample sequences based on a function of the predicted next token probability distribution given by the model. Both approaches vastly improve the repetition issue, as the randomization often reduces the number of duplicate tokens in a decoded sequence, even if highly scored paths under the model (represented by beam search candidates) contain repetitions. However, as the underlying model is unchanged, it often prefers semantically similar phrasing, depending on the temperature parameter of the sampling (Holtzman et al., 2019). Furthermore, this solution is less relevant in less open-ended tasks such as machine translation, where beam search variants are the preferred method. Ideally we would like a model that can work with both beam and sampling decoding methods.
+
+Improved Learning Algorithms The proposed learning criteria are closely related to structured output prediction methods in which the goal is to increase the scores assigned by a model to true examples while decreasing those assigned to negative examples often generated by the model itself. Some representative algorithms include structured perceptron (Collins, 2002), energy-based models (LeCun et al., 2006) and more recently reflective likelihood (Dieng et al., 2018). A particular variant in this family of algorithms, called negative training, was recently used by He and
+
+Glass (2019) to prevent generic and malicious responses in dialogue models. Similarly, these structured prediction algorithms with neural language models have been applied to machine translation in recent years by Shen et al. (2015) and Edunov et al. (2017).
+
+# 3 NEURAL TEXT GENERATION
+
+Language Modeling In language modeling, our goal is to model a probability distribution $p _ { * } ( \mathbf { x } )$ over variable-length text sequences $\mathbf { x } = ( x _ { 1 } , \dots , x _ { | \mathbf { x } | } )$ composed of tokens from a vocabulary, $x _ { t } \in$ $\nu$ . We wish to find a model $p _ { \theta } ( \mathbf { x } )$ which resembles $p _ { * } ( \mathbf { x } )$ , meaning that samples $\hat { x } \sim p _ { \theta }$ are similar to samples from $p _ { * }$ , and $p _ { \theta } ( \mathbf { x } ) \approx p _ { * } ( \mathbf { x } )$ for all $\mathbf { X }$ . When $p _ { \theta } ( \mathbf { x } )$ is parameterized by a neural network, we call $p _ { \theta }$ a neural language model. We assume that $p _ { \theta }$ takes the form $\begin{array} { r } { p _ { \theta } ( \mathbf { x } ) = \prod _ { t = 1 } ^ { | \mathbf { x } | } p _ { \theta } ( x _ { t } | x _ { < t } ) } \end{array}$ .
+
+The de facto approach to training such a model is to find parameters $\theta$ that maximize the loglikelihood of a finite set of samples $\mathcal { D }$ from $p _ { * }$ by minimizing:
+
+$$
+\mathcal { L } _ { \mathrm { M L E } } ( p _ { \theta } , \mathcal { D } ) = - \sum _ { i = 1 } ^ { | \mathcal { D } | } \sum _ { t = 1 } ^ { | \mathbf { x } ^ { ( i ) } | } \log p _ { \theta } ( x _ { t } ^ { ( i ) } | x _ { < t } ^ { ( i ) } ) .
+$$
+
+Sequence Completion A closely related problem consists of sampling a sub-sequence, or prefix, $\mathbf { x } _ { 1 : k } \sim p _ { * }$ , then using $p _ { \theta }$ to conditionally decode a continuation, $\hat { \mathbf { x } } _ { k + 1 : N } \sim p _ { \theta } \mathopen { } \mathclose \bgroup \left( \cdot | \mathbf { x } _ { 1 : k } \aftergroup \egroup \right)$ . We now want the resulting completion $( x _ { 1 } , \ldots , x _ { k } , \hat { x } _ { k + 1 } , \ldots , \hat { x } _ { N } )$ to resemble a sample from $p _ { * }$ .
+
+We use sequence completion as a setting to study the behavior of neural language models due to its generality. For instance, sequence completion encompasses story generation (Fan et al., 2018), contextual text completion (Radford et al., 2019), language modeling (for $k = 0$ ), and dialogue modeling (Zhang et al., 2018) where $\mathbf { X } _ { 1 : k }$ is a dialogue history and a continuation is a next utterance.
+
+Given $p _ { \theta }$ and a prefix $\mathbf { X } _ { 1 : k }$ , finding the optimal continuation is not tractable, so in practice approximate deterministic or stochastic decoding strategies are used to generate continuations.
+
+Deterministic Decoding Two widely used deterministic decoding approaches are greedy search and beam search. The former can be seen as a special case of the latter. Greedy search selects the highest probability token at each time step: $x _ { t } = \arg \operatorname* { m a x } p _ { \theta } ( x _ { t } | x _ { < t } )$ . Beam search maintains a fixed-size set of partially-decoded sequences, called hypotheses. At each time step, beam search forms new hypotheses by appending each token in the vocabulary to each existing hypothesis, scoring the resulting sequences then selecting the highest scoring sequences. As we describe in Section 4, these deterministic decoding strategies, which depend highly on underlying model probabilities, expose issues with conventionally trained neural language models.
+
+Stochastic Decoding An alternative is to sample from a model-dependent distribution at each step, $x _ { t } \sim q ( x _ { t } | \boldsymbol { x } _ { < t } , p _ { \theta } )$ . In order to prevent sampling low probability tokens, a typical approach is to restrict sampling to a subset of the vocabulary $U \subset \mathcal { V }$ at each step:
+
+$$
+q ( x _ { t } | x _ { < t } , p _ { \theta } ) = { \left\{ \begin{array} { l l } { p _ { \theta } ( x _ { t } | x _ { < t } ) / Z } & { x _ { t } \in U } \\ { 0 } & { { \mathrm { o t h e r w i s e } } , } \end{array} \right. }
+$$
+
+where $\begin{array} { r } { Z = \sum _ { x \in U } p _ { \theta } ( x | x _ { < t } ) } \end{array}$ . The top- $k$ sampler restricts sampling to the $k$ most-probable tokens; i.e. $U$ is the size $k$ subset of $\nu$ which maximizes $\textstyle \sum _ { x \in U } p _ { \theta } ( x | x _ { < t } )$ (Fan et al., 2018). The nucleus sampler instead restricts sampling to the smallest set of tokens with total mass above a threshold $p \in \ [ 0 , 1 ]$ ; i.e. $U$ is the smallest subset with $\textstyle \sum _ { x \in U } p _ { \theta } ( x | x _ { < t } ) > = p$ (Holtzman et al., 2019).
+
+# 4 NEURAL TEXT DEGENERATION
+
+In this section we discuss two degenerate properties that frequently occur in conventional neural language models trained with the maximum likelihood objective (Equation 1).
+
+Repetition First, model-generated continuations exhibit sequence-level repetition, especially with deterministic decoding. The problem is seen by observing samples in Appendix Table 4, which shows completions from the state-of-the-art GPT-2 language model (Radford et al., 2019). Greedy decoding as well as top-k and nucleus sampling exhibit degenerate repetition (with a certain hyperparameter setting), although greedy decoding shows the worst degradation. Using a Transformer language model trained with maximum likelihood (§6), we find that the average percentage of repeated n-grams in model continuations with greedy decoding $(43 \% )$ far exceeds that of humans $( 0 . 5 \% )$ , computed over prefixes drawn from a validation corpus.
+
+Unlike previous work which only focused on degenerate sequence-level repeats (Holtzman et al., 2019), we additionally observe that neural language models exhibit substantially more repetition in next-token prediction compared to human text:
+
+$$
+\begin{array} { r } { \operatorname* { P r } \left( \hat { x } _ { k + 1 } = \arg \operatorname* { m a x } p _ { \theta } ( x | \mathbf { x } _ { 1 : k } ) \in \mathbf { x } _ { 1 : k } \right) > \operatorname* { P r } \left( x _ { k + 1 } \in \mathbf { x } _ { 1 : k } \right) . } \end{array}
+$$
+
+For instance, the Transformer language model $( \ S 6 )$ predicted next-tokens that appeared in the preceding 128 words $62 \%$ of the time, versus $49 \%$ in ground-truth text. This is especially concerning since the maximum-likelihood objective focuses on optimizing next-token conditional distributions.
+
+Token Distribution Mismatch Second, both greedy continuations and next-token predictions from conventional neural text generators have different token distributions from human text. As demonstrated by Holtzman et al. (2019), such models with greedy or beam search tend to produce high frequency tokens too often and low frequency tokens too rarely, where frequency is defined by the human token distribution. With the Transformer language model (§6), the set of nexttoken greedy predictions on a held-out validation set had roughly $40 \%$ fewer unique tokens than the ground-truth tokens (11.6k vs. 18.9k), and overproduced frequent tokens (Appendix Figure 1). Such behavior has been linked to generations being judged as dull by humans because rare words can add engaging specificity (Weston et al., 2018; See et al., 2019).
+
+# 5 THE UNLIKELIHOOD TRAINING OBJECTIVE
+
+We now describe unlikelihood training for neural language models, then in Section 6 demonstrate empirically that our proposal substantially improves neural text degeneration (§4).
+
+# 5.1 UNLIKELIHOOD TRAINING
+
+The key idea behind unlikelihood training is decreasing the model’s probability of certain tokens, called negative candidates. Given a sequence $( x _ { 1 } , \dots , x _ { T } )$ and a set of negative candidate tokens $\mathcal { C } ^ { t } = \{ c _ { 1 } , \ldots , c _ { m } \}$ , where each $c _ { j } \in \mathcal V$ , we define the unlikelihood loss for step $t$ as:
+
+$$
+\mathcal { L } _ { \mathrm { U L } } ^ { t } ( p _ { \theta } ( \cdot | x _ { < t } ) , \mathcal { C } ^ { t } ) = - \sum _ { c \in \mathcal { C } ^ { t } } \log ( 1 - p _ { \theta } ( c | x _ { < t } ) ) .
+$$
+
+The loss decreases as $p _ { \theta } ( c | x _ { < t } )$ decreases. We incorporate the unlikelihood loss into a token-level unlikelihood objective which augments each time-step of maximum likelihood training:
+
+$$
+\mathcal { L } _ { \mathrm { U L - t o k e n } } ^ { t } ( p _ { \theta } ( \cdot | x _ { < t } ) , \mathcal { C } ^ { t } ) = - \alpha \cdot \sum _ { c \in \mathcal { C } ^ { t } } \log ( 1 - p _ { \theta } ( c | x _ { < t } ) ) - \underbrace { \log p _ { \theta } ( x _ { t } | x _ { < t } ) } _ { \mathrm { l i k e l i h o o d } } .
+$$
+
+As candidates, we use previous context tokens:
+
+$$
+\mathcal { C } _ { \mathrm { p r e v - c o n t e x t } } ^ { t } = \{ x _ { 1 } , \ldots , x _ { t - 1 } \} \setminus \{ x _ { t } \} .
+$$
+
+Intuitively, minimizing the unlikelihood loss with this candidate set makes (i) incorrect repeating tokens less likely, as the previous context contains potential repeats, and (ii) frequent tokens less likely, as these tokens appear often in the previous context. These candidates are efficient to compute, without requiring additional supervision.
+
+Gradient analysis We assume $p _ { \theta } ( x _ { t } | x _ { < t } ) = \mathrm { s o f t m a x } ( a )$ and consider the gradient of (4) with respect to the softmax input $a \in \mathbb { R } ^ { \nu }$ . With a single negative candidate, the (negative) gradient is:
+
+$$
+\nabla { \mathcal { L } } _ { a } = x ^ { * } - m \odot p , \quad m _ { i } = { \left\{ \begin{array} { l l } { ( 1 - \alpha { \frac { p _ { \mathrm { n e g } } } { 1 - p _ { \mathrm { n e g } } } } ) } & { { \mathrm { ~ i f ~ } } i \neq i _ { \mathrm { n e g } } } \\ { ( 1 + \alpha ) } & { { \mathrm { ~ i f ~ } } i = i _ { \mathrm { n e g } } , } \end{array} \right. }
+$$
+
+where $x ^ { * } \in \{ 0 , 1 \} ^ { \nu }$ is a one-hot ground-truth vector, $m \in \mathbb { R } ^ { \nu }$ , $p = p _ { \theta } ( \cdot | x _ { < t } )$ , and $p _ { \mathrm { n e g } }$ is the probability of the negative candidate at index $i _ { \mathrm { n e g } }$ (derivation in Appendix A).
+
+This unlikelihood gradient (6) differs from the likelihood gradient, $\left( x ^ { * } - p \right)$ , due to the term $m$ which varies based on the hyper-parameter $\alpha$ and the model’s negative candidate probability, $p _ { \mathrm { n e g } }$ . At the ground-truth token index $i ^ { * }$ , the unlikelihood gradient is positive, increasing the ground-truth token’s probability with a magnitude that grows with $p _ { \mathrm { n e g } }$ . Conversely, at the negative candidate index $i _ { \mathrm { n e g } }$ the gradient is negative. At all other token indices $i \not \in \{ i ^ { * } , i _ { \mathrm { n e g } } \}$ , the gradient moves from negative to positive as $p _ { \mathrm { n e g } }$ increases. For instance, with $\alpha = 1 . 0$ the gradient increases the probability of each token $x _ { i }$ when the model assigns high probability to the negative candidate $\mathrm { \Delta } p _ { \mathrm { n e g } } > 0 . 5$ ).
+
+# 5.2 SEQUENCE-LEVEL UNLIKELIHOOD TRAINING
+
+While the token-level unlikelihood objective efficiently augments maximum likelihood training with token-level penalties, it is limited to prefixes drawn from the training distribution. The resulting distribution mismatch between training sequences and generated sequences is a known issue with maximum-likelihood training, motivating objectives that operate on model-generated sequences (Daume et al., 2009; Ross et al., 2011; Ranzato et al., 2015; Yu et al., 2016). ´
+
+We thus propose a sequence-level unlikelihood objective which uses unlikelihood on decoded continuations. That is, given a prefix $( x _ { 1 } , \ldots , x _ { k } ) \sim p _ { * }$ , we decode a continuation $( x _ { k + 1 } , \dots , x _ { k + N } ) \sim$ $p _ { \theta } ( \cdot | x _ { 1 } , \ldots , x _ { k } )$ , construct per-step negative candidate sets $( { \mathcal { C } } ^ { k + 1 } , \dots , { \mathcal { C } } ^ { k + N } )$ , and define each perstep sequence-level loss for $t \in \{ k + 1 , \ldots , k + N \}$ as:
+
+$$
+\mathcal { L } _ { \mathrm { U L S } } ^ { t } ( p _ { \theta } ( \cdot | x _ { < t } ) , \mathcal { C } ^ { t } ) = - \sum _ { c \in \mathcal { C } ^ { t } } \log ( 1 - p _ { \theta } ( c | x _ { < t } ) ) .
+$$
+
+Intuitively, the negative candidates can identify problematic tokens for the loss to penalize. We choose to penalize repeating n-grams in the continuation:
+
+$$
+( x _ { t - i } , \ldots , x _ { t } , \ldots , x _ { t + j } ) \in x _ { < t - i } { \mathrm { ~ f o r ~ a n y ~ } } ( j - i ) = n , i \leq n \leq j ,
+$$
+
+which says that $x _ { t }$ is the (single) negative candidate for step $t$ if it is part of a repeating n-gram1.
+
+In our experiments we apply this sequence loss in two ways: (i) using it to fine-tune a standard MLE baseline; and (ii) using it to fine-tune an unlikelihood model trained at the token level, ${ \mathcal { L } } _ { \mathrm { U L - t o k e n } }$ . We refer to the former as ${ \mathcal { L } } _ { \mathrm { U L - s e q } }$ and the latter as $\mathcal { L } _ { \mathrm { U L - t o k e n + s e q } }$ . In both cases, fine-tuning is done by equally mixing sequence-level unlikelihood updates (7) and the token-level loss from which it was initially trained (either likelihood updates (1) or token-level unlikelihood updates (4)).
+
+Efficiency Any objective that requires explicitly decoding a sequence is constrained by sample efficiency when decoding is slow; if sample efficiency is low, the total decoding time is too large for practical use. In our experiments we show that when used for fine-tuning, the sequence-level unlikelihood objective substantially reduced degeneration in under 1,500 updates, rendering it practical for modern large-scale neural models, even with high decoding costs.
+
+# 6 EXPERIMENTS
+
+We follow a standard language modeling setup from Baevski and Auli (2019) and evaluate our method on the task of sequence completion, detailed below.2
+
+Model Architecture Recent large-scale language models are based on the Transformer architecture, a multi-layer feed-forward network with self-attention (Vaswani et al., 2017). We use a 16-layer Transformer with 8 attention heads, embedding dimension 1024, and fully-connected dimension 4096; the architecture is based on Baevski and Auli (2019) but with standard embedding and softmax layers. Our proposed method is architecture agnostic; we choose this one as a representative of recent large-scale language models, e.g. Radford et al. (2019).
+
+Table 1: Example greedy completions showing representative examples of the MLE model’s degenerate single-token repetition (top), phrase-level repetition (middle), and ‘structural’ repetition (bottom), as well as the proposed method’s ability to fix these degenerate behaviors.   
+
+<table><tr><td></td><td></td><td>seq-rep-4</td></tr><tr><td>Prefix LMLE</td><td>...Lyrically the song hasexcerpts ofdifferent languages including French,Spanish ,Italian,Spaish,alian,pansh,alian,panish,paish,Portuguese,Portuguee,ortuguese,org</td><td>0.744</td></tr><tr><td></td><td>,Portuguese,Portuguese,Portuguese,Portuguese,Portuguese,Portuguese,Portuguese,Portuguese,panish, Portuguese,Portuguese,Portuguese,Portuguese,Portuguese ,and German.In the first verse,the protagonist sings about being a“girl who&#x27;s been in love with someone else</td><td></td></tr><tr><td>LUL-token+seq</td><td>”,while the second versedescribes the relationship between theprotagonist and her lover.Inthe third verse,the protagonist sings</td><td>0.063</td></tr><tr><td>Prefix LMLE</td><td>... starboard engines and was going to crash.“We&#x27;re going in,” hesaid.“We’re going tocrash.We&#x27;re going to crash.We&#x27;re going to crash.We&#x27;re going to crash.We’re going</td><td>0.787</td></tr><tr><td></td><td>to crash.We &#x27;re going to crash.We&#x27;re going to crash.We&#x27;re going to</td><td></td></tr><tr><td>LUL-token+seq</td><td>Hood said.“I&#x27;m going to make sure we&#x27;re going to get back to the water.”The order to abandon ship was given by Admiral Beatty,who ordered the remaining two batlecruisers to turn away.At18:25,Hood turned his</td><td>0.000</td></tr><tr><td>Prefix</td><td>... career-high 27 points on 8-for-ll shooting with three rebounds</td><td></td></tr><tr><td>LMLE</td><td>and two assists.OnJanuary 3,2012,he was named to the 201213All-Atlantic10 frst team.OnFebruary 3，</td><td>0.277</td></tr><tr><td>LUL-token+seq</td><td>2012,he was named to the Atlantic 10 first team.On February 5,20l2,he was named anda career-high7assists againstthe Minnesota Timberwolves.OnFebruary 3,2012,he was named to the 2012 All- NBAFirstTeam.On March7,2Ol2,he was named oneoffive finalists forthe Naismith Award,which is</td><td>0.064</td></tr></table>
+
+Dataset We use the Wikitext-103 dataset (Merity et al., 2016), a large-scale collection of Wikipedia articles containing over 100 million words and 260 thousand unique tokens. As a document-level dataset, Wikitext-103 is an open-source representative of recent datasets used for large-scale language modeling (Baevski and Auli, 2019; Radford et al., 2019). We perform experiments at the word level.
+
+Training We train on fixed-length contiguous sequences, in our case of length 1,536, which was selected based on GPU memory constraints. For the token-level losses $\mathcal { L } _ { \mathrm { M L E } }$ , ${ \mathcal { L } } _ { \mathrm { U L - t o k e n } } )$ , we train each model on 8 GPUs for a maximum of $1 5 0 \mathrm { k }$ updates, evaluating on the validation set and saving the model state every 10k updates. For the experiments below, we select the saved model state with the best validation perplexity.
+
+Sequence-level fine-tuning begins with the model state selected based on the validation perplexity. Models are fine-tuned for 1,500 total updates. With probability 0.5 an update uses ${ \mathcal { L } } _ { \mathrm { U L S } }$ and otherwise uses the token-level loss with which the model was trained. For a ${ \mathcal { L } } _ { \mathrm { U L S } }$ update, we split each training sequence and greedily decode continuations (details below). The experiments use a prefix length $k = 5 0$ and continuation length $N = 1 0 0$ for fine-tuning.
+
+Completions We evaluate a model on sequence completion by using the model to decode continuations of prefixes derived from the validation (or test) set. Specifically, the validation (or test) set is first partitioned into sequences of 1,536 tokens, as in training. Then we split each sequence into a batch of prefixes of length $k$ (discarding extra tokens), and decode a continuation of length $N$ for each prefix. The experiments below use $k = 5 0$ and $N = 1 0 0$ for evaluation. For deterministic decoding we use greedy search and beam search with beam size 10, and for stochastic decoding we use top- $k$ sampling with $k \in \{ 3 , 5 0 \}$ and nucleus sampling with $p \in \{ 0 . 3 , 0 . 9 \}$ .
+
+# 6.1 EVALUATION METRICS
+
+Repetition As a token-level metric for repetition, we use the fraction of next-token (top-1) predictions that occur in the previous $\ell$ tokens $( \mathbf { r e p } / \ell )$ ; given a set $\mathcal { D }$ of length- $\mathcal { T }$ sequences,
+
+$$
+\mathrm { r e p } / \ell = \frac { 1 } { | \mathscr { D } | T } \sum _ { \mathbf { x } \in \mathscr { D } } \sum _ { t = 1 } ^ { T } \mathbb { I } \left[ \mathrm { a r g } \operatorname* { m a x } p _ { \theta } \left( x | \mathbf { x } _ { < t } \right) \in \mathbf { x } _ { t - \ell - 1 : t - 1 } \right] .
+$$
+
+A predicted token is called a “single-token repeat” when $\mathbb { I } \left[ \cdot \right]$ is 1. Some of these single-token repeats also occur in the human-generated sequences, and we thus report a variant which only counts singletoken repeats that are additionally not equal to the ground-truth next-token $( \mathbf { w r e p } / \ell )$ .
+
+Table 2: Results for token-level objectives (upper) and sequence-level fine-tuning (lower) according to sequence-level (left) and token-level (right) metrics using the test subset of Wikitext-103.   
+
+<table><tr><td>Model</td><td>search</td><td> seq-rep-4</td><td>uniq-seq</td><td>ppl</td><td>acc</td><td>rep</td><td>wrep</td><td>uniq</td></tr><tr><td rowspan="2">LMLE</td><td>greedy</td><td>.442</td><td>10.8k</td><td rowspan="2">25.64</td><td rowspan="2">.395</td><td rowspan="2">.627</td><td rowspan="2">.352</td><td rowspan="2">11.8k</td></tr><tr><td>beam</td><td>.523</td><td>9.5k</td></tr><tr><td rowspan="2">LUL-token</td><td>greedy</td><td>.283</td><td>13.2k</td><td rowspan="2">26.91</td><td rowspan="2">.390</td><td rowspan="2">.577</td><td rowspan="2">.311</td><td rowspan="2">12.7k</td></tr><tr><td>beam</td><td>.336</td><td>11.7k</td></tr><tr><td rowspan="2">LUL-seq</td><td>greedy</td><td>.137</td><td>13.1k</td><td rowspan="2">25.42</td><td rowspan="2">.399</td><td rowspan="2">.609</td><td rowspan="2">.335</td><td rowspan="2">12.8k</td></tr><tr><td>beam</td><td>.019</td><td>18.3k</td></tr><tr><td rowspan="2">LUL-token+seq</td><td>greedy</td><td>.058</td><td>15.4k</td><td rowspan="2">26.72</td><td rowspan="2">.395</td><td rowspan="2">.559</td><td rowspan="2">.293</td><td rowspan="2">13.8k</td></tr><tr><td>beam</td><td>.013</td><td>19.1k</td></tr><tr><td>Human</td><td>1</td><td>.006</td><td>19.8k</td><td>-</td><td>-</td><td>.487</td><td>-</td><td>19.8k</td></tr></table>
+
+We use the portion of duplicate $n$ -grams (seq-rep-n) in a generated sequence to measure sequencelevel repetition. That is, for a continuation $\mathbf { X } _ { k + 1 : k + N }$ we compute,
+
+$$
+{ \mathrm { s e q - r e p - n } } = 1 . 0 - { \frac { \left| { \mathrm { u n i q u e ~ n - g r a m s } } ( \mathbf { x } _ { k + 1 : k + N } ) \right| } { \left| { \mathrm { n - g r a m s } } \right| } } ,
+$$
+
+and average over continuations. seq-rep- $\mathbf { \nabla } \cdot \mathbf { n }$ is zero when the continuation has no repeating $\mathbf { n }$ -grams, and increases towards 1.0 as the model repeats. We compute seq-rep-n on the continuation.
+
+Token Distribution We quantify a model’s predicted token distribution using the number of unique tokens. As a token-level metric (uniq), we use the number of unique next-token predictions on a validation or test set $\mathcal { D }$ , i.e. $\left| \left\{ \arg \operatorname* { m a x } p ( x _ { t } | x _ { < t } ) \ : | \ : x _ { < t } \in \mathcal { D } \right\} \right|$ . As a sequence-level metric (uniq-seq) we use the number of unique tokens in continuations of validation or test prefixes (§6).
+
+Language Modeling Quality We use perplexity (ppl), and next-token prediction accuracy (acc), defined as $\scriptstyle { \frac { 1 } { N } } | \{ \arg \operatorname* { m a x } p ( x _ { t } | x _ { < t } ) = x _ { t } ^ { * } \ | \ x _ { < t } ^ { ^ { } } \in { \dot { \mathcal { D } } } \} |$ , with $N$ prefixes $x _ { < t }$ and true next tokens $\boldsymbol { x } _ { t } ^ { * }$ .
+
+# 6.2 RESULTS
+
+Token-level and sequence-level results on the test set are in Table 2 (valid set in Appendix Table 5).
+
+Baseline The baseline model trained with maximum likelihood $( \mathcal { L } _ { \mathrm { M L E } } )$ ) achieved 25.64 test perplexity, comparable to a current state-of-the-art system (Baevski and Auli, 2019) (24.92). However, the greedy baseline’s seq-level repeats (seq-rep-4 .442) and single-token repeats (rep .627) far exceed those in human text (.006, .487 respectively). The baseline continuations have far fewer unique tokens than human text (uniq-seq $1 1 . 8 \mathrm { k }$ vs 19.8k), with a high rate of frequent tokens (Figure 1).
+
+Token-Level Objective The proposed token-level unlikelihood objective ${ \mathcal { L } } _ { \mathrm { U L - t o k e n } } )$ reduced nexttoken wrong repetition (wrep .311 vs. .352) while increasing the number of unique next-tokens (uniq $1 2 . 7 \mathrm { k }$ vs. 11.8k) compared to the baseline $\boldsymbol { \mathcal { L } } _ { \mathrm { M L E } } )$ ). Perplexity and accuracy were similar.
+
+Importantly, the token-level unlikelihood objective yielded substantial improvements in sequencelevel generations. With greedy search, token-level unlikelihood training improved the 4-gram repetition in continuations by $36 \%$ (seq-rep-4 .283 vs. .442) while generating roughly $22 \%$ more unique tokens than the baseline (uniq-seq $1 3 . 2 \mathrm { k }$ vs. $1 0 . 8 \mathrm { k } )$ , and a more favorable rate of infrequent tokens (Figure 1). With beam search, unlikelihood training showed similar improvements over the baseline.
+
+Sequence-Level Objective The sequence level fine-tuning $( \mathcal { L } _ { \mathrm { U L - t o k e n + s e q } } )$ yielded further improvements, with a $97 \%$ reduction in 4-gram repetitions (seq-rep-4 .013 vs. .442) from the baseline level (greedy $\mathcal { L } _ { \mathrm { M L E } } )$ , and $77 \%$ more unique tokens (uniq-seq 19.1k vs. 10.8k) with beam search.
+
+Compared to the token-level unlikelihood model ${ \mathcal { L } } _ { \mathrm { U L - t o k e n } } )$ which was the starting point of finetuning, the fine-tuned model’s repetition substantially improved (seq-rep-4 .058 vs. .283), unique tokens increased (uniq-seq $1 5 . 4 \mathrm { k }$ vs. 13.2k), and token-level metrics such as perplexity improved $\mathrm { ( p p l ~ 2 6 . 7 2 }$ vs. 26.91), despite using only 1,500 updates. The token distribution improved, with infrequent tokens produced more often than the baseline, and frequent tokens approaching the human level (Figure 1). Finally, after sequence-level fine-tuning, beam search out-performed greedy search.
+
+Table 3: Human eval results. \* denotes statistical significance (2-sided binomial test, $p < . 0 5 )$   
+
+<table><tr><td rowspan="2">Winner</td><td rowspan="2">Loser</td><td>Crowdworkers</td><td>Experts</td></tr><tr><td>Win rate</td><td>Win rate</td></tr><tr><td>LUL-token</td><td>LMLE baseline</td><td>57%</td><td></td></tr><tr><td>LUL-seq</td><td>LMLE baseline beats</td><td>*71%</td><td></td></tr><tr><td>LUL-token+seq</td><td>LMLE baseline</td><td>*82%</td><td></td></tr><tr><td>LUL-token+seq</td><td>LUL-token</td><td>*75%</td><td></td></tr><tr><td>LUL-token+seq</td><td>LUL-seq</td><td>59%</td><td></td></tr><tr><td>LUL-token+seq</td><td>beats</td><td>LMLE Nucleus sampling (p= 0.9)</td><td>59%</td><td>*83%</td></tr><tr><td>LUL-token+seq</td><td></td><td>LMLE Beam blocking (4-gram)</td><td>60%</td><td>*74%</td></tr></table>
+
+To visualize how these improvements in metrics translate to generation quality, Table 1 shows greedy completions that characterize the baseline’s degeneration and $\mathcal { L } _ { \mathrm { U L - t o k e n + s e q } }$ ’s improved behavior.
+
+GPT-2 Fine-Tuning In the preceding experiment, sequence-level fine-tuning alone $( \mathcal { L } _ { \mathrm { U L - s e q } } )$ showed substantial improvements over the baseline using a small number of updates. This indicates that the proposed sequence-level fine-tuning can be a cheap, effective way to improve existing pre-trained language models. We demonstrate this by fine-tuning a pre-trained GPT-2 (Radford et al., 2019) language model with sequence-level unlikelihood, using a comparable experimental setup to $\ S 6$ (details in Appendix C). Fine-tuning with unlikelihood yielded similar improvements in sequence-level repetition (seq-rep-4 .042 vs. .506) to those observed in Table 5, while maintaining language modeling quality according to perplexity and accuracy (see Appendix Table 7).
+
+Stochastic Decoding Although we have focused on deterministic decoding, we also confirm that a model trained with the proposed unlikelihood objectives may still be used with stochastic decoders. Appendix Table 6 shows metrics for completions generated with top- $k$ sampling (Fan et al., 2018) and nucleus sampling (Holtzman et al., 2019). Models trained with unlikelihood objectives maintain language modeling quality compared to the baseline, but with improvements in repetition.
+
+Human Evaluation We perform a crowdworker evaluation to judge the quality of the generations of our proposed models compared to each other, the baseline, two other generation methods, and the reference. We employ a pairwise setup: an evaluator is presented with a prefix and shown continuations from two different models and asked to select which continuation they found more natural. Following Li et al. (2019), we filter workers using quality controls (detailed in Appendix E) and limit the number of annotations that they may complete. Prompts are from the Wikitext-103 test set. All models used beam search (beam size 10) for generation, except for those that use stochastic decoding. We report the win rates for each pairwise comparison.
+
+The main results are presented in Table 3, with additional experiments in Appendix Table 9. We find that all proposed models are preferred over the baseline, and that congruent with automatic metrics, win rates improve after adding the sequence level objective. Our best model also outperforms the baseline used with either nucleus sampling or beam blocking.
+
+We also collected limited annotations from other NLP researchers. These Expert annotators were given the same UI as the crowdworkers, and not told about models they were evaluating, but all annotators were familiar with language models. As shown in Table 3, the $\mathcal { L } _ { \mathrm { U L - t o k e n + s e q } }$ model significantly outperforms both nucleus sampling and beam blocking according to the experts.
+
+# 7 CONCLUSION
+
+We described unlikelihood training, an approach to training neural language models. We observed that state-of-the-art models trained to maximize likelihood exhibit neural text degeneration, which we characterized and quantified in terms of repetition and token distribution mismatch. Our results show that the likelihood objective is not constrained enough, in the sense that two models with the same perplexity can exhibit wildly different generation performance. We empirically showed that unlikelihood training - both at the token and sequence levels - substantially reduced degeneration according to automatic metrics, and outperformed likelihood-trained models with various decoding methods according to human evaluation, being superior to the current state-of-the-art approaches.
+
+# REFERENCES
+
+Alexei Baevski and Michael Auli. 2019. Adaptive input representations for neural language modeling. In International Conference on Learning Representations.
+
+Yejin Choi. 2018. The missing representation in neural (language) models. 3rd Workshop on Representation Learning for NLP (RepL4NLP).
+
+Michael Collins. 2002. Discriminative training methods for hidden Markov models: Theory and experiments with perceptron algorithms. In Proceedings of the 2002 Conference on Empirical Methods in Natural Language Processing (EMNLP 2002). Association for Computational Linguistics.
+
+Hal Daume, John Langford, and Daniel Marcu. 2009. Search-based structured prediction. ´ Machine learning, 75(3):297–325.
+
+Adji B Dieng, Kyunghyun Cho, David M Blei, and Yann LeCun. 2018. Learning with reflective likelihoods.
+
+Emily Dinan, Varvara Logacheva, Valentin Malykh, Alexander Miller, Kurt Shuster, Jack Urbanek, Douwe Kiela, Arthur Szlam, Iulian Serban, Ryan Lowe, et al. 2019. The second conversational intelligence challenge (convai2). arXiv preprint arXiv:1902.00098.
+
+Sergey Edunov, Myle Ott, Michael Auli, David Grangier, and Marc’Aurelio Ranzato. 2017. Classical structured prediction losses for sequence to sequence learning. arXiv preprint arXiv:1711.04956.
+
+Angela Fan, Mike Lewis, and Yann Dauphin. 2018. Hierarchical neural story generation. arXiv preprint arXiv:1805.04833.
+
+Tianxing He and James Glass. 2019. Negative training for neural dialogue response generation. arXiv preprint arXiv:1903.02134.
+
+Ari Holtzman, Jan Buys, Maxwell Forbes, Antoine Bosselut, David Golub, and Yejin Choi. 2018. Learning to write with cooperative discriminators. In Proceedings of the 56th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 1638–1649. Association for Computational Linguistics.
+
+Ari Holtzman, Jan Buys, Maxwell Forbes, and Yejin Choi. 2019. The curious case of neural text degeneration. arXiv preprint arXiv:1904.09751.
+
+Guillaume Klein, Yoon Kim, Yuntian Deng, Jean Senellart, and Alexander M Rush. 2017. Opennmt: Open-source toolkit for neural machine translation. arXiv preprint arXiv:1701.02810.
+
+Ilya Kulikov, Alexander H Miller, Kyunghyun Cho, and Jason Weston. 2018. Importance of a search strategy in neural dialogue modelling. arXiv preprint arXiv:1811.00907.
+
+Yann LeCun, Sumit Chopra, Raia Hadsell, M Ranzato, and F Huang. 2006. A tutorial on energybased learning. Predicting structured data.
+
+Jiwei Li, Will Monroe, and Dan Jurafsky. 2016. A simple, fast diverse decoding algorithm for neural generation. arXiv preprint arXiv:1611.08562.
+
+Margaret Li, Jason Weston, and Stephen Roller. 2019. Acute-eval: Improved dialogue evaluation with optimized questions and multi-turn comparisons. arXiv preprint arXiv:1909.03087.
+
+Stephen Merity, Caiming Xiong, James Bradbury, and Richard Socher. 2016. Pointer sentinel mixture models. arXiv preprint arXiv:1609.07843.
+
+Myle Ott, Sergey Edunov, Alexei Baevski, Angela Fan, Sam Gross, Nathan $\mathrm { N g }$ , David Grangier, and Michael Auli. 2019. fairseq: A fast, extensible toolkit for sequence modeling. In Proceedings of NAACL-HLT 2019: Demonstrations.
+
+Romain Paulus, Caiming Xiong, and Richard Socher. 2017. A deep reinforced model for abstractive summarization. arXiv preprint arXiv:1705.04304.
+
+Alec Radford, Jeffrey Wu, Rewon Child, David Luan, Dario Amodei, and Ilya Sutskever. 2019. Language models are unsupervised multitask learners. OpenAI Blog, 1(8).
+
+Marc’Aurelio Ranzato, Sumit Chopra, Michael Auli, and Wojciech Zaremba. 2015. Sequence level training with recurrent neural networks. CoRR, abs/1511.06732.
+
+Stephane Ross, Geoffrey Gordon, and Drew Bagnell. 2011. A reduction of imitation learning and ´ structured prediction to no-regret online learning. In Proceedings of the fourteenth international conference on artificial intelligence and statistics, pages 627–635.
+
+Abigail See, Stephen Roller, Douwe Kiela, and Jason Weston. 2019. What makes a good conversation? how controllable attributes affect human judgments. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), pages 1702–1723, Minneapolis, Minnesota. Association for Computational Linguistics.
+
+Shiqi Shen, Yong Cheng, Zhongjun He, Wei He, Hua Wu, Maosong Sun, and Yang Liu. 2015. Minimum risk training for neural machine translation. arXiv preprint arXiv:1512.02433.
+
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. 2017. Attention is all you need. In Advances in Neural Information Processing Systems, pages 5998–6008.
+
+Jesse Vig. 2018. Deconstructing bert: Distilling 6 patterns from 100 million parameters. Medium.
+
+Ashwin K Vijayakumar, Michael Cogswell, Ramprasaath R Selvaraju, Qing Sun, Stefan Lee, David Crandall, and Dhruv Batra. 2018. Diverse beam search for improved description of complex scenes. In Thirty-Second AAAI Conference on Artificial Intelligence.
+
+Jason Weston, Emily Dinan, and Alexander H Miller. 2018. Retrieve and refine: Improved sequence generation models for dialogue. arXiv preprint arXiv:1808.04776.
+
+Lantao Yu, Weinan Zhang, Jun Wang, and Yingrui Yu. 2016. Seqgan: Sequence generative adversarial nets with policy gradient. ArXiv, abs/1609.05473.
+
+Saizheng Zhang, Emily Dinan, Jack Urbanek, Arthur Szlam, Douwe Kiela, and Jason Weston. 2018. Personalizing dialogue agents: I have a dog, do you have pets too? In Proceedings of the 56th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 2204–2213, Melbourne, Australia. Association for Computational Linguistics.
+
+<table><tr><td>Prefix GPT2-greedy</td><td>Lyrically the song has excerpts of different languages including French,Spanish, German，Italian,Portuguese，Spanish，Portuguese，Portuguese，Portuguese ,Portuguese,Portuguese，Portuguese ，Portuguese ，Portuguese，Portuguese,</td></tr><tr><td>GPT2-top3</td><td>Portuguese,Portuguese,Portuguese,Portuguese, German,Italian,Portuguese,Spanish,Portuguese,Portuguese,Italian and Span- ish.It is also available in English,French and Spanish.In addition to its lyrics,the</td></tr><tr><td>GPT2-nucleus-0.3</td><td>album features a number of original songs,. German,Italian,Portuguese,Spanish,Portuguese,Italian,Portuguese,Spanish ,Portuguese ,Spanish ,Portuguese ,Spanish ,Portuguese ,Spanish,Portuguese,</td></tr><tr><td>Prefix GPT2-greedy</td><td>Spanish,Portuguese ,Spanish,Portuguese ,Spanish,Portuguese , The firstpair ofpereiopodsis armed with a large,asymm etrical,and long-range laser cannon. The second pair is armed with a large ,asym-</td></tr><tr><td>GPT2-top3</td><td>metrical,and long-range laser cannon. The third pair is armed with a large ,asym- metrical,and long-range laser cannon. The fourth pair is armed with a large . etrical,and highly mobile head,and the second pair has a small,asymmetrical,and</td></tr><tr><td></td><td>highly mobile head.The second pair has a large and highly mobile head,and the third pair is armed with a large and highly mobile head.The first pair.</td></tr><tr><td>GPT2-nucleus-0.3</td><td>etrical head and a large body. The first pair of pereiopods is armed with a large , asymmetrical head and a large body. The first pair of pereiopods is armed with a large ,asymmetrical head and a large body. The first pair of pereiopods is armed ...</td></tr></table>
+
+Table 4: Top: Degenerate repetition in completions from a state-of-the-art large-scale language model (Radford et al., 2019). The examples contain single-word repetitions, phrase-level repetitions, and structural repetitions where some tokens within a repeating phrase vary. Recently proposed stochastic samplers (top- $k$ , nucleus) exhibit degeneration based on hyper-parameter settings.
+
+![](images/5ba613d1effe810ec49acbf58d6907519a85ec0e3510bdb78310a1c1e133d8c0.jpg)  
+Figure 1: Sequence-level token distribution using the test subset of Wikitext-103. Nucleus sampling $\mathit { p } = 0 . 9$ ) and beam blocking $P = 4$ ) are used with the maximum likelihood baseline ${ ( \mathcal { L } _ { \mathrm { M L E } } ) }$ .
+
+# A GRADIENT
+
+Notation Let $\boldsymbol { x } _ { t } ^ { * }$ be the true next-token (index $i ^ { * } \in \mathcal { V }$ ) at step $t$ , and let $x _ { \mathrm { n { e g } } }$ be a negative candidate (index $i _ { \mathrm { n e g . } }$ ). Let $p = p ( x _ { t } | x _ { < t } ) \in \mathbb { R } ^ { \mathcal { V } }$ be the output of softmax $( a )$ where $a \in \mathbb { R } ^ { \nu }$ .
+
+Denote the probability of an element $i \in \{ 1 , \ldots , V \}$ as $p _ { i } = p ( x _ { t } ^ { i } | \boldsymbol x _ { < t } )$ , and let $p _ { * }$ , $p _ { \mathrm { n e g } }$ , and $\tilde { p } _ { i }$ be probabilities of the true next-token, negative-candidate token, and any other token with $\bar { i } \notin \{ i ^ { * } , \bar { i } \}$ .
+
+# A.1 DERIVATION
+
+The (negative) token-level loss with a single candidate is,
+
+$$
+\mathcal { L } _ { t } = \log p ( x _ { t } ^ { * } | \boldsymbol { x } _ { < t } ) + \alpha \cdot \log ( 1 - p ( x _ { \mathrm { n e g } } | \boldsymbol { x } _ { < t } ) ) ,
+$$
+
+and its gradient with respect to a logit $a _ { i }$ is:
+
+$$
+\frac { \partial \mathcal { L } } { \partial p _ { i } } \frac { \partial p _ { i } } { \partial a _ { i } } = \left( \mathbb { I } [ i = i ^ { * } ] - p _ { i } \right) - \alpha \frac { p _ { \mathrm { n e g } } } { 1 - p _ { \mathrm { n e g } } } \left( \mathbb { I } [ i = i _ { \mathrm { n e g } } ] - p _ { i } \right) .
+$$
+
+We consider the gradient when $i$ is the true next-token, a negative-candidate, and any other token.
+
+True Next-Token $( i = i ^ { * }$ )
+
+$$
+\begin{array} { c } { \displaystyle \frac { \partial \mathcal { L } } { \partial p _ { * } } \frac { \partial p _ { * } } { \partial a _ { i ^ { * } } } = ( 1 - p _ { * } ) - \alpha \frac { p _ { \mathrm { n e g } } } { 1 - p _ { \mathrm { n e g } } } ( 0 - p _ { * } ) } \\ { \displaystyle = 1 - p _ { * } ( 1 - \alpha \frac { p _ { \mathrm { n e g } } } { 1 - p _ { \mathrm { n e g } } } ) . } \end{array}
+$$
+
+Negative Candidate $( i = i _ { \mathbf { n } \mathbf { e } \mathbf { g } } )$ )
+
+$$
+\begin{array} { c c c } { \displaystyle { \frac { \partial \mathcal { L } } { \partial p _ { \mathrm { n e g } } } \frac { \partial p _ { \mathrm { n e g } } } { \partial a _ { \mathrm { n e g } } } = ( 0 - p _ { \mathrm { n e g } } ) - \alpha \frac { p _ { \mathrm { n e g } } } { 1 - p _ { \mathrm { n e g } } } ( 1 - p _ { \mathrm { n e g } } ) } } \\ { \displaystyle { = - p _ { \mathrm { n e g } } ( 1 + \alpha ) . } } \end{array}
+$$
+
+Other Token $( i \not \in \{ i ^ { * } , i _ { \mathrm { n e g } } \} )$
+
+$$
+\begin{array} { c } { { \displaystyle \frac { \partial \mathcal { L } } { \partial \tilde { p } _ { i } } \frac { \partial \tilde { p } _ { i } } { \partial a _ { i } } = ( 0 - \tilde { p } _ { i } ) - \alpha \frac { p _ { \mathrm { n e g } } } { 1 - p _ { \mathrm { n e g } } } ( 0 - \tilde { p } _ { i } ) } } \\ { { = - \tilde { p } _ { i } ( 1 - \alpha \frac { p _ { \mathrm { n e g } } } { 1 - p _ { \mathrm { n e g } } } ) . } } \end{array}
+$$
+
+Combining the three cases above, we get:
+
+$$
+\nabla \mathcal { L } _ { a } = x ^ { * } - m \odot p ,
+$$
+
+where $x ^ { * } \in \{ 0 , 1 \} ^ { V }$ is 1 at index $i ^ { * }$ and 0 otherwise, and $m \in \mathbb { R } ^ { V }$ is:
+
+$$
+m _ { i } = \left\{ \begin{array} { l l } { ( 1 - \alpha \frac { p _ { \mathrm { n e g } } } { 1 - p _ { \mathrm { n e g } } } ) } & { i \neq i _ { \mathrm { n e g } } } \\ { ( 1 + \alpha ) } & { i = i _ { \mathrm { n e g } } . } \end{array} \right.
+$$
+
+Multiple Candidates In general the objective considers multiple candidates (see section 5):
+
+$$
+\mathcal { L } _ { \mathrm { U L - t o k e n } } ^ { t } ( p _ { \theta } ( \cdot | x _ { < t } ) , \mathcal { C } ^ { t } ) = - \alpha \cdot \sum _ { c \in \mathcal { C } ^ { t } } \log ( 1 - p _ { \theta } ( c | x _ { < t } ) ) - \underbrace { \log p _ { \theta } ( x _ { t } | x _ { < t } ) } _ { \mathrm { l i t e l i h o o d } } .
+$$
+
+We regroup the token-level objective to be a weighted sum of per-candidate objectives:
+
+$$
+- \mathcal { L } _ { \mathrm { U L } \cdot \mathrm { t o k e n } } ^ { t } ( p _ { \theta } ( \cdot | x _ { < t } ) , \mathcal { C } ^ { t } ) = \frac { 1 } { | \mathcal { C } ^ { t } | } \sum _ { c \in \mathcal { C } ^ { t } } \left( \log p _ { \theta } ( x _ { t } | x _ { < t } ) + \alpha _ { c } \cdot \log ( 1 - p _ { \theta } ( c | x _ { < t } ) ) \right)
+$$
+
+where $\alpha _ { c } = \alpha \cdot | \mathcal { C } ^ { t } |$ .
+
+Now the gradient can be generalized to multiple candidates, in which case the gradient takes the same form as Eqn. 20, but with $\alpha _ { c }$ in place of $\alpha$ .
+
+Table 5: Results for token-level objectives (upper) and sequence-level fine-tuning (lower) according to sequence-level (left) and token-level (right) metrics using the validation subset of wikitext-103.   
+
+<table><tr><td>Model</td><td>search</td><td> seq-rep-4</td><td>uniq-seq</td><td>ppl</td><td>acc</td><td>rep</td><td>wrep</td><td>uniq</td></tr><tr><td rowspan="2">LMLE</td><td>greedy</td><td>.429</td><td>10.6k</td><td rowspan="2">24.59</td><td rowspan="2">.401</td><td rowspan="2">.619</td><td rowspan="2">.346</td><td rowspan="2">11.6k</td></tr><tr><td>beam</td><td>.495</td><td>9.4k</td></tr><tr><td rowspan="2">LUL-token</td><td>greedy</td><td>.274</td><td>12.6k</td><td rowspan="2">25.62</td><td rowspan="2">.396</td><td rowspan="2">.569</td><td rowspan="2">.305</td><td rowspan="2">12.5k</td></tr><tr><td>beam</td><td>.327</td><td>11.2k</td></tr><tr><td rowspan="2">LUL-seq</td><td>greedy</td><td>.130</td><td>12.7k</td><td rowspan="2">24.28</td><td rowspan="2">.406</td><td rowspan="2">.603</td><td rowspan="2">.329</td><td rowspan="2">12.4k</td></tr><tr><td>beam</td><td>.018</td><td>16.8k</td></tr><tr><td rowspan="2">LUL-token+seq</td><td>greedy</td><td>.051</td><td>14.8k</td><td rowspan="2">25.37</td><td rowspan="2">.401</td><td rowspan="2">.551</td><td rowspan="2">.287</td><td rowspan="2">13.4k</td></tr><tr><td>beam</td><td>.013</td><td>17.6k</td></tr><tr><td>Human</td><td>1</td><td>.005</td><td>18.9k</td><td>-</td><td>1</td><td>.479</td><td>1</td><td>18.9k</td></tr></table>
+
+<table><tr><td>Search</td><td>Model</td><td> seq-rep-4</td><td>uniq-seq</td><td>ppl</td><td>acc</td><td>rep</td><td>wrep</td><td>uniq</td></tr><tr><td rowspan="4">top-k-3</td><td>LMLE</td><td>.0991</td><td>14.7k</td><td>25.70</td><td>.350</td><td>.597</td><td>.355</td><td>12.6k</td></tr><tr><td>LUL-token</td><td>.0491</td><td>16.4k</td><td>27.02</td><td>.344</td><td>.539</td><td>.306</td><td>13.6k</td></tr><tr><td>LUL-seq</td><td>.0068</td><td>17.9k</td><td>25.11</td><td>.353</td><td>.581</td><td>.341</td><td>13.6k</td></tr><tr><td>LUL-token+seq</td><td>.0087</td><td>15.2k</td><td>26.84</td><td>.347</td><td>.524</td><td>.292</td><td>14.6k</td></tr><tr><td rowspan="4">top-k-50</td><td>LMLE</td><td>.0165</td><td>21.9k</td><td>25.70</td><td>.302</td><td>.511</td><td>.303</td><td>16.1k</td></tr><tr><td>LUL-token</td><td>.006</td><td>23.5k</td><td>27.02</td><td>.286</td><td>.440</td><td>.247</td><td>17.8k</td></tr><tr><td>LUL-seq</td><td>.0005</td><td>25.7k</td><td>25.11</td><td>.291</td><td>.497</td><td>.291</td><td>17.3k</td></tr><tr><td>LUL-token+seq</td><td>.0009</td><td>23.7k</td><td>26.84</td><td>.289</td><td>.430</td><td>.238</td><td>18.8k</td></tr><tr><td rowspan="4">top-p-0.3</td><td>LMLE</td><td>.273</td><td>13.6k</td><td>25.70</td><td>.264</td><td>.339</td><td>.154</td><td>12.6k</td></tr><tr><td>LUL-token</td><td>.101</td><td>16.5k</td><td>27.02</td><td>.247</td><td>.290</td><td>.121</td><td>13.9k</td></tr><tr><td>LUL-seq</td><td>.0033</td><td>20.8k</td><td>25.11</td><td>.266</td><td>.327</td><td>.145</td><td>13.6k</td></tr><tr><td>LUL-token+seq</td><td>.0041</td><td>19.1k</td><td>26.84</td><td>.250</td><td>.284</td><td>.116</td><td>14.9k</td></tr><tr><td rowspan="4">top-p-0.9</td><td>LMLE</td><td>.0154</td><td>26.9k</td><td>25.70</td><td>.288</td><td>.462</td><td>.263</td><td>18.6k</td></tr><tr><td>LUL-token</td><td>.004</td><td>30.2k</td><td>27.02</td><td>.266</td><td>.381</td><td>.202</td><td>22.3k</td></tr><tr><td>LUL-seq</td><td>.0003</td><td>34.7k</td><td>25.11</td><td>.290</td><td>.450</td><td>.254</td><td>19.6k</td></tr><tr><td>LUL-token+seq</td><td>.0007</td><td>32.4k</td><td>26.84</td><td>.269</td><td>.376</td><td>.198</td><td>22.7k</td></tr><tr><td>Human</td><td>=</td><td>.006</td><td>19.8k</td><td>-</td><td>-</td><td>.487</td><td>1</td><td>19.8k</td></tr></table>
+
+Table 6: Stochastic decoding results according to sequence-level (left) and token-level (right) metrics using the test subset of Wikitext-103.
+
+# B STOCHASTIC DECODING RESULTS
+
+Table 6 provides automatic metrics for top- $k$ and nucleus sampling (called top- $p$ ) on the Wikitext103 test set. These can be compared with the main results of the paper in Table 2. In general, sampling methods yield worse next-token predictions than deterministic approaches (0.302 vs. 0.394 acc for top- $\cdot \mathrm { k } { - } 5 0$ vs. greedy MLE, where acc for stochastic decoding measures the probability that the decoding strategy chooses the ground truth word given a ground truth context). As the choice of sampling hyperparameter gets closer to greedy (i.e. lower values of $k$ and $p$ ) next token accuracy improves, eventually approaching the greedy MLE results. The unlikelihood-trained sampling models have similar next token accuracy (acc) to their likelihood-trained counterparts, but exhibit fewer repetitions. For lower values of $p$ and $k$ the improvements of unlikelihood training are larger, e.g. 0.277 reduced to 0.0041 for 4-gram sequence repetitions (seq-rep-4) using top-p-0.3. At higher levels of $p$ and $k$ , for all methods the continuations contain more unique tokens than that of humans, meaning those values may be too high.
+
+Table 7: GPT-2 results according to sequence-level and token-level metrics using the validation subset of wikitext-103. seq-rep-4 is computed on the word level; ppl, acc, rep, wrep are computed on the BPE level.   
+
+<table><tr><td>Model</td><td>search</td><td> seq-rep-4</td><td>ppl</td><td>acc</td><td>rep</td><td>wrep</td><td>uniq</td></tr><tr><td>GPT-2</td><td>greedy</td><td>.506</td><td>20.75</td><td>.430</td><td>.589</td><td>.306</td><td>13.3k</td></tr><tr><td>GPT-2MLE</td><td>greedy</td><td>.460</td><td>15.82</td><td>.464</td><td>.612</td><td>.305</td><td>11.8k</td></tr><tr><td>GPT-2UL-seq</td><td>greedy</td><td>.042</td><td>18.49</td><td>.444</td><td>.613</td><td>.317</td><td>11.3k</td></tr><tr><td>Human</td><td>-</td><td>.005</td><td>-</td><td>-</td><td>.407</td><td>1</td><td>17.7k</td></tr></table>
+
+# C GPT-2 FINE-TUNING
+
+We evaluated the GPT-2 medium pre-trained model (‘GPT-2’) and two separate fine-tuning variants on Wikitext-103. The first variant $( ^ { \bullet } \mathbf { G P T } \ – 2 _ { \mathbf { M L E } } ^ { } )$ was fine-tuned using maximum likelihood; we select the model state with the lowest validation perplexity. The second model $\mathrm { \mathrm { : G P T } } { \cdot } 2 _ { \mathrm { U L } { \cdot } \mathrm { s e q } } ,$ ) was fine-tuned using the sequence-level unlikelihood objective (§5.2). For both evaluation and sequencelevel tuning, we used a prefix length of 50 BPE tokens and a continuation length of 100 BPE tokens. In order to train on a single GPU, we used a batch-size of 1024 tokens for MLE updates, and 300 prefix tokens for unlikelihood updates. Due to the smaller batch size and single-GPU setting, we used 10,000 updates during sequence-level fine-tuning, comparable to the 1,500 updates in the main experiment (§6) in terms of the total number of tokens. Results are shown in Table 7.
+
+# D SEQUENCE-LEVEL RANDOM CANDIDATES
+
+In Sec. 5.2 we described a way to penalize tokens that occurred in a n-gram repetition. One alternative is to penalize a random subset of the generated sequence. That is, given a continuation xt+1, . . . , xt+K , we now define per-step candidates (Ck+1, $( { \mathcal { C } } ^ { k + 1 } , \ldots , { \mathcal { C } } ^ { k + N } )$ as:
+
+$$
+{ \mathcal { C } } _ { \mathrm { r a n d o m - s e q } } ^ { t } = { \left\{ \begin{array} { l l } { \{ x _ { t } \} } & { { \mathrm { ~ i f ~ } } z _ { t } = 1 } \\ { \emptyset } & { { \mathrm { ~ i f ~ } } z _ { t } = 0 , } \end{array} \right. }
+$$
+
+for each $t \in \{ k + 1 , \ldots , k + N \}$ , where $z _ { t } \sim \mathrm { B e r n o u l l i } ( p _ { \mathrm { p e n a l i z e } } )$ , and $p _ { \mathrm { p e n a l i z e } } \in [ 0 , 1 ]$ is a fixed hyper-parameter. Intuitively, these candidates identify random tokens in the generated sequence (hence ‘random-seq’), which are then penalized by the sequence-level loss (Eqn. 7).
+
+Results with different values of $p _ { \mathrm { p e n a l i z e } }$ are shown in Table 8. Penalizing $10 \%$ of the generated tokens led to substantial improvements in seq-rep-4 for both greedy and beam search compared to the baseline (e.g. $41 \%$ for ${ \mathcal { L } } _ { \mathrm { U L - s e q } }$ greedy, $73 \%$ for $\mathcal { L } _ { \mathrm { U L - t o k + s e q } }$ greedy), though using n-gram repetition candidates yielded further improvements (§5.2, Table 5). Improvements in single-token metrics were similar to those from the $\mathbf { n }$ -gram repetition candidates (e.g. wrep .287). These results with random-seq candidates demonstrate that sequence fine-tuning can yield improvements without explicitly using the notion of repetition for candidate selection. We also find that penalizing $90 \%$ of the generated tokens yields substantial improvements in beam search, but not greedy search; investigating this is left as future work.
+
+Table 8: Results for sequence-level fine-tuning using random-seq candidates according to sequence-level (left) and token-level (right) metrics using the validation subset of wikitext-103.   
+
+<table><tr><td>Model</td><td>Ppenalize</td><td>search</td><td> seq-rep-4</td><td> uniq-seq</td><td>ppl</td><td>acc</td><td>rep</td><td>wrep</td><td>uniq</td></tr><tr><td rowspan="2">LMLE</td><td rowspan="2">1</td><td>greedy</td><td>.429</td><td>10.6k</td><td rowspan="2">24.590</td><td rowspan="2">.401</td><td rowspan="2">.619</td><td rowspan="2">.346</td><td rowspan="2">11.6k</td></tr><tr><td>beam 1</td><td>.495</td><td>9.4k</td></tr><tr><td rowspan="2">LUL-seq</td><td rowspan="2">0.1</td><td>greedy</td><td>.253</td><td>9.9k</td><td rowspan="2">24.329</td><td rowspan="2">.404</td><td rowspan="2">.602</td><td rowspan="2">.330</td><td rowspan="2">12.3k</td></tr><tr><td>beam</td><td>.274</td><td>13.1k</td></tr><tr><td rowspan="2">LUL-seq</td><td rowspan="2">0.9</td><td>greedy</td><td>.434</td><td>5.3k</td><td rowspan="2">26.519</td><td rowspan="2">.399</td><td rowspan="2">.600</td><td rowspan="2">.330</td><td rowspan="2">12.2k</td></tr><tr><td>beam</td><td>.231</td><td>13.5k</td></tr><tr><td rowspan="2">LUL-tok+seq</td><td rowspan="2">0.1</td><td></td><td>.116</td><td>12.5k</td><td rowspan="2">25.518</td><td rowspan="2">.399</td><td rowspan="2">.551</td><td rowspan="2">.287</td><td rowspan="2">13.2k</td></tr><tr><td>greedy</td><td></td><td>14.2k</td></tr><tr><td rowspan="2">LUL-tok+seq</td><td rowspan="2">0.9</td><td>beam</td><td>.146</td><td>6.7k</td><td rowspan="2">26.629</td><td rowspan="2">.396</td><td rowspan="2">.551</td><td rowspan="2">.288</td><td rowspan="2">13.2k</td></tr><tr><td>greedy</td><td>.423</td><td></td></tr><tr><td></td><td></td><td>beam</td><td>.080</td><td>16k</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>Human</td><td>-</td><td>1</td><td>.005</td><td>18.9k</td><td>1</td><td>1</td><td>.479</td><td>1</td><td>18.9k</td></tr></table>
+
+# E HUMAN EVALUATION DETAILS
+
+# E.1 UI SCREENSHOT
+
+![](images/89f65dff900b580575d37bb44b003722dd7081b83f1ff1619a61d4b8c93b6773.jpg)  
+Figure 2: Screen shot of the user interface used in the human evaluation.
+
+# E.2 CROWDWORKER QUALITY CONTROLS
+
+We require workers to correctly answer both of the following quality control questions for their evaluations to be included. Both quality controls compare the true completion against a greedy baseline model.
+
+Following Li et al. (2019), we informed workers that they must provide reasoning for their choices.   
+We filtered workers who did not provide reasoning for at least $80 \%$ of their choices.
+
+$63 \%$ of workers fail at least one of our three quality control mechanisms (2 quality control metrics, and failing to give reasons). $61 \%$ fail at least one quality control question; $16 \%$ of workers fail both; $4 \%$ of workers fail to give reasoning for their choices.
+
+# E.2.1 QUALITY CONTROL 1
+
+Prompt $= = \operatorname { I n }$ the decades since its release , The Hustler has cemented its reputation as a classic . Roger Ebert , echoing earlier praise for the performances , direction , and cinematography and adding laurels for editor Dede Allen , cites the film as ” one of”’
+
+Correct answer those films where scenes have such psychic weight that they grow in our memories . ” He further cites Fast Eddie Felson as one of ” only a handful of movie characters so real that the audience refers to them as touchstones . ” TV Guide calls the film a ” dark stunner ” offering ” a grim world whose only bright spot is the top of the pool table , yet [ with ] characters [ who ] maintain a shabby nobility and grace . ” The four leads are again lavishly praised for their performances and the
+
+Incorrect answer the most influential films of the year ” . In his review for the Chicago Sun $@ - @$ Times , Richard Corliss calls it ” a film of the highest order ” and ” a film of the highest order ” . In his review for the Chicago Sun $@ - @$ Times , Richard Corliss calls it ” a film of the highest order ” and ” a film of the highest order ” . In his review for the Chicago Sun $@ - @$ Times , Richard Corliss calls it ” a film of the highest order ” and ” a film of
+
+# E.2.2 QUALITY CONTROL 2
+
+Prompt , which had a major negative effect on the state ’s large merchant fleet . Gore was in 1808 elected to the Massachusetts House of Representatives , where he successfully led Federalist efforts to ensure the selection of a Federalist slate of presidential electors . He also spearheaded actions to
+
+Correct answer drive Senator John Quincy Adams from the Federalist Party over his support of Thomas Jefferson ’s foreign policy . The legislature elected Adams ’ successor nine months early , and gave Adams sufficiently distasteful instructions that he resigned the post and joined with the Republicans . $= =$ Governor $= =$ Gore led the Federalists to victory in 1809 against Sullivan ’s successor , Levi Lincoln , Sr. , who had taken over as acting governor upon Sullivan ’s death late in 1808 . During Gore ’s term the principal domestic issue occupying state politics
+
+Incorrect Answer prevent the American Revolutionary War from being fought by the British , and to prevent the British from using the country to launch a war against the British . Gore ’s actions in the House of Representatives were a major turning point in his political career . He was elected to the House of Representatives in 1811 , and served until his death in 1815 . $= =$ Early life and education $= = \mathrm { j } / \mathrm { s } _ { \dot { G } } \mathrm { \Delta } \mathrm { j } / \mathrm { s } _ { \dot { G } }$ Gore was born in Boston , Massachusetts , on February 22 , 1798 , the son of Benjamin Gore and his
+
+E.3 FULL HUMAN EVALUATION RESULTS
+
+Table 9: Full human evaluation results. Includes additional comparisons omitted for brevity, and the raw number of wins and loses by each comparison.   
+
+<table><tr><td rowspan="2" colspan="2">Winner</td><td rowspan="2">Loser</td><td colspan="2">Crowdworkers</td><td colspan="2">Experts</td></tr><tr><td>Win rate</td><td>W-L</td><td>Win rate</td><td>W-L</td></tr><tr><td>LUL-token</td><td rowspan="5"></td><td>LMLE baseline</td><td>57%</td><td>17-13</td><td rowspan="5"></td><td></td></tr><tr><td>LUL-seq</td><td>LMLE baseline</td><td>*71%</td><td>41-17</td><td></td></tr><tr><td>LUL-token+seq</td><td>LMLE baseline</td><td>*82%</td><td>41-9</td><td></td></tr><tr><td>LUL-token+seq</td><td>LUL-token</td><td>*75%</td><td>56-19</td><td></td></tr><tr><td>LUL-token+seq</td><td>LUL-seq</td><td>59%</td><td>38-27</td><td></td></tr><tr><td></td><td rowspan="3">beats</td><td></td><td>59%</td><td></td><td>*83%</td><td>30-6</td></tr><tr><td>LUL-token+seq LUL-token+seq</td><td>Nucleus Beam blocking</td><td>60%</td><td>47-33 50-34</td><td>*74%</td><td>25-9</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>Reference</td><td rowspan="5">beats</td><td>LMLE baseline</td><td>*85%</td><td>17-3</td><td></td><td></td></tr><tr><td>Reference</td><td>Nucleus</td><td>*69%</td><td>38-17</td><td></td><td></td></tr><tr><td>Reference</td><td>Beam blocking</td><td>*68%</td><td>48-23</td><td></td><td></td></tr><tr><td>Reference</td><td>LUL-token</td><td>*73%</td><td>44-16</td><td></td><td></td></tr><tr><td>Reference Reference</td><td>LUL-seq LUL-token+seq</td><td>50% *64%</td><td>30-30 46-26</td><td></td><td></td></tr></table>

parse/train/q0h6av9Vi8/q0h6av9Vi8.md

@@ -0,0 +1,293 @@
+# Light Field Networks: Neural Scene Representations with Single-Evaluation Rendering
+
+Vincent Sitzmann1,∗ sitzmann@mit.edu
+
+Semon Rezchikov2,∗ skr@math.columbia.edu
+
+William T. Freeman1,3 billf@mit.edu
+
+Joshua B. Tenenbaum1,4,5 jbt@mit.edu
+
+Frédo Durand1 fredo@mit.edu
+
+1MIT CSAIL 2Columbia University 3 IAFI 4MIT BCS 5 CBMM vsitzmann.github.io/lfns/
+
+# Abstract
+
+Inferring representations of 3D scenes from 2D observations is a fundamental problem of computer graphics, computer vision, and artificial intelligence. Emerging 3D-structured neural scene representations are a promising approach to 3D scene understanding. In this work, we propose a novel neural scene representation, Light Field Networks or LFNs, which represent both geometry and appearance of the underlying 3D scene in a 360-degree, four-dimensional light field parameterized via a neural network. Rendering a ray from an LFN requires only a single network evaluation, as opposed to hundreds of evaluations per ray for ray-marching or volumetric based renderers in 3D-structured neural scene representations. In the setting of simple scenes, we leverage meta-learning to learn a prior over LFNs that enables multi-view consistent light field reconstruction from as little as a single image observation. This results in dramatic reductions in time and memory complexity, and enables real-time rendering. The cost of storing a 360-degree light field via an LFN is two orders of magnitude lower than conventional methods such as the Lumigraph. Utilizing the analytical differentiability of neural implicit representations and a novel parameterization of light space, we further demonstrate the extraction of sparse depth maps from LFNs.
+
+# 1 Introduction
+
+A fundamental problem across computer graphics, computer vision, and artificial intelligence is to infer a representation of a scene’s 3D shape and appearance given impoverished observations such as 2D images of the scene. Recent contributions have advanced the state of the art for this problem significantly. First, neural implicit representations have enabled efficient representation of local 3D scene properties by mapping a 3D coordinate to local properties of the 3D scene at that coordinate $[ 1 -$ 6]. Second, differentiable neural renderers allow for the inference of these representations given only 2D image observations [3, 4]. Finally, leveraging meta-learning approaches such as hypernetworks or gradient-based meta-learning has enabled the learning of distributions of 3D scenes, and therefore reconstruction given only a single image observation [3]. This has enabled a number of applications, such as novel view synthesis [7, 3, 6], 3D reconstruction [5, 3] semantic segmentation [8, 9], and SLAM [10]. However, 3D-structured neural scene representations come with a major limitation: Their rendering is prohibitively expensive, on the order of tens of seconds for a single $2 5 6 \times 2 5 6$ image for state-of-the-art approaches. In particular, parameterizing the scene in 3D space necessitates the discovery of surfaces along camera rays during rendering. This can be solved either by encoding geometry as a level set of an occupancy or signed distance function, or via volumetric rendering, which solves an alpha-compositing problem along each ray. Either approach, however, requires tens or even hundreds of evaluations of the 3D neural scene representation in order to render a single camera ray.
+
+We propose a novel neural scene representation, dubbed Light Field Networks or LFNs. Instead of encoding a scene in 3D space, Light Field Networks encode a scene by directly mapping an oriented camera ray in the four dimensional space of light rays to the radiance observed by that ray. This obviates the need to query opacity and RGB at 3D locations along a ray or to ray-march towards the level set of a signed distance function, speeding up rendering by three orders of magnitude compared to volumetric methods. In addition to directly encoding appearance, we demonstrate that LFNs encode information about scene geometry in their derivatives. Utilizing the unique flexibility of neural field representations, we introduce the use of Plücker coordinates to parameterize 360-degree light fields, which allow for storage of a-priori unbounded scenes and admit a simple expression for the depth as an analytical function of an LFN. Using this relationship, we demonstrate the computation of geometry in the form of sparse depth maps. While 3D-structured neural scene representations are multi-view consistent by design, parameterizing a scene in light space does not come with this guarantee: the additional degree of freedom enables rays that view the same 3D point to change appearance across viewpoints. For the setting of simple scenes, we demonstrate that this challenge can be overcome by learning a prior over 4D light fields in a meta-learning framework. We benchmark with current state-of-the-art approaches for single-shot novel view synthesis, and demonstrate that LFNs compare favorably with globally conditioned 3D-structured representations, while accelerating rendering and reducing memory consumption by orders of magnitude.
+
+In summary, we make the following contributions:
+
+1. We propose Light Field Networks (LFNs), a novel neural scene representation that directly parameterizes the light field of a 3D scene via a neural network, enabling real-time rendering and vast reduction in memory utilization.   
+2. We demonstrate that we may leverage 6-dimensional Plücker coordinates as a parameterization of light fields, despite their apparent overparameterization of the 4D space of rays, thereby enabling continuous, 360-degree light fields.   
+3. By embedding LFNs in a meta-learning framework, we demonstrate light field reconstruction and novel view synthesis of simple scenes from sparse 2D image supervision only.   
+4. We demonstrate that inferred LFNs encode both appearance and geometry of the underlying 3D scenes by extracting sparse depth maps from the derivatives of LFNs, leveraging their analytical differentiability.
+
+Scope. The proposed method is currently constrained to the reconstruction of simple scenes, such as single objects and simple room-scale scenes, in line with recent work on learning generative models in this regime [3, 11].
+
+# 2 Related Work
+
+Neural Scene Representations and Neural Rendering. A large body of work addresses the question of inferring feature representations of 3D scenes useful to downstream tasks across graphics, vision, and machine learning. Models without 3D structure suffer from poor data efficiency [12, 13]. Voxel grids [14–20] offer 3D structure, but scale poorly with spatial resolution. Inspired by neural implicit representations of 3D geometry [1, 2], recent work has proposed to encode properties of 3D scenes as neural fields (also implicit- or coordinate-based representations, see [21] for an overview), neural networks that map 3D coordinates to local properties of the 3D scene at these coordinates. Using differentiable rendering, these models can be learned from image observations only [3, 4, 22, 11]. Reconstruction from sparse observations can be achieved by learning priors over the space of neural fields [3, 5, 11, 23–25] or by conditioning of the neural field on local features [6, 26, 27]. Differentiable rendering of such 3D-structured neural scene representations is exceptionally computationally intensive, requiring hundreds of evaluations of the neural representation per ray, with tens of thousands to millions of rays per image. Some recent work seeks to accelerate test-time rendering, but either does not admit generalization [28–30], or does not alleviate the cost of rendering at training/inference time [31–33]. With Light Field Networks, we propose to leverage 360- degree light fields as neural scene representations. We introduce a novel neural field parameterization of 360-degree light fields, infer light fields via meta-learning from as few as a single 2D image observation, and demonstrate that LFNs encode both scene geometry and appearance.
+
+![](images/f984b102b6a5cea20d418143230c2e728adb213ce51b7f5ce7db780b4765d219.jpg)  
+Figure 1: Overview. We propose Light Field Networks or LFNs, which encode the full 360-degree light field of a 3D scene in the weights of a fully connected neural network $\Phi _ { \phi }$ (with weights $\phi$ conditioned on a latent code $\mathbf { z }$ ) that maps an oriented ray $\mathbf { r }$ to the radiance c observed by that ray. Rendering an LFN $\Phi _ { \phi }$ only requires evaluating the underlying MLP once per ray, in contrast to 3D-structured neural scene representations $\Phi _ { 3 D }$ such as SRNs [3], NeRF [4], or DVR [5] that require hundreds of evaluations per ray. We leverage meta-learning to learn a multi-view consistent space of LFNs. Once trained, this enables reconstruction of a 360-degree light field and subsequent real-time novel view synthesis of simple scenes from only a single observation.
+
+Light fields and their reconstruction. Light fields have a rich history as a scene representation in both computer vision and computer graphics. Adelson et al. [34] introduced the 5D plenoptic function as a unified representation of information in the early visual system [35]. Levoy et al. [36] and, concurrently, Gortler et al. [37] introduced light fields in computer graphics as a 4D sampled scene representation for fast image-based rendering. Light fields have since enjoyed popularity as a representation for novel view synthesis [38] and computational photography, e.g. [39]. Light fields enable direct rendering of novel views by simply extracting a 2D slice of the 4D light field. However, they tend to incur significant storage cost, and since they rely on two-plane parameterizations, they make it hard to achieve a full 360-degree representation without concatenating multiple light fields. A significant amount of prior work addresses reconstruction of fronto-parallel light fields via handcrafted priors, such as sparsity in the Fourier or shearlet domains [40–42]. With the advent of deep learning, approaches to light field reconstruction that leverage convolutional neural networks to in-paint or extrapolate light fields from sparse views have been proposed [43, 7, 44], but similarly only support fronto-parallel novel view synthesis. We are instead interested in light fields as a representation of 3D appearance and geometry that enables efficient inference of and reasoning about the properties of the full underlying scene.
+
+# 3 Background: 3D-structured Neural Scene Representations
+
+Recent progress in neural scene representation and rendering has been driven by two key innovations. The first are neural fields, often also referred to as neural implicit- or coordinate-based scene representations $\Phi ^ { 3 D }$ [3, 4], which model a scene as a continuous function, parameterized as an MLP which maps a 3D coordinate to a representation $\mathbf { v }$ of whatever is at that 3D coordinate:
+
+$$
+\Phi ^ { 3 D } : \mathbb { R } ^ { 3 } \to \mathbb { R } ^ { n } , \quad \mathbf { x } \mapsto \Phi ^ { 3 D } ( \mathbf { x } ) = \mathbf { v } .
+$$
+
+The second is a differentiable renderer $\mathbf { m }$ , which, given a ray $\mathbf { r }$ in $\mathbb { R } ^ { 3 }$ , and the representation $\Phi ^ { 3 D }$ , computes the value of the color c of the scene when viewed along r:
+
+$$
+\begin{array} { r } { { \bf m } ( { \bf r } , \Phi ^ { 3 D } ) = { \bf c } ( { \bf r } ) \in \mathbb { R } ^ { 3 } . } \end{array}
+$$
+
+Existing rendering methods broadly fall into two categories: sphere-tracing-based renderers [3, 45, 5, 46] and volumetric renderers [19, 4]. These methods require on the order of tens or hundreds of
+
+evaluations of the values of $\Phi ^ { 3 D }$ along a ray $\mathbf { r }$ to compute $\mathbf { c } ( \mathbf { r } )$ . This leads to extraordinarily large memory and time complexity of rendering. As training requires error backpropagation through the renderer, this impacts both training and test time.
+
+# 4 The Light Field Network Scene Representation
+
+We propose to represent a scene as a 360-degree neural light field, a function parameterized by an MLP $\Phi _ { \phi }$ with parameters $\phi$ that directly maps the 4D space $\mathcal { L }$ of oriented rays to their observed radiance:
+
+$$
+\Phi _ { \phi } : \mathcal { L } \to \mathbb { R } ^ { 3 } , \mathbf { r } \mapsto \Phi _ { \phi } ( \mathbf { r } ) = \mathbf { c } ( \mathbf { r } ) .
+$$
+
+A light field completely characterizes the flow of light through unobstructed space in a static scene with fixed illumination. Light fields have the unique property that rendering is achieved by a single evaluation of $\Phi$ per light ray, i.e., no ray-casting is required. Moreover, while the light field only encodes appearance explicitly, its derivatives encode geometry information about the underlying 3D scene [47, 34, 35]. This makes many methods to extract 3D geometry from light fields possible [48–51], and we demonstrate efficient recovery of sparse depth maps from LFNs below.
+
+# 4.1 Implicit representations for 360 degree light fields
+
+To fully represent a 3D scene requires a parameterization of all light rays in space. Conventional light field methods are constrained to leverage minimal parameterizations of the 4D space of rays, due to the high memory requirements of discretely sampled high-dimensional spaces. In contrast, our use of neural field representations allows us to freely choose a continuous parameterization that is mathematically convenient. In particular, we propose to leverage the 6D Plücker parameterization of the space of light rays $\mathcal { L }$ for LFNs. The Plücker coordinates (see [52] for an excellent overview) of a ray $\mathbf { r }$ through a point $\mathbf { p }$ in a normalized direction $\mathbf { d }$ are
+
+$$
+\begin{array} { r } { \mathbf { m } = \mathbf { p } \times \mathbf { d } , \ \mathrm { f o r } \quad \mathbf { d } \in \mathbb { S } ^ { 2 } , \mathbf { p } \in \mathbb { R } ^ { 3 } . } \end{array}
+$$
+
+where $\times$ denotes the cross product. While Plücker coordinates are a-priori 6-tuples of real numbers, the coordinates of any ray lie on a curved 4-dimensional subspace $\mathcal { L }$ . Plücker coordinates uniformly represent all oriented rays in space without singular directions or special cases. Intuitively, a general ray $\mathbf { r }$ together with the origin define a plane, and $\mathbf { m }$ is a normal vector to the plane with its magnitude capturing the distance from the ray to the origin; if $\textbf { m } = \textbf { 0 }$ then the ray passes through the origin and is defined by its direction d. This is in contrast to conventional light field parameterizations: Fronto-parallel two-plane or cylindrical parameterizations cannot represent the full 360-degree light field of a scene [36, 53]. Cubical two-plane arrangements [37, 38] are not continuous, complicating the parameterization via a neural implicit representation. In contrast to the two-sphere parameterization [54], Plücker coordinates do not require that scenes are bounded in size and do not require spherical trigonometry.
+
+The parameterization via a neural field enables compact storage of a 4D light field that can be sampled at arbitrary resolutions, while non-neural representations are resolution-limited. Neural fields further allow the analytical computation of derivatives. This enables the efficient computation of sparse depth maps, where prior representations of light fields require finite-differences approximations of the gradient [48–50].
+
+Rendering LFNs. To render an image given an LFN, one computes the Plücker coordinates $\mathbf { r } _ { u , v }$ of the camera rays at each $u , v$ pixel coordinate in the image according to Equation 4. Specifically, given the extrinsic $\mathbf { E } = \left[ \mathbf { R } | \mathbf { t } \right] \bar { \in } S E ( 3 )$ and intrinsic $\mathbf { K } \in \mathbf { \bar { \mathbb { R } } ^ { 3 \times 3 } }$ camera matrices [55] of a camera, one may retrieve the Plücker coordinates of the ray $\mathbf { r } _ { u , v }$ at pixel coordinate $u , v$ as:
+
+$$
+\begin{array} { r } { \mathbf { r } _ { u , v } = ( \mathbf { d } _ { u , v } , \mathbf { t } \times \mathbf { d } _ { u , v } ) / \lVert \mathbf { d } _ { u , v } \rVert , \mathrm { ~ w h e r e ~ } \mathbf { d } _ { u , v } = \mathbf { R } \mathbf { K } ^ { - 1 } \left( \mathbf { \Omega } _ { 1 } ^ { u } \right) + \mathbf { t } , } \end{array}
+$$
+
+where we use the world-to-camera convention for the extrinsic camera parameters. Rendering then amounts to a single evaluation of the LFN $\Phi$ for each ray, $\mathbf { c } _ { u , v } = \Phi ( \mathbf { r } _ { u , v } )$ . For notational convenience, we introduce a rendering function
+
+$$
+\Theta _ { \mathbf { E } , \mathbf { K } } ^ { \Phi } : \mathbb { R } ^ { \ell } \to \mathbb { R } ^ { H \times W \times 3 }
+$$
+
+which renders an LFN $\Phi _ { \phi }$ with parameters $\phi \in \mathbb { R } ^ { \ell }$ when viewed from a camera with extrinsic and intrinsic parameters $( \mathbf { E } , \mathbf { K } )$ into an image.
+
+![](images/73c7c61826461a6765bc0204fe8bf7adbe552e4de5e489c38d2723128c1da544.jpg)  
+Figure 2: Given a 3D scene (left) and a light ray $\mathbf { r }$ (blue), we can slice the scene along a 2D plane containing the ray (light blue), yielding a 2D scene (center). The light field of all rays in a 2D plane, the Epipolar Plane Image (EPI) $\mathbf { c } ( s , t )$ (right). can be analytically computed from our 360-degree LFN. The family of rays $L _ { \mathbf { p } }$ (green) going through a point $\mathbf { p }$ on an object in the scene defines a straight line in the EPI. See below for further discussion of EPI geometry.
+
+# 4.2 The geometry of Light Field Networks
+
+We will now analyze the properties of LFNs representing Lambertian 3D scenes, and illustrate how the geometry of the underlying 3D scene is encoded. We will first derive an expression that establishes a relationship between LFNs and the classic two-plane parameterization of the light field. Subsequently, we will derive an expression for the depth of a ray in terms of the local color gradient of the light field, therefore allowing us to efficiently extract sparse depth maps from the light field at any camera pose via analytical differentiation of the neural implicit representation. Please see Figure 2 for an overview.
+
+Locally linear slices of the light field. We derive here a local parametrization that will allow us to work with an LFN as if it were a conventional 2-plane light field. Given a ray r in Plücker coordinates, we pick two points $\mathbf { x } , \mathbf { x } ^ { \prime } \in \mathbb { R } ^ { 3 }$ along this ray. We then find a normalized direction $ { \mathbf { d } } \in \mathbb { S } ^ { 2 }$ not parallel to the ray direction - a canonical choice is a direction orthogonal to the ray direction. We may now parameterize two parallel lines $\mathbf { a } ( s ) = \mathbf { x } + s \mathbf { d }$ and $\mathbf b ( t ) = \mathbf x ^ { \prime } + t \mathbf d$ that give rise to a local two-plane basis of the light field with ray coordinates $s$ and $t$ . r intersects these lines at the two-plane coordinates $( s , t ) = ( 0 , \bar { 0 } )$ . This choice of local basis now assigns the two-plane coordinates $( s , t )$ to the ray $\mathbf { r }$ from $\mathbf { a } ( s )$ to ${ \bf b } ( t )$ . In Figure 2, we illustrate this process on a simple 2D scene.
+
+Epipolar Plane Images and their geometry. The Plücker coordinates (see Eq. 4) enable us to extract a 2D slice from an LFN field by varying $( s , t )$ and sampling $\Phi$ on the Plücker coordinates of the rays parametrized pairs of points on the lines $\mathbf { a } ( s )$ and ${ \bf b } ( t )$ :
+
+$$
+\mathbf { c } ( s , t ) = \Phi \left( \mathbf { r } ( s , t ) \right) { \mathrm { , w h e r e ~ } } \mathbf { r } ( s , t ) = { \overline { { \mathbf { a } ( s ) \mathbf { b } ( t ) } } } = \left( { \frac { \mathbf { b } ( t ) - \mathbf { a } ( s ) } { \| \mathbf { b } ( t ) - \mathbf { a } ( s ) \| } } , { \frac { \mathbf { a } ( s ) \times \mathbf { b } ( t ) } { \| \mathbf { b } ( t ) - \mathbf { a } ( s ) \| } } \right) .
+$$
+
+The image of this 2D slice $\mathbf { c } ( s , t )$ is well-known in the light field literature as an Epipolar Plane Image (EPI) [47]. EPIs carry rich information about the geometry of the underlying 3D scene. For example, consider a point $\mathbf { p }$ on the surface of an object in the scene; please see Figure 2 for a diagram. A point $ { \mathbf { p } } \in \mathbb { R } ^ { 2 }$ has a 1-dimensional family of rays going through the point, which correspond to a (green) line $L _ { \mathbf { p } }$ in the EPI. In a Lambertian scene, all rays that meet in this point and that are not occluded by other objects must observe the same color. Therefore, the light field is constant along this line. As one travels along $L _ { \mathbf { p } }$ , rotating through the family of rays through p, one eventually reaches a (magenta) tangent ray $\tau$ to the object. At a tangent ray, the value of the EPI ceases to be constant, and the light field changes its color to whatever is disoccluded by the object at this tangent ray. Because objects of different depth undergo differing amounts of parallax,
+
+the slope of the segment of $L _ { \mathbf { p } }$ along which c is constant determines the 3D coordinates of $\mathbf { p }$ . Finally, by observing that we may extract EPIs from any perspective, it is clear that an LFN encodes the full 3D geometry of the underlying scene. Intuitively, this may also be seen by con
+
+![](images/922664117c7125aaf03163853ddc50ab3cffea5b53c7f11f9bbbd0dc4bd02722.jpg)
+
+sidering that one could render out all possible perspectives of the underlying scene, and solve a classic multi-view stereo problem to retrieve the shape.
+
+Extracting depth maps from LFNs. A correctly inferred light field necessarily contains accurate 3D geometry information, although the geometry is encoded in a nontrivial way. To extract 3D geometry from an LFN, we utilize the property of the 2-plane parameterization that the light field is constant on segments $L _ { \mathbf { p } }$ , the slopes of which determine $\mathbf { p }$ . In the supplemental material, we derive
+
+Proposition 1. For a Lambertian scene, the distance $d$ along $\mathbf { r } = { \overrightarrow { \mathbf { a } ( s ) \mathbf { b } ( t ) } }$ from $\mathbf { a } ( s )$ to the point $\mathbf { p }$ on the object is
+
+$$
+d ( \mathbf { r } ) = D \frac { \partial _ { t } \mathbf { c } ( s , t ) } { \partial _ { s } \mathbf { c } ( s , t ) + \partial _ { t } \mathbf { c } ( s , t ) } .
+$$
+
+where $\mathbf { a } ( s )$ and ${ \bf b } ( t )$ are as above, $\mathbf { c } ( s , t )$ is defined by (7), $D$ is the distance between the lines ${ \bf a } ( t )$ and ${ \bf b } ( t )$ . Thus $\begin{array} { r } { \mathbf { p } = \mathbf { a } ( s ) + d ( \mathbf { r } ) \frac { \mathbf { b } ( t ) - \mathbf { a } ( s ) } { \| \mathbf { b } ( t ) - \mathbf { a } ( s ) \| } } \end{array}$ ) b(t)−a(s)kb(t)−a(s)k , and ∂x denotes the partial derivative by variable x.
+
+This result yields meaningful depth estimates wherever the derivatives of the light fields are nonzero along the ray. In practice, we sample several rays in a small $( s , t )$ neighborhood of the ray $\mathbf { r }$ and declare depth estimates as invalid if the gradients have high variance-please see the code for implementation details. This occurs when $\mathbf { r }$ hits the object at a point where the surface color is changing, or when $\mathbf { r }$ is a tangent ray. We note that there is a wealth of prior art that could be used to extend this approach to extract dense depth maps [48–51].
+
+# 4.3 Meta-learning with conditional Light Field Networks
+
+We consider a dataset $\mathcal { D }$ consisting of $N$ 3D scenes
+
+$$
+S _ { i } = \{ ( \mathbf { I } _ { j } , \mathbf { E } _ { j } , \mathbf { K } _ { j } ) \} _ { j = 1 } ^ { K } \in \mathbb { R } ^ { H \times W \times 3 } \times S E ( 3 ) \times \mathbb { R } ^ { 3 \times 3 } , i = 1 \dots N
+$$
+
+with $K$ images $\mathbf { I } _ { j }$ of each scene taken with cameras with extrinsic parameters $\mathbf { E } _ { j }$ and intrinsic parameters $\mathbf { K } _ { j }$ [55]. Each scene is completely described by the parameters $\phi _ { i } \in \mathbb { R } ^ { \ell }$ of its corresponding light field MLP $\Phi _ { i } = \Phi _ { \phi _ { i } }$ .
+
+Meta-learning and multi-view consistency. In the case of 3D-structured neural scene representations, ray-marching or volumetric rendering naturally ensure multi-view consistency of the reconstructed 3D scene representation. In contrast, a general 4D function $\Phi : \mathcal { L }  \mathbb { R } ^ { 3 }$ is not multi-view consistent, as most such functions are not the light fields of any 3D scene. We propose to overcome this challenge by learning a prior over the space of light fields. As we will demonstrate, this prior can also be used to reconstruct an LFN from a single 2D image observation. In this paradigm, differentiable ray-casting is a method to force the light field of a scene to be multi-view consistent, while we instead impose multi-view consistency by learning a prior over light fields.
+
+Meta-learning framework. We propose to represent each 3D scene $S _ { i }$ by its own latent vector $\mathbf { z } _ { i } \in \mathbb { R } ^ { k }$ . Generalizing to new scenes amounts to learning a prior over the space of light fields that is concentrated on the manifold of multi-view consistent light fields of natural scenes. To represent this latent manifold, we utilize a hypernetwork [56, 3]. The hypernetwork is a function, represented as an MLP
+
+$$
+\Psi : \mathbb { R } ^ { k } \to \mathbb { R } ^ { \ell } , \Psi _ { \psi } ( \mathbf { z } _ { i } ) = \phi _ { i }
+$$
+
+with parameters $\psi$ which sends the latent code $\mathbf { z } _ { i }$ of the $i$ -th scene to the parameters of the corresponding LFN.
+
+Several reasonable approaches exist to obtain latent codes $\mathbf { z } _ { i }$ . One may leverage a convolutionalor transformer-based image encoder, directly inferring the latent from an image [11, 5], or utilize gradient-based meta-learning [23]. Here, we follow an auto-decoder framework [1, 3] to find the latent codes $\mathbf { z } _ { i }$ , but note that LFNs are in no way constrained to this approach. We do not claim that this particular meta-learning method will out-perform other forms of conditioning, such as gradient-based meta-learning [57, 23] or FILM conditioning [58], but perform a comparison to a conditioning-by-concatenation approach in the appendix. We assume that the latent vectors have a Gaussian prior with zero mean and a diagonal covariance matrix. At training time, we jointly optimize the latent parameters $\mathbf { z } _ { i }$ together with the hypernetwork parameters $\psi$ using the objective
+
+![](images/22115e545d7ac56d292ba67c10b6574f621b5aef47d4b2aa2cb55dc839511f3d.jpg)  
+Figure 3: 360-degree light field parameterization. Top left: 3D slice in the style of the Lumigraph [37] of an LFN of a room-scale scene. Bottom left: nearby views of a car as well as vertical (right, red) and horizontal (top, green) Epipolar Plane Images, sampled from an LFN. Reconstructed from training set, 50 and 15 views, respectively. Right: LFNs enable rendering from arbitrary, 360-degree camera perspectives as well as sparse depth map extraction from only a single sample per ray. Please see the supplemental video for more qualitative results.
+
+$$
+\underset { \{ { \bf { z } } _ { i } \} , \psi } { \arg \operatorname* { m i n } } \sum _ { i } \sum _ { j } \| \Theta _ { { \bf { E } } _ { j } , { \bf { K } } _ { j } } ^ { \Phi } ( \Psi _ { \psi } ( { \bf { z } } _ { i } ) ) - { \bf { I } } _ { j } \| _ { 2 } ^ { 2 } + \lambda _ { l a t } \| { \bf { z } } _ { i } \| _ { 2 } ^ { 2 } .
+$$
+
+Here the $\Theta ^ { \Phi }$ is the rendering function (Equation 6), the first term is an $\ell _ { 2 }$ loss penalizing the light fields that disagree with the observed images, and the second term enforces the prior over the latent variables. We solve Equation 11 using gradient descent. At test time, we freeze the parameters of the hypernetwork and reconstruct the light field for a new scene $S$ given a single observation of the scene $\mathbf { \bar { \{ ( I , E , K ) \} } }$ by optimizing, using gradient descent, the latent variable $\mathbf { z } _ { S }$ of the scene, such that the reconstructed light field $\Phi _ { \Psi _ { \psi } ( { \bf z } _ { S } ) }$ best matches the given observation of the scene:
+
+$$
+\mathbf { z } _ { S } = \underset { \mathbf { z } } { \arg \operatorname* { m i n } } \ \lVert \boldsymbol { \Theta } _ { \mathbf { E } , \mathbf { K } } ^ { \Phi } ( \boldsymbol { \Psi } _ { \psi } ( \mathbf { z } ) ) - \mathbf { I } ) \rVert _ { 2 } ^ { 2 } + \lambda _ { l a t } \lVert \mathbf { z } \rVert _ { 2 } ^ { 2 } .
+$$
+
+Global vs. local conditioning The proposed meta-learning framework globally conditions an LFN on a single latent variable $\mathbf { z }$ . Recent work instead leverages local conditioning, where a neural field is conditioned on local features extracted from a context image [26, 6, 27]. In particular, the recently proposed pixelNeRF [6] has achieved impressive results on few-shot novel view synthesis. As we will see, the current formulation of LFNs does not outperform pixelNeRF. We note, however, that local conditioning methods solve a different problem. Rather than learning a prior over classes of objects, local conditioning methods learn priors over patches, answering the question “How does this image patch look like from a different perspective?”. As a result, this approach does not learn a latent space of neural scene representations. Rather, scene context is required to be available at test time to reason about the underlying 3D scene, and the representation is not compact: the size of the conditioning grows with the number of context observations. In contrast, globally conditioned methods [3, 11, 1, 2] first infer a global representation that is invariant to the number of context views and subsequently discard the observations. However, local conditioning enables better generalization due to the shift-equivariance of convolutional neural networks. An equivalent to local conditioning in light fields is non-obvious, and an exciting direction for future work.
+
+![](images/59f49446de3ce480d695474c650bd5267d9e830d8755e6fbd85c5a6cf1c615a1.jpg)  
+Figure 4: Category-agnostic single-shot reconstruction. We train a single model on the 13 largest Shapenet classes. LFNs consistently outperform global conditioning baselines. Baseline results courtesy of the pixelNeRF [6] authors. Please see the supplemental video for more qualitative results.
+
+Table 1: Single-shot multi-class reconstruction results. We benchmark LFNs with SRNs [3] and DVR [5] on the task of single-shot (auto-decoding with a single view), multi-class reconstruction of the 13 largest ShapeNet [59] classes. LFNs significantly outperform DVR and SRNs on almost all classes, on average by more than 1dB, while only requiring a single network evaluation per ray. Note that DVR requires additional supervision in the form of foreground-background masks. Means across classes are weighted equally.
+
+<table><tr><td></td><td></td><td>plane</td><td>bench</td><td>cbnt.</td><td>car</td><td>chair</td><td>disp.</td><td>lamp</td><td>spkr.</td><td>rifle</td><td>sofa</td><td>table</td><td>phone</td><td>boat</td><td>mean</td></tr><tr><td rowspan="3">↑PSNR</td><td>DVR [5]</td><td>25.29</td><td>22.64</td><td>24.47</td><td>23.95</td><td>19.91</td><td>20.86</td><td>23.27</td><td>20.78</td><td>23.44</td><td>23.35</td><td>21.53</td><td>24.18</td><td>25.09</td><td>22.70</td></tr><tr><td>SRN[3]</td><td>26.62</td><td>22.20</td><td>23.42</td><td>24.40</td><td>21.85</td><td>19.07</td><td>22.17</td><td>21.04</td><td>24.95</td><td>23.65</td><td>22.45</td><td>20.87</td><td>25.86</td><td>23.28</td></tr><tr><td>LFN</td><td>29.95</td><td>23.21</td><td>25.91</td><td>28.04</td><td>22.94</td><td>20.64</td><td>24.56</td><td>22.54</td><td>27.50</td><td>25.15</td><td>24.58</td><td>22.21</td><td>27.16</td><td>24.95</td></tr><tr><td rowspan="3">↑ SSIM</td><td>DVR [5]</td><td>0.905</td><td>0.866</td><td>0.877</td><td>0.909</td><td>0.787</td><td>0.814</td><td>0.849</td><td>0.798</td><td>0.916</td><td>0.868</td><td>0.840</td><td>0.892</td><td>0.902</td><td>0.860</td></tr><tr><td>SRN[3]</td><td>0.901</td><td>0.837</td><td>0.831</td><td>0.897</td><td>0.814</td><td>0.744</td><td>0.801</td><td>0.779</td><td>0.913</td><td>0.851</td><td>0.828</td><td>0.811</td><td>0.898</td><td>0.849</td></tr><tr><td>LFN</td><td>0.932</td><td>0.855</td><td>0.871</td><td>0.943</td><td>0.835</td><td>0.786</td><td>0.844</td><td>0.808</td><td>0.939</td><td>0.874</td><td>0.868</td><td>0.844</td><td>0.907</td><td>0.870</td></tr></table>
+
+# 5 Experiments
+
+We demonstrate the efficacy of LFNs by reconstructing 360-degree light fields of a variety of simple 3D scenes. In all experiments, we parameterize LFNs via a 6-layer ReLU MLP, and the hypernetwork as a 3-layer ReLU MLP, both with layer normalization. We solve all optimization problems using the ADAM solver with a step size of $1 0 ^ { - 4 }$ . Please find more results, as well as precise hyperparameter, implementation, and dataset details, in the supplemental document and video.
+
+Reconstructing appearance and geometry of single-object and room-scale light fields. We demonstrate that LFN can parameterize 360-degree light fields of both single-object ShapeNet [59] objects and simple, room-scale environments. We train LFNs on the ShapeNet “cars” dataset with 50 observations per object from [3], as well as on simple room-scale environments as proposed in [13]. Subsequently, we evaluate the ability of LFNs to generate novel views of the underlying 3D scenes. Please see Figure 3 for qualitative results. LFNs succeed in parameterizing the 360-degree light field, enabling novel view synthesis at real-time frame-rates (see supplemental video). We further demonstrate that LFNs encode scene geometry by presenting Epipolar Plane Images and leveraging the relationship derived in Equation 8 to infer sparse depth maps. We highlight that both rendering and depth map extraction do not require ray-casting, with only a single evaluation of the network or the network and its gradient respectively.
+
+Multi-class single-view reconstruction. Following [5, 6], we benchmark LFNs with recent global conditioning methods on the task of single-view reconstruction and novel view synthesis of the 13 largest ShapeNet categories. We follow the same evaluation protocol as [60] and train a single model across all categories. See Figure 4 for qualitative and Table 1 for quantitative baseline comparisons. We significantly outperform both Differentiable Volumetric Rendering (DVR) [5] and Scene Representation Networks (SRNs) [3] on all but two classes by an average of 1dB, while requiring more than an order of magnitude fewer network evaluations per ray. Qualitatively, we find that the reconstructions from LFNs are often crisper than those of either Scene Representation Networks or DVR. Note that DVR requires additional ground-truth foreground-background segmentation masks.
+
+Class-specific single-view reconstruction. We benchmark LFNs on single-shot reconstruction on the Shapenet “cars” and “chairs” classes as proposed in SRNs [3]. See Figure 5 for qualitative and quantitative results. We report performance better than SRNs in PSRN and on par in terms of SSIM on the “cars” class, and worse in PSNR but better in terms of SSIM on the “chairs” class, while requiring an order of magnitude fewer network evaluations and rendering in real-time. We attribute the drop in performance compared to multi-class reconstruction to the smaller dataset size, causing multi-view inconsistency.
+
+![](images/fe52aa157497d0214fab15373ed7a9762e7b4da6397b9cc0cca6fc7ef6bb492d.jpg)  
+Figure 5: Class-specific single-shot reconstruction. LFN performs approximately on par with SRNs [3] in the single-class single-shot reconstruction case, while requiring an order of magnitude fewer network evaluations, memory, and rendering time. Quantitative results report (PSNR, SSIM).
+
+<table><tr><td></td><td>Chairs</td><td>Cars</td></tr><tr><td>SRNs [3]</td><td>22.89 /0.89</td><td>22.25 /0.89</td></tr><tr><td>LFN</td><td>22.26 / 0.90</td><td>22.42/0.89</td></tr></table>
+
+<table><tr><td></td><td>Class-specific</td><td>Multi-Class</td></tr><tr><td>LFN</td><td>22.34 /0.90</td><td>24.95 /0.87</td></tr><tr><td>pixelNeRF</td><td>23.45 /0.91</td><td>26.80/0.91</td></tr></table>
+
+![](images/02021fee3ced9ce221bb477ebf540075483c411f89cf83da1fdae1b980d0455d.jpg)  
+Figure 6: Global vs. local conditioning. The locally conditioned pixelNeRF outperforms LFNs in single-shot reconstruction, though LFNs require three orders of magnitude less rendering time and memory. Qualitatively, for many objects LFNs are on par with pixelNERF (left), but confuse the object class on others (right). Quantitative results report (PSNR, SSIM). ‘Class-specific’ refers to average over cars and chairs as in Fig. 5 while ’multi-class’ refers to the average over all ShapeNet classes as in Fig. 1.
+
+Global vs. local conditioning and comparison to pixelNeRF [6]. We investigate the role of global conditioning, where a single latent is inferred to describe the whole scene [3], to local conditioning, where latents are inferred per-pixel in a 2D image and leveraged to locally condition a neural implicit representation [26, 27, 6]. We benchmark with the recently proposed pixelNeRF [6]. As noted above (see Section 4.3), local conditioning does not infer a compact neural scene representation of the scene. Nevertheless, we provide the comparison here for completeness. See Figure 6 for qualitative and quantitative results. On average, LFNs perform 1dB worse than pixelNeRF in the single-class case, and 2dB worse in the multi-class setting.
+
+Real-time rendering and storage cost. See Table 2 for a quantitative comparison of the rendering complexity of LFN compared with that of volumetric and ray-marching based neural renderers [3, 45, 19, 4, 6]. All clock times were collected for rendering $2 5 6 \times 2 5 6$ images on an NVIDIA RTX 6000 GPU. We further compare the cost of storing a single LFN with the cost of storing a conventional light field. With approximately $4 0 0 \mathrm { k }$ parameters, a single LFN requires around $1 . 6 \mathrm { M B }$ of storage, compared to $1 4 6 \mathrm { M B }$ required for storing a 360-degree light field at a resolution of $2 5 6 \times 2 5 6 \times 1 7 \times 1 7$ in the six-plane Lumigraph configuration.
+
+Multi-view consistency as a function of training set size. We investigate how multi-view consistency scales with the amount of data that the prior is trained on. Please find this analysis in the supplementary material.
+
+Table 2: Comparison of rendering complexity. LFNs require three orders of magnitude less compute than volumetric rendering based approaches, and admit real-time rendering. Please see Table of supplemental material for comparison on larger images based on data in []   
+
+<table><tr><td></td><td>LFNs</td><td>SRNs [3]</td><td>pixelNeRF [6]</td></tr><tr><td># evaluations per ray</td><td>1</td><td>11</td><td>192</td></tr><tr><td>clock time for 256 × 256 image (ms)</td><td>2.1</td><td>120</td><td>30e3</td></tr></table>
+
+<table><tr><td>Method</td><td>Cars</td><td>Chairs</td></tr><tr><td>SRNs</td><td>0.071</td><td>0.20</td></tr><tr><td>LFN</td><td>0.059</td><td>0.130</td></tr></table>
+
+![](images/530da26ccc2b5956552abe83e4bc801dceb799c43163dc51935a7c926ce33f4a.jpg)  
+Figure 7: Geometry reconstruction with LFNs. By backprojecting extracted depth into 3D, LFNs enable reconstruction of 3D pointclouds (left). For rays were depth is valid, LFNs achieve lower mean L1 depth error than Scene Representation Networks (right).
+
+Overfitting of single 3D scenes. We investigate overfitting a single 3D scene with a Light Field Network with positional encodings / sinusoidal activations [24, 61]. Please find this analysis in the supplementary material.
+
+Evaluation of Reconstructed Geometry. We investigate the quality of the geometry that can be computed from an LFN via Eq. 8. For every sample in the class-specific single-shot reconstruction experiment, we extract its per-view sparse depth map. We then backproject depth maps from four views into 3D to reconstruct a point cloud, and benchmark mean L1 error on valid depth estimates with Scene Representation Networks [3]. Fig. 7 displays qualitative and quantitative results. Qualitatively, point clouds succeed in capturing fine detail such as the armrests of chairs. Quantitatively, LFNs outperform SRNs on both cars and chairs. We note that LFNs have a slight advantage in this comparison, as we can only benchmark on the sparse depth values, for which LFNs have high confidence. This includes occlusion boundaries, which are areas where the sphere-tracing based SRNs incurs high error, as it is forced to take smaller and smaller steps and may not reach the surface. We highlight that we do not claim that the proposed method is competetive with methods designed for geometry reconstruction in particular, but that we only report this to demonstrate that the proposed method is capable to extract valid depth estimates from an LFN.
+
+![](images/f7c7f6ba77efe36b20df3656c2915d05fb267b3447fd0fada506b8afe052a6cf.jpg)
+
+Limitations. First, as every existing light field approach, LFNs store only one color per oriented ray, which makes rendering views from cameras placed in between occluding objects challenging, even if the information may still be stored in the light field. Second, though we outperform globally-conditioned methods, we currently do not outperform the locally conditioned pixelNeRF. Finally, as opposed to 3D-structured representations, LFNs do not enforce strict multi-view consistency, and may be inconsistent in the case of small datasets.
+
+# 6 Discussion and Conclusion
+
+We have proposed Light Field Networks, a novel neural scene representation that directly parameterizes the full 360-degree, 4D light field of a 3D scene via a neural implicit representation. This enables both real-time neural rendering with a single evaluation of the neural scene representation per ray, as well as sparse depth map extraction without ray-casting. Light Field Networks outperform globally conditioned baselines in single-shot novel view synthesis, while being three orders of magnitude faster and less memory-intensive than current volumetric rendering approaches. Exciting avenues for future work include combining LFNs with local conditioning, which would enable stronger out-of-distribution generalization, studying the learning of non-Lambertian scenes, and enabling camera placement in obstructed 3D space. With this work, we make important contributions to the emerging fields of neural rendering and neural scene representations, with exciting applications across computer vision, computer graphics, and robotics.
+
+Societal Impacts. Potential improvements extending our work on few-observation novel view synthesis could enable abuse by decreasing the cost of non-consensual impersonations. We refer the reader to a recent review of neural rendering [22] for an in-depth discussion of this topic.
+
+# Acknowledgements and Disclosure of Funding
+
+This work is supported by the NSF under Cooperative Agreement PHY-2019786 (The NSF AI Institute for Artificial Intelligence and Fundamental Interactions, http://iaifi.org/), ONR under 1015
+
+G TA243/N00014-16-1-2007 (Understanding Scenes and Events through Joint Parsing, Cognitive Reasoning and Lifelong Learning), Mitsubishi under 026455-00001 (Building World Models from some data through analysis by synthesis), DARPA under CW3031624 (Transfer, Augmentation and Automatic Learning with Less Labels), as well as the Singapore DSTA under DST00OECI20300823 (New Representations for Vision). We thank Andrea Tagliasacchi, Tomasz Malisiewicz, Prafull Sharma, Ludwig Schubert, Kevin Smith, Bernhard Egger, Christian Richardt, Manuel Rey Area, and Jürgen and Susanne Sitzmann for interesting discussions and feedback, and Alex Yu for kindly sharing the outputs of pixelNeRF and baselines with us.
+
+# References
+
+[1] Jeong Joon Park, Peter Florence, Julian Straub, Richard Newcombe, and Steven Lovegrove. Deepsdf: Learning continuous signed distance functions for shape representation. In Proc. CVPR, 2019.   
+[2] Lars Mescheder, Michael Oechsle, Michael Niemeyer, Sebastian Nowozin, and Andreas Geiger. Occupancy networks: Learning 3d reconstruction in function space. In Proc. CVPR, 2019.   
+[3] Vincent Sitzmann, Michael Zollhöfer, and Gordon Wetzstein. Scene representation networks: Continuous 3d-structure-aware neural scene representations. In Proc. NeurIPS 2019, 2019.   
+[4] Ben Mildenhall, Pratul P Srinivasan, Matthew Tancik, Jonathan T Barron, Ravi Ramamoorthi, and Ren Ng. Nerf: Representing scenes as neural radiance fields for view synthesis. In Proc. ECCV, 2020.   
+[5] Michael Niemeyer, Lars Mescheder, Michael Oechsle, and Andreas Geiger. Differentiable volumetric rendering: Learning implicit 3d representations without 3d supervision. In Proc. CVPR, 2020.   
+[6] Alex Yu, Vickie Ye, Matthew Tancik, and Angjoo Kanazawa. pixelnerf: Neural radiance fields from one or few images. Proc. CVPR, 2020.   
+[7] Ben Mildenhall, Pratul P Srinivasan, Rodrigo Ortiz-Cayon, Nima Khademi Kalantari, Ravi Ramamoorthi, Ren Ng, and Abhishek Kar. Local light field fusion: Practical view synthesis with prescriptive sampling guidelines. ACM Transactions on Graphics (TOG), 38(4):1–14, 2019.   
+[8] Shuaifeng Zhi, Tristan Laidlow, Stefan Leutenegger, and Andrew J Davison. In-place scene labelling and understanding with implicit scene representation. arXiv preprint arXiv:2103.15875, 2021.   
+[9] A. Kohli, V. Sitzmann, and G. Wetzstein. Semantic Implicit Neural Scene Representations with Semisupervised Training. In Proc. 3DV, 2020.   
+[10] Edgar Sucar, Shikun Liu, Joseph Ortiz, and Andrew J Davison. imap: Implicit mapping and positioning in real-time. arXiv preprint arXiv:2103.12352, 2021.   
+[11] Adam R Kosiorek, Heiko Strathmann, Daniel Zoran, Pol Moreno, Rosalia Schneider, Sona Mokrá, ˇ and Danilo J Rezende. Nerf-vae: A geometry aware 3d scene generative model. arXiv preprint arXiv:2104.00587, 2021.   
+[12] Daniel E Worrall, Stephan J Garbin, Daniyar Turmukhambetov, and Gabriel J Brostow. Interpretable transformations with encoder-decoder networks. In Proc. ICCV, volume 4, 2017.   
+[13] SM Ali Eslami, Danilo Jimenez Rezende, Frederic Besse, Fabio Viola, Ari S Morcos, Marta Garnelo, Avraham Ruderman, Andrei A Rusu, Ivo Danihelka, Karol Gregor, et al. Neural scene representation and rendering. Science, 360(6394):1204–1210, 2018.   
+[14] Vincent Sitzmann, Justus Thies, Felix Heide, Matthias Nießner, Gordon Wetzstein, and Michael Zollhöfer. Deepvoxels: Learning persistent 3d feature embeddings. In Proc. CVPR, 2019.   
+[15] Hsiao-Yu Fish Tung, Ricson Cheng, and Katerina Fragkiadaki. Learning spatial common sense with geometry-aware recurrent networks. Proc. CVPR, 2019.   
+[16] Thu H Nguyen-Phuoc, Chuan Li, Stephen Balaban, and Yongliang Yang. Rendernet: A deep convolutional network for differentiable rendering from 3d shapes. In Proc. NIPS. 2018.   
+[17] Jun-Yan Zhu, Zhoutong Zhang, Chengkai Zhang, Jiajun Wu, Antonio Torralba, Josh Tenenbaum, and Bill Freeman. Visual object networks: image generation with disentangled 3d representations. In Proc. NIPS, pages 118–129, 2018.   
+[18] Thu Nguyen-Phuoc, Chuan Li, Lucas Theis, Christian Richardt, and Yong-Liang Yang. Hologan: Unsupervised learning of 3d representations from natural images. In Proc. ICCV, 2019.   
+[19] Stephen Lombardi, Tomas Simon, Jason Saragih, Gabriel Schwartz, Andreas Lehrmann, and Yaser Sheikh. Neural volumes: Learning dynamic renderable volumes from images. arXiv preprint arXiv:1906.07751, 2019.   
+[20] Danilo Jimenez Rezende, S. M. Ali Eslami, Shakir Mohamed, Peter Battaglia, Max Jaderberg, and Nicolas Heess. Unsupervised learning of 3d structure from images. In Proc. NIPS. 2016.   
+[21] Yiheng Xie, Towaki Takikawa, Shunsuke Saito, Or Litany, Shiqin Yan, Numair Khan, Federico Tombari, James Tompkin, Vincent Sitzmann, and Srinath Sridhar. Neural fields in visual computing and beyond. In arXiv, 2021.   
+[22] Ayush Tewari, Ohad Fried, Justus Thies, Vincent Sitzmann, Stephen Lombardi, Kalyan Sunkavalli, Ricardo Martin-Brualla, Tomas Simon, Jason Saragih, Matthias Nießner, et al. State of the art on neural rendering. In Computer Graphics Forum, volume 39, pages 701–727. Wiley Online Library, 2020.   
+[23] Vincent Sitzmann, Eric R Chan, Richard Tucker, Noah Snavely, and Gordon Wetzstein. Metasdf: Metalearning signed distance functions. Proc. NeurIPS, 2020.   
+[24] Vincent Sitzmann, Julien N.P. Martel, Alexander W. Bergman, David B. Lindell, and Gordon Wetzstein. Implicit neural representations with periodic activation functions. In Proc. NeurIPS, 2020.   
+[25] Konstantinos Rematas, Ricardo Martin-Brualla, and Vittorio Ferrari. Sharf: Shape-conditioned radiance fields from a single view. In Proc. ICML, 2021.   
+[26] Shunsuke Saito, Zeng Huang, Ryota Natsume, Shigeo Morishima, Angjoo Kanazawa, and Hao Li. Pifu: Pixel-aligned implicit function for high-resolution clothed human digitization. In Proc. ICCV, pages 2304–2314, 2019.   
+[27] Alex Trevithick and Bo Yang. Grf: Learning a general radiance field for 3d scene representation and rendering. arXiv preprint arXiv:2010.04595, 2020.   
+[28] Christian Reiser, Songyou Peng, Yiyi Liao, and Andreas Geiger. Kilonerf: Speeding up neural radiance fields with thousands of tiny mlps. arXiv preprint arXiv:2103.13744, 2021.   
+[29] Alex Yu, Ruilong Li, Matthew Tancik, Hao Li, Ren Ng, and Angjoo Kanazawa. Plenoctrees for real-time rendering of neural radiance fields. arXiv preprint arXiv:2103.14024, 2021.   
+[30] Lingjie Liu, Jiatao Gu, Kyaw Zaw Lin, Tat-Seng Chua, and Christian Theobalt. Neural sparse voxel fields. Proc. NeurIPS, 2020.   
+[31] David B Lindell, Julien NP Martel, and Gordon Wetzstein. Autoint: Automatic integration for fast neural volume rendering. Proc. CVPR, 2020.   
+[32] Thomas Neff, Pascal Stadlbauer, Mathias Parger, Andreas Kurz, Chakravarty R Alla Chaitanya, Anton Kaplanyan, and Markus Steinberger. Donerf: Towards real-time rendering of neural radiance fields using depth oracle networks. arXiv e-prints, pages arXiv–2103, 2021.   
+[33] Petr Kellnhofer, Lars Jebe, Andrew Jones, Ryan Spicer, Kari Pulli, and Gordon Wetzstein. Neural lumigraph rendering. Proc. CVPR, 2021.   
+[34] Edward H Adelson, James R Bergen, et al. The plenoptic function and the elements of early vision, volume 2. Vision and Modeling Group, Media Laboratory, Massachusetts Institute of Technology, 1991.   
+[35] Edward H Adelson and John YA Wang. Single lens stereo with a plenoptic camera. IEEE transactions on pattern analysis and machine intelligence, 14(2):99–106, 1992.   
+[36] Marc Levoy and Pat Hanrahan. Light field rendering. In Proc. SIGGRAPH, 1996.   
+[37] Steven J Gortler, Radek Grzeszczuk, Richard Szeliski, and Michael F Cohen. The lumigraph. In Proc. SIGGRAPH, 1996.   
+[38] Chris Buehler, Michael Bosse, Leonard McMillan, Steven Gortler, and Michael Cohen. Unstructured lumigraph rendering. In Proceedings of the 28th annual conference on Computer graphics and interactive techniques, pages 425–432, 2001.   
+[39] Ren Ng et al. Digital light field photography, volume 7. stanford university Stanford, 2006.   
+[40] Suren Vagharshakyan, Robert Bregovic, and Atanas Gotchev. Light field reconstruction using shearlet transform. Proc. PAMI, 40(1):133–147, 2017.   
+[41] Lixin Shi, Haitham Hassanieh, Abe Davis, Dina Katabi, and Fredo Durand. Light field reconstruction using sparsity in the continuous fourier domain. ACM Transactions on Graphics (TOG), 34(1):1–13, 2014.   
+[42] Anat Levin and Fredo Durand. Linear view synthesis using a dimensionality gap light field prior. In Proc. CVPR, pages 1831–1838. IEEE, 2010.   
+[43] Nima Khademi Kalantari, Ting-Chun Wang, and Ravi Ramamoorthi. Learning-based view synthesis for light field cameras. ACM Trans. Graph. (SIGGRAPH Asia), 35(6):193, 2016.   
+[44] Mojtaba Bemana, Karol Myszkowski, Hans-Peter Seidel, and Tobias Ritschel. X-fields: Implicit neural view-, light- and time-image interpolation. Proc. SIGGRAPH Asia 2020, 39(6), 2020.   
+[45] Lior Yariv, Yoni Kasten, Dror Moran, Meirav Galun, Matan Atzmon, Basri Ronen, and Yaron Lipman. Multiview neural surface reconstruction by disentangling geometry and appearance. Proc. NeurIPS, 2020.   
+[46] Qiangeng Xu, Weiyue Wang, Duygu Ceylan, Radomír Mech, and Ulrich Neumann. DISN: deep implicit surface network for high-quality single-view 3d reconstruction. In Proc. NIPS, 2019.   
+[47] Robert C Bolles, H Harlyn Baker, and David H Marimont. Epipolar-plane image analysis: An approach to determining structure from motion. Proc. IJCV, 1(1):7–55, 1987.   
+[48] Don Dansereau and Len Bruton. Gradient-based depth estimation from 4d light fields. In Proc. IEEE International Symposium on Circuits and Systems, volume 3, pages III–549. IEEE, 2004.   
+[49] Ivana Tosic and Kathrin Berkner. Light field scale-depth space transform for dense depth estimation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition Workshops, pages 435–442, 2014.   
+[50] Changil Kim, Henning Zimmer, Yael Pritch, Alexander Sorkine-Hornung, and Markus H Gross. Scene reconstruction from high spatio-angular resolution light fields. ACM Transactions on Graphics (TOG), 32(4):73–1, 2013.   
+[51] Lipeng Si and Qing Wang. Dense depth-map estimation and geometry inference from light fields via global optimization. In Asian Conference on Computer Vision, pages 83–98. Springer, 2016.   
+[52] Yan-Bin Jia. Plücker coordinates for lines in the space. Problem Solver Techniques for Applied Computer Science, Com-S-477/577 Course Handout. Iowa State University, https://faculty.sites.iastate.edu/jia/files/inline-files/plucker-coordinates.pdf, 2020.   
+[53] Bernd Krolla, Maximilian Diebold, Bastian Goldlücke, and Didier Stricker. Spherical light fields. In Proc. BMVC, 2014.   
+[54] Insung Ihm, Sanghoon Park, and Rae Kyoung Lee. Rendering of spherical light fields. In Proceedings The Fifth Pacific Conference on Computer Graphics and Applications, pages 59–68, 1997.   
+[55] Richard Hartley and Andrew Zisserman. Multiple View Geometry in Computer Vision. Cambridge University Press, 2nd edition, 2003.   
+[56] David Ha, Andrew Dai, and Quoc V Le. Hypernetworks. In Proc. ICLR, 2017.   
+[57] Chelsea Finn, Pieter Abbeel, and Sergey Levine. Model-agnostic meta-learning for fast adaptation of deep networks. In Proceedings of the 34th International Conference on Machine Learning - Volume 70, ICML’17, page 1126–1135. JMLR.org, 2017.   
+[58] Ethan Perez, Florian Strub, Harm de Vries, Vincent Dumoulin, and Aaron C. Courville. Film: Visual reasoning with a general conditioning layer. In AAAI, 2018.   
+[59] Angel X Chang, Thomas Funkhouser, Leonidas Guibas, Pat Hanrahan, Qixing Huang, Zimo Li, Silvio Savarese, Manolis Savva, Shuran Song, Hao Su, et al. Shapenet: An information-rich 3d model repository. arXiv preprint arXiv:1512.03012, 2015.   
+[60] Hiroharu Kato, Yoshitaka Ushiku, and Tatsuya Harada. Neural 3d mesh renderer. In Proc. CVPR, pages 3907–3916, 2018.   
+[61] Matthew Tancik, Pratul P Srinivasan, Ben Mildenhall, Sara Fridovich-Keil, Nithin Raghavan, Utkarsh Singhal, Ravi Ramamoorthi, Jonathan T Barron, and Ren Ng. Fourier features let networks learn high frequency functions in low dimensional domains. In Proc. NeurIPS, 2020.

parse/train/q0h6av9Vi8/q0h6av9Vi8_content_list.json

@@ -0,0 +1,1254 @@
+[
+    {
+        "type": "text",
+        "text": "Light Field Networks: Neural Scene Representations with Single-Evaluation Rendering ",
+        "text_level": 1,
+        "bbox": [
+            181,
+            122,
+            818,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Vincent Sitzmann1,∗ sitzmann@mit.edu ",
+        "bbox": [
+            282,
+            226,
+            423,
+            253
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Semon Rezchikov2,∗ skr@math.columbia.edu ",
+        "bbox": [
+            534,
+            224,
+            717,
+            253
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "William T. Freeman1,3 billf@mit.edu ",
+        "bbox": [
+            220,
+            275,
+            377,
+            303
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Joshua B. Tenenbaum1,4,5 jbt@mit.edu ",
+        "bbox": [
+            431,
+            275,
+            607,
+            304
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Frédo Durand1 fredo@mit.edu ",
+        "bbox": [
+            663,
+            275,
+            776,
+            303
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1MIT CSAIL 2Columbia University 3 IAFI 4MIT BCS 5 CBMM vsitzmann.github.io/lfns/ ",
+        "bbox": [
+            253,
+            314,
+            740,
+            344
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            378,
+            535,
+            395
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Inferring representations of 3D scenes from 2D observations is a fundamental problem of computer graphics, computer vision, and artificial intelligence. Emerging 3D-structured neural scene representations are a promising approach to 3D scene understanding. In this work, we propose a novel neural scene representation, Light Field Networks or LFNs, which represent both geometry and appearance of the underlying 3D scene in a 360-degree, four-dimensional light field parameterized via a neural network. Rendering a ray from an LFN requires only a single network evaluation, as opposed to hundreds of evaluations per ray for ray-marching or volumetric based renderers in 3D-structured neural scene representations. In the setting of simple scenes, we leverage meta-learning to learn a prior over LFNs that enables multi-view consistent light field reconstruction from as little as a single image observation. This results in dramatic reductions in time and memory complexity, and enables real-time rendering. The cost of storing a 360-degree light field via an LFN is two orders of magnitude lower than conventional methods such as the Lumigraph. Utilizing the analytical differentiability of neural implicit representations and a novel parameterization of light space, we further demonstrate the extraction of sparse depth maps from LFNs. ",
+        "bbox": [
+            233,
+            409,
+            766,
+            643
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            667,
+            312,
+            685
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A fundamental problem across computer graphics, computer vision, and artificial intelligence is to infer a representation of a scene’s 3D shape and appearance given impoverished observations such as 2D images of the scene. Recent contributions have advanced the state of the art for this problem significantly. First, neural implicit representations have enabled efficient representation of local 3D scene properties by mapping a 3D coordinate to local properties of the 3D scene at that coordinate $[ 1 -$ 6]. Second, differentiable neural renderers allow for the inference of these representations given only 2D image observations [3, 4]. Finally, leveraging meta-learning approaches such as hypernetworks or gradient-based meta-learning has enabled the learning of distributions of 3D scenes, and therefore reconstruction given only a single image observation [3]. This has enabled a number of applications, such as novel view synthesis [7, 3, 6], 3D reconstruction [5, 3] semantic segmentation [8, 9], and SLAM [10]. However, 3D-structured neural scene representations come with a major limitation: Their rendering is prohibitively expensive, on the order of tens of seconds for a single $2 5 6 \\times 2 5 6$ image for state-of-the-art approaches. In particular, parameterizing the scene in 3D space necessitates the discovery of surfaces along camera rays during rendering. This can be solved either by encoding geometry as a level set of an occupancy or signed distance function, or via volumetric rendering, which solves an alpha-compositing problem along each ray. Either approach, however, requires tens or even hundreds of evaluations of the 3D neural scene representation in order to render a single camera ray. ",
+        "bbox": [
+            174,
+            699,
+            826,
+            878
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            92,
+            825,
+            161
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We propose a novel neural scene representation, dubbed Light Field Networks or LFNs. Instead of encoding a scene in 3D space, Light Field Networks encode a scene by directly mapping an oriented camera ray in the four dimensional space of light rays to the radiance observed by that ray. This obviates the need to query opacity and RGB at 3D locations along a ray or to ray-march towards the level set of a signed distance function, speeding up rendering by three orders of magnitude compared to volumetric methods. In addition to directly encoding appearance, we demonstrate that LFNs encode information about scene geometry in their derivatives. Utilizing the unique flexibility of neural field representations, we introduce the use of Plücker coordinates to parameterize 360-degree light fields, which allow for storage of a-priori unbounded scenes and admit a simple expression for the depth as an analytical function of an LFN. Using this relationship, we demonstrate the computation of geometry in the form of sparse depth maps. While 3D-structured neural scene representations are multi-view consistent by design, parameterizing a scene in light space does not come with this guarantee: the additional degree of freedom enables rays that view the same 3D point to change appearance across viewpoints. For the setting of simple scenes, we demonstrate that this challenge can be overcome by learning a prior over 4D light fields in a meta-learning framework. We benchmark with current state-of-the-art approaches for single-shot novel view synthesis, and demonstrate that LFNs compare favorably with globally conditioned 3D-structured representations, while accelerating rendering and reducing memory consumption by orders of magnitude. ",
+        "bbox": [
+            174,
+            166,
+            825,
+            416
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In summary, we make the following contributions: ",
+        "bbox": [
+            174,
+            421,
+            504,
+            436
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1. We propose Light Field Networks (LFNs), a novel neural scene representation that directly parameterizes the light field of a 3D scene via a neural network, enabling real-time rendering and vast reduction in memory utilization.   \n2. We demonstrate that we may leverage 6-dimensional Plücker coordinates as a parameterization of light fields, despite their apparent overparameterization of the 4D space of rays, thereby enabling continuous, 360-degree light fields.   \n3. By embedding LFNs in a meta-learning framework, we demonstrate light field reconstruction and novel view synthesis of simple scenes from sparse 2D image supervision only.   \n4. We demonstrate that inferred LFNs encode both appearance and geometry of the underlying 3D scenes by extracting sparse depth maps from the derivatives of LFNs, leveraging their analytical differentiability. ",
+        "bbox": [
+            210,
+            446,
+            825,
+            613
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Scope. The proposed method is currently constrained to the reconstruction of simple scenes, such as single objects and simple room-scale scenes, in line with recent work on learning generative models in this regime [3, 11]. ",
+        "bbox": [
+            176,
+            626,
+            825,
+            667
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            686,
+            321,
+            704
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Neural Scene Representations and Neural Rendering. A large body of work addresses the question of inferring feature representations of 3D scenes useful to downstream tasks across graphics, vision, and machine learning. Models without 3D structure suffer from poor data efficiency [12, 13]. Voxel grids [14–20] offer 3D structure, but scale poorly with spatial resolution. Inspired by neural implicit representations of 3D geometry [1, 2], recent work has proposed to encode properties of 3D scenes as neural fields (also implicit- or coordinate-based representations, see [21] for an overview), neural networks that map 3D coordinates to local properties of the 3D scene at these coordinates. Using differentiable rendering, these models can be learned from image observations only [3, 4, 22, 11]. Reconstruction from sparse observations can be achieved by learning priors over the space of neural fields [3, 5, 11, 23–25] or by conditioning of the neural field on local features [6, 26, 27]. Differentiable rendering of such 3D-structured neural scene representations is exceptionally computationally intensive, requiring hundreds of evaluations of the neural representation per ray, with tens of thousands to millions of rays per image. Some recent work seeks to accelerate test-time rendering, but either does not admit generalization [28–30], or does not alleviate the cost of rendering at training/inference time [31–33]. With Light Field Networks, we propose to leverage 360- degree light fields as neural scene representations. We introduce a novel neural field parameterization of 360-degree light fields, infer light fields via meta-learning from as few as a single 2D image observation, and demonstrate that LFNs encode both scene geometry and appearance. ",
+        "bbox": [
+            173,
+            718,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/f984b102b6a5cea20d418143230c2e728adb213ce51b7f5ce7db780b4765d219.jpg",
+        "image_caption": [
+            "Figure 1: Overview. We propose Light Field Networks or LFNs, which encode the full 360-degree light field of a 3D scene in the weights of a fully connected neural network $\\Phi _ { \\phi }$ (with weights $\\phi$ conditioned on a latent code $\\mathbf { z }$ ) that maps an oriented ray $\\mathbf { r }$ to the radiance c observed by that ray. Rendering an LFN $\\Phi _ { \\phi }$ only requires evaluating the underlying MLP once per ray, in contrast to 3D-structured neural scene representations $\\Phi _ { 3 D }$ such as SRNs [3], NeRF [4], or DVR [5] that require hundreds of evaluations per ray. We leverage meta-learning to learn a multi-view consistent space of LFNs. Once trained, this enables reconstruction of a 360-degree light field and subsequent real-time novel view synthesis of simple scenes from only a single observation. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            92,
+            826,
+            261
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            393,
+            825,
+            449
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Light fields and their reconstruction. Light fields have a rich history as a scene representation in both computer vision and computer graphics. Adelson et al. [34] introduced the 5D plenoptic function as a unified representation of information in the early visual system [35]. Levoy et al. [36] and, concurrently, Gortler et al. [37] introduced light fields in computer graphics as a 4D sampled scene representation for fast image-based rendering. Light fields have since enjoyed popularity as a representation for novel view synthesis [38] and computational photography, e.g. [39]. Light fields enable direct rendering of novel views by simply extracting a 2D slice of the 4D light field. However, they tend to incur significant storage cost, and since they rely on two-plane parameterizations, they make it hard to achieve a full 360-degree representation without concatenating multiple light fields. A significant amount of prior work addresses reconstruction of fronto-parallel light fields via handcrafted priors, such as sparsity in the Fourier or shearlet domains [40–42]. With the advent of deep learning, approaches to light field reconstruction that leverage convolutional neural networks to in-paint or extrapolate light fields from sparse views have been proposed [43, 7, 44], but similarly only support fronto-parallel novel view synthesis. We are instead interested in light fields as a representation of 3D appearance and geometry that enables efficient inference of and reasoning about the properties of the full underlying scene. ",
+        "bbox": [
+            173,
+            463,
+            826,
+            685
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Background: 3D-structured Neural Scene Representations ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            703,
+            694,
+            722
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Recent progress in neural scene representation and rendering has been driven by two key innovations. The first are neural fields, often also referred to as neural implicit- or coordinate-based scene representations $\\Phi ^ { 3 D }$ [3, 4], which model a scene as a continuous function, parameterized as an MLP which maps a 3D coordinate to a representation $\\mathbf { v }$ of whatever is at that 3D coordinate: ",
+        "bbox": [
+            174,
+            734,
+            825,
+            790
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a63c1354c64d4103dc101fdda33b65590d487da07475a1d9938f5baa98fa3523.jpg",
+        "text": "$$\n\\Phi ^ { 3 D } : \\mathbb { R } ^ { 3 } \\to \\mathbb { R } ^ { n } , \\quad \\mathbf { x } \\mapsto \\Phi ^ { 3 D } ( \\mathbf { x } ) = \\mathbf { v } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            367,
+            795,
+            629,
+            814
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The second is a differentiable renderer $\\mathbf { m }$ , which, given a ray $\\mathbf { r }$ in $\\mathbb { R } ^ { 3 }$ , and the representation $\\Phi ^ { 3 D }$ , computes the value of the color c of the scene when viewed along r: ",
+        "bbox": [
+            173,
+            819,
+            825,
+            848
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/aff3e44d9310385bb8c77751fee4bfffb67d653238669c012ac5f1ceb293f2b7.jpg",
+        "text": "$$\n\\begin{array} { r } { { \\bf m } ( { \\bf r } , \\Phi ^ { 3 D } ) = { \\bf c } ( { \\bf r } ) \\in \\mathbb { R } ^ { 3 } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            413,
+            852,
+            584,
+            871
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Existing rendering methods broadly fall into two categories: sphere-tracing-based renderers [3, 45, 5, 46] and volumetric renderers [19, 4]. These methods require on the order of tens or hundreds of ",
+        "bbox": [
+            173,
+            882,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "evaluations of the values of $\\Phi ^ { 3 D }$ along a ray $\\mathbf { r }$ to compute $\\mathbf { c } ( \\mathbf { r } )$ . This leads to extraordinarily large memory and time complexity of rendering. As training requires error backpropagation through the renderer, this impacts both training and test time. ",
+        "bbox": [
+            174,
+            90,
+            825,
+            133
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 The Light Field Network Scene Representation ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            151,
+            598,
+            170
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We propose to represent a scene as a 360-degree neural light field, a function parameterized by an MLP $\\Phi _ { \\phi }$ with parameters $\\phi$ that directly maps the 4D space $\\mathcal { L }$ of oriented rays to their observed radiance: ",
+        "bbox": [
+            174,
+            181,
+            823,
+            223
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e198739f25174d9edd08db5472ca0753f7237c54055d44410d47a5b132683787.jpg",
+        "text": "$$\n\\Phi _ { \\phi } : \\mathcal { L } \\to \\mathbb { R } ^ { 3 } , \\mathbf { r } \\mapsto \\Phi _ { \\phi } ( \\mathbf { r } ) = \\mathbf { c } ( \\mathbf { r } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            383,
+            222,
+            612,
+            239
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "A light field completely characterizes the flow of light through unobstructed space in a static scene with fixed illumination. Light fields have the unique property that rendering is achieved by a single evaluation of $\\Phi$ per light ray, i.e., no ray-casting is required. Moreover, while the light field only encodes appearance explicitly, its derivatives encode geometry information about the underlying 3D scene [47, 34, 35]. This makes many methods to extract 3D geometry from light fields possible [48–51], and we demonstrate efficient recovery of sparse depth maps from LFNs below. ",
+        "bbox": [
+            173,
+            239,
+            825,
+            324
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 Implicit representations for 360 degree light fields ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            338,
+            558,
+            354
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To fully represent a 3D scene requires a parameterization of all light rays in space. Conventional light field methods are constrained to leverage minimal parameterizations of the 4D space of rays, due to the high memory requirements of discretely sampled high-dimensional spaces. In contrast, our use of neural field representations allows us to freely choose a continuous parameterization that is mathematically convenient. In particular, we propose to leverage the 6D Plücker parameterization of the space of light rays $\\mathcal { L }$ for LFNs. The Plücker coordinates (see [52] for an excellent overview) of a ray $\\mathbf { r }$ through a point $\\mathbf { p }$ in a normalized direction $\\mathbf { d }$ are ",
+        "bbox": [
+            173,
+            363,
+            825,
+            462
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/be8b7abf4eed57cb2e0da8439aae409448776e06c6097d846c044cd6092749e3.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathbf { m } = \\mathbf { p } \\times \\mathbf { d } , \\ \\mathrm { f o r } \\quad \\mathbf { d } \\in \\mathbb { S } ^ { 2 } , \\mathbf { p } \\in \\mathbb { R } ^ { 3 } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            459,
+            463,
+            700,
+            481
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\times$ denotes the cross product. While Plücker coordinates are a-priori 6-tuples of real numbers, the coordinates of any ray lie on a curved 4-dimensional subspace $\\mathcal { L }$ . Plücker coordinates uniformly represent all oriented rays in space without singular directions or special cases. Intuitively, a general ray $\\mathbf { r }$ together with the origin define a plane, and $\\mathbf { m }$ is a normal vector to the plane with its magnitude capturing the distance from the ray to the origin; if $\\textbf { m } = \\textbf { 0 }$ then the ray passes through the origin and is defined by its direction d. This is in contrast to conventional light field parameterizations: Fronto-parallel two-plane or cylindrical parameterizations cannot represent the full 360-degree light field of a scene [36, 53]. Cubical two-plane arrangements [37, 38] are not continuous, complicating the parameterization via a neural implicit representation. In contrast to the two-sphere parameterization [54], Plücker coordinates do not require that scenes are bounded in size and do not require spherical trigonometry. ",
+        "bbox": [
+            173,
+            483,
+            825,
+            637
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The parameterization via a neural field enables compact storage of a 4D light field that can be sampled at arbitrary resolutions, while non-neural representations are resolution-limited. Neural fields further allow the analytical computation of derivatives. This enables the efficient computation of sparse depth maps, where prior representations of light fields require finite-differences approximations of the gradient [48–50]. ",
+        "bbox": [
+            173,
+            642,
+            825,
+            712
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Rendering LFNs. To render an image given an LFN, one computes the Plücker coordinates $\\mathbf { r } _ { u , v }$ of the camera rays at each $u , v$ pixel coordinate in the image according to Equation 4. Specifically, given the extrinsic $\\mathbf { E } = \\left[ \\mathbf { R } | \\mathbf { t } \\right] \\bar { \\in } S E ( 3 )$ and intrinsic $\\mathbf { K } \\in \\mathbf { \\bar { \\mathbb { R } } ^ { 3 \\times 3 } }$ camera matrices [55] of a camera, one may retrieve the Plücker coordinates of the ray $\\mathbf { r } _ { u , v }$ at pixel coordinate $u , v$ as: ",
+        "bbox": [
+            173,
+            726,
+            825,
+            782
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f0828707311fc696149ded1baf7c13c5fe1e7c2fc8b27d8af803656d99984b53.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathbf { r } _ { u , v } = ( \\mathbf { d } _ { u , v } , \\mathbf { t } \\times \\mathbf { d } _ { u , v } ) / \\lVert \\mathbf { d } _ { u , v } \\rVert , \\mathrm { ~ w h e r e ~ } \\mathbf { d } _ { u , v } = \\mathbf { R } \\mathbf { K } ^ { - 1 } \\left( \\mathbf { \\Omega } _ { 1 } ^ { u } \\right) + \\mathbf { t } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            281,
+            785,
+            714,
+            813
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where we use the world-to-camera convention for the extrinsic camera parameters. Rendering then amounts to a single evaluation of the LFN $\\Phi$ for each ray, $\\mathbf { c } _ { u , v } = \\Phi ( \\mathbf { r } _ { u , v } )$ . For notational convenience, we introduce a rendering function ",
+        "bbox": [
+            174,
+            814,
+            825,
+            856
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ac77ca56f5c17a1814fe4c3d922199df23445078af7dd1abca0e6e5b89667ce3.jpg",
+        "text": "$$\n\\Theta _ { \\mathbf { E } , \\mathbf { K } } ^ { \\Phi } : \\mathbb { R } ^ { \\ell } \\to \\mathbb { R } ^ { H \\times W \\times 3 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            416,
+            858,
+            581,
+            878
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "which renders an LFN $\\Phi _ { \\phi }$ with parameters $\\phi \\in \\mathbb { R } ^ { \\ell }$ when viewed from a camera with extrinsic and intrinsic parameters $( \\mathbf { E } , \\mathbf { K } )$ into an image. ",
+        "bbox": [
+            173,
+            882,
+            826,
+            912
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/73c7c61826461a6765bc0204fe8bf7adbe552e4de5e489c38d2723128c1da544.jpg",
+        "image_caption": [
+            "Figure 2: Given a 3D scene (left) and a light ray $\\mathbf { r }$ (blue), we can slice the scene along a 2D plane containing the ray (light blue), yielding a 2D scene (center). The light field of all rays in a 2D plane, the Epipolar Plane Image (EPI) $\\mathbf { c } ( s , t )$ (right). can be analytically computed from our 360-degree LFN. The family of rays $L _ { \\mathbf { p } }$ (green) going through a point $\\mathbf { p }$ on an object in the scene defines a straight line in the EPI. See below for further discussion of EPI geometry. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            87,
+            826,
+            231
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 The geometry of Light Field Networks ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            333,
+            478,
+            348
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We will now analyze the properties of LFNs representing Lambertian 3D scenes, and illustrate how the geometry of the underlying 3D scene is encoded. We will first derive an expression that establishes a relationship between LFNs and the classic two-plane parameterization of the light field. Subsequently, we will derive an expression for the depth of a ray in terms of the local color gradient of the light field, therefore allowing us to efficiently extract sparse depth maps from the light field at any camera pose via analytical differentiation of the neural implicit representation. Please see Figure 2 for an overview. ",
+        "bbox": [
+            173,
+            359,
+            825,
+            457
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Locally linear slices of the light field. We derive here a local parametrization that will allow us to work with an LFN as if it were a conventional 2-plane light field. Given a ray r in Plücker coordinates, we pick two points $\\mathbf { x } , \\mathbf { x } ^ { \\prime } \\in \\mathbb { R } ^ { 3 }$ along this ray. We then find a normalized direction $ { \\mathbf { d } } \\in \\mathbb { S } ^ { 2 }$ not parallel to the ray direction - a canonical choice is a direction orthogonal to the ray direction. We may now parameterize two parallel lines $\\mathbf { a } ( s ) = \\mathbf { x } + s \\mathbf { d }$ and $\\mathbf b ( t ) = \\mathbf x ^ { \\prime } + t \\mathbf d$ that give rise to a local two-plane basis of the light field with ray coordinates $s$ and $t$ . r intersects these lines at the two-plane coordinates $( s , t ) = ( 0 , \\bar { 0 } )$ . This choice of local basis now assigns the two-plane coordinates $( s , t )$ to the ray $\\mathbf { r }$ from $\\mathbf { a } ( s )$ to ${ \\bf b } ( t )$ . In Figure 2, we illustrate this process on a simple 2D scene. ",
+        "bbox": [
+            173,
+            472,
+            825,
+            584
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Epipolar Plane Images and their geometry. The Plücker coordinates (see Eq. 4) enable us to extract a 2D slice from an LFN field by varying $( s , t )$ and sampling $\\Phi$ on the Plücker coordinates of the rays parametrized pairs of points on the lines $\\mathbf { a } ( s )$ and ${ \\bf b } ( t )$ : ",
+        "bbox": [
+            174,
+            598,
+            826,
+            641
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ad4af7d689b410a14416c886f72206eff9b3276975557e2a8a0aa1ddd4a472c0.jpg",
+        "text": "$$\n\\mathbf { c } ( s , t ) = \\Phi \\left( \\mathbf { r } ( s , t ) \\right) { \\mathrm { , w h e r e ~ } } \\mathbf { r } ( s , t ) = { \\overline { { \\mathbf { a } ( s ) \\mathbf { b } ( t ) } } } = \\left( { \\frac { \\mathbf { b } ( t ) - \\mathbf { a } ( s ) } { \\| \\mathbf { b } ( t ) - \\mathbf { a } ( s ) \\| } } , { \\frac { \\mathbf { a } ( s ) \\times \\mathbf { b } ( t ) } { \\| \\mathbf { b } ( t ) - \\mathbf { a } ( s ) \\| } } \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            214,
+            647,
+            784,
+            683
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The image of this 2D slice $\\mathbf { c } ( s , t )$ is well-known in the light field literature as an Epipolar Plane Image (EPI) [47]. EPIs carry rich information about the geometry of the underlying 3D scene. For example, consider a point $\\mathbf { p }$ on the surface of an object in the scene; please see Figure 2 for a diagram. A point $ { \\mathbf { p } } \\in \\mathbb { R } ^ { 2 }$ has a 1-dimensional family of rays going through the point, which correspond to a (green) line $L _ { \\mathbf { p } }$ in the EPI. In a Lambertian scene, all rays that meet in this point and that are not occluded by other objects must observe the same color. Therefore, the light field is constant along this line. As one travels along $L _ { \\mathbf { p } }$ , rotating through the family of rays through p, one eventually reaches a (magenta) tangent ray $\\tau$ to the object. At a tangent ray, the value of the EPI ceases to be constant, and the light field changes its color to whatever is disoccluded by the object at this tangent ray. Because objects of different depth undergo differing amounts of parallax, ",
+        "bbox": [
+            173,
+            689,
+            826,
+            829
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "the slope of the segment of $L _ { \\mathbf { p } }$ along which c is constant determines the 3D coordinates of $\\mathbf { p }$ . Finally, by observing that we may extract EPIs from any perspective, it is clear that an LFN encodes the full 3D geometry of the underlying scene. Intuitively, this may also be seen by con",
+        "bbox": [
+            174,
+            829,
+            485,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/922664117c7125aaf03163853ddc50ab3cffea5b53c7f11f9bbbd0dc4bd02722.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            496,
+            834,
+            825,
+            909
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "sidering that one could render out all possible perspectives of the underlying scene, and solve a classic multi-view stereo problem to retrieve the shape. ",
+        "bbox": [
+            173,
+            90,
+            823,
+            119
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Extracting depth maps from LFNs. A correctly inferred light field necessarily contains accurate 3D geometry information, although the geometry is encoded in a nontrivial way. To extract 3D geometry from an LFN, we utilize the property of the 2-plane parameterization that the light field is constant on segments $L _ { \\mathbf { p } }$ , the slopes of which determine $\\mathbf { p }$ . In the supplemental material, we derive ",
+        "bbox": [
+            174,
+            136,
+            825,
+            191
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Proposition 1. For a Lambertian scene, the distance $d$ along $\\mathbf { r } = { \\overrightarrow { \\mathbf { a } ( s ) \\mathbf { b } ( t ) } }$ from $\\mathbf { a } ( s )$ to the point $\\mathbf { p }$ on the object is ",
+        "bbox": [
+            173,
+            196,
+            823,
+            231
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f84ef06ef6c11b3dd40ea645cf9c1453e699b73e88098d1ac5a3bccebfba271e.jpg",
+        "text": "$$\nd ( \\mathbf { r } ) = D \\frac { \\partial _ { t } \\mathbf { c } ( s , t ) } { \\partial _ { s } \\mathbf { c } ( s , t ) + \\partial _ { t } \\mathbf { c } ( s , t ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            393,
+            232,
+            604,
+            266
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { a } ( s )$ and ${ \\bf b } ( t )$ are as above, $\\mathbf { c } ( s , t )$ is defined by (7), $D$ is the distance between the lines ${ \\bf a } ( t )$ and ${ \\bf b } ( t )$ . Thus $\\begin{array} { r } { \\mathbf { p } = \\mathbf { a } ( s ) + d ( \\mathbf { r } ) \\frac { \\mathbf { b } ( t ) - \\mathbf { a } ( s ) } { \\| \\mathbf { b } ( t ) - \\mathbf { a } ( s ) \\| } } \\end{array}$ ) b(t)−a(s)kb(t)−a(s)k , and ∂x denotes the partial derivative by variable x. ",
+        "bbox": [
+            173,
+            271,
+            828,
+            308
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "This result yields meaningful depth estimates wherever the derivatives of the light fields are nonzero along the ray. In practice, we sample several rays in a small $( s , t )$ neighborhood of the ray $\\mathbf { r }$ and declare depth estimates as invalid if the gradients have high variance-please see the code for implementation details. This occurs when $\\mathbf { r }$ hits the object at a point where the surface color is changing, or when $\\mathbf { r }$ is a tangent ray. We note that there is a wealth of prior art that could be used to extend this approach to extract dense depth maps [48–51]. ",
+        "bbox": [
+            173,
+            318,
+            825,
+            402
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 Meta-learning with conditional Light Field Networks ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            420,
+            581,
+            435
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We consider a dataset $\\mathcal { D }$ consisting of $N$ 3D scenes ",
+        "bbox": [
+            174,
+            446,
+            511,
+            462
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/46690ba16dcc1fd1d77105796cefe744372ebf706f5a3dc4ea36ae3ad1ebf4cc.jpg",
+        "text": "$$\nS _ { i } = \\{ ( \\mathbf { I } _ { j } , \\mathbf { E } _ { j } , \\mathbf { K } _ { j } ) \\} _ { j = 1 } ^ { K } \\in \\mathbb { R } ^ { H \\times W \\times 3 } \\times S E ( 3 ) \\times \\mathbb { R } ^ { 3 \\times 3 } , i = 1 \\dots N\n$$",
+        "text_format": "latex",
+        "bbox": [
+            271,
+            469,
+            727,
+            491
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "with $K$ images $\\mathbf { I } _ { j }$ of each scene taken with cameras with extrinsic parameters $\\mathbf { E } _ { j }$ and intrinsic parameters $\\mathbf { K } _ { j }$ [55]. Each scene is completely described by the parameters $\\phi _ { i } \\in \\mathbb { R } ^ { \\ell }$ of its corresponding light field MLP $\\Phi _ { i } = \\Phi _ { \\phi _ { i } }$ . ",
+        "bbox": [
+            174,
+            497,
+            825,
+            542
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Meta-learning and multi-view consistency. In the case of 3D-structured neural scene representations, ray-marching or volumetric rendering naturally ensure multi-view consistency of the reconstructed 3D scene representation. In contrast, a general 4D function $\\Phi : \\mathcal { L }  \\mathbb { R } ^ { 3 }$ is not multi-view consistent, as most such functions are not the light fields of any 3D scene. We propose to overcome this challenge by learning a prior over the space of light fields. As we will demonstrate, this prior can also be used to reconstruct an LFN from a single 2D image observation. In this paradigm, differentiable ray-casting is a method to force the light field of a scene to be multi-view consistent, while we instead impose multi-view consistency by learning a prior over light fields. ",
+        "bbox": [
+            173,
+            558,
+            825,
+            670
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Meta-learning framework. We propose to represent each 3D scene $S _ { i }$ by its own latent vector $\\mathbf { z } _ { i } \\in \\mathbb { R } ^ { k }$ . Generalizing to new scenes amounts to learning a prior over the space of light fields that is concentrated on the manifold of multi-view consistent light fields of natural scenes. To represent this latent manifold, we utilize a hypernetwork [56, 3]. The hypernetwork is a function, represented as an MLP ",
+        "bbox": [
+            173,
+            685,
+            825,
+            755
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bad77c4c8fd73351caff9e56fc5c2880ff0bc96af208ac56fa7eeb145e2b7ac6.jpg",
+        "text": "$$\n\\Psi : \\mathbb { R } ^ { k } \\to \\mathbb { R } ^ { \\ell } , \\Psi _ { \\psi } ( \\mathbf { z } _ { i } ) = \\phi _ { i }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            405,
+            755,
+            593,
+            773
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "with parameters $\\psi$ which sends the latent code $\\mathbf { z } _ { i }$ of the $i$ -th scene to the parameters of the corresponding LFN. ",
+        "bbox": [
+            173,
+            779,
+            825,
+            809
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Several reasonable approaches exist to obtain latent codes $\\mathbf { z } _ { i }$ . One may leverage a convolutionalor transformer-based image encoder, directly inferring the latent from an image [11, 5], or utilize gradient-based meta-learning [23]. Here, we follow an auto-decoder framework [1, 3] to find the latent codes $\\mathbf { z } _ { i }$ , but note that LFNs are in no way constrained to this approach. We do not claim that this particular meta-learning method will out-perform other forms of conditioning, such as gradient-based meta-learning [57, 23] or FILM conditioning [58], but perform a comparison to a conditioning-by-concatenation approach in the appendix. We assume that the latent vectors have a Gaussian prior with zero mean and a diagonal covariance matrix. At training time, we jointly optimize the latent parameters $\\mathbf { z } _ { i }$ together with the hypernetwork parameters $\\psi$ using the objective ",
+        "bbox": [
+            173,
+            814,
+            825,
+            912
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/22115e545d7ac56d292ba67c10b6574f621b5aef47d4b2aa2cb55dc839511f3d.jpg",
+        "image_caption": [
+            "Figure 3: 360-degree light field parameterization. Top left: 3D slice in the style of the Lumigraph [37] of an LFN of a room-scale scene. Bottom left: nearby views of a car as well as vertical (right, red) and horizontal (top, green) Epipolar Plane Images, sampled from an LFN. Reconstructed from training set, 50 and 15 views, respectively. Right: LFNs enable rendering from arbitrary, 360-degree camera perspectives as well as sparse depth map extraction from only a single sample per ray. Please see the supplemental video for more qualitative results. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            87,
+            823,
+            347
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            455,
+            823,
+            486
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/132587682fafa0bc23efe48585cb358f46bcd1a3c384f95a182b7e4cd7955772.jpg",
+        "text": "$$\n\\underset { \\{ { \\bf { z } } _ { i } \\} , \\psi } { \\arg \\operatorname* { m i n } } \\sum _ { i } \\sum _ { j } \\| \\Theta _ { { \\bf { E } } _ { j } , { \\bf { K } } _ { j } } ^ { \\Phi } ( \\Psi _ { \\psi } ( { \\bf { z } } _ { i } ) ) - { \\bf { I } } _ { j } \\| _ { 2 } ^ { 2 } + \\lambda _ { l a t } \\| { \\bf { z } } _ { i } \\| _ { 2 } ^ { 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            312,
+            500,
+            684,
+            535
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Here the $\\Theta ^ { \\Phi }$ is the rendering function (Equation 6), the first term is an $\\ell _ { 2 }$ loss penalizing the light fields that disagree with the observed images, and the second term enforces the prior over the latent variables. We solve Equation 11 using gradient descent. At test time, we freeze the parameters of the hypernetwork and reconstruct the light field for a new scene $S$ given a single observation of the scene $\\mathbf { \\bar { \\{ ( I , E , K ) \\} } }$ by optimizing, using gradient descent, the latent variable $\\mathbf { z } _ { S }$ of the scene, such that the reconstructed light field $\\Phi _ { \\Psi _ { \\psi } ( { \\bf z } _ { S } ) }$ best matches the given observation of the scene: ",
+        "bbox": [
+            173,
+            553,
+            825,
+            638
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1c273c343b577ba6ed99eb858bdb33232432c98ca03b78759e7cfbb59c86e3e5.jpg",
+        "text": "$$\n\\mathbf { z } _ { S } = \\underset { \\mathbf { z } } { \\arg \\operatorname* { m i n } } \\ \\lVert \\boldsymbol { \\Theta } _ { \\mathbf { E } , \\mathbf { K } } ^ { \\Phi } ( \\boldsymbol { \\Psi } _ { \\psi } ( \\mathbf { z } ) ) - \\mathbf { I } ) \\rVert _ { 2 } ^ { 2 } + \\lambda _ { l a t } \\lVert \\mathbf { z } \\rVert _ { 2 } ^ { 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            330,
+            654,
+            668,
+            681
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Global vs. local conditioning The proposed meta-learning framework globally conditions an LFN on a single latent variable $\\mathbf { z }$ . Recent work instead leverages local conditioning, where a neural field is conditioned on local features extracted from a context image [26, 6, 27]. In particular, the recently proposed pixelNeRF [6] has achieved impressive results on few-shot novel view synthesis. As we will see, the current formulation of LFNs does not outperform pixelNeRF. We note, however, that local conditioning methods solve a different problem. Rather than learning a prior over classes of objects, local conditioning methods learn priors over patches, answering the question “How does this image patch look like from a different perspective?”. As a result, this approach does not learn a latent space of neural scene representations. Rather, scene context is required to be available at test time to reason about the underlying 3D scene, and the representation is not compact: the size of the conditioning grows with the number of context observations. In contrast, globally conditioned methods [3, 11, 1, 2] first infer a global representation that is invariant to the number of context views and subsequently discard the observations. However, local conditioning enables better generalization due to the shift-equivariance of convolutional neural networks. An equivalent to local conditioning in light fields is non-obvious, and an exciting direction for future work. ",
+        "bbox": [
+            173,
+            704,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/59f49446de3ce480d695474c650bd5267d9e830d8755e6fbd85c5a6cf1c615a1.jpg",
+        "image_caption": [
+            "Figure 4: Category-agnostic single-shot reconstruction. We train a single model on the 13 largest Shapenet classes. LFNs consistently outperform global conditioning baselines. Baseline results courtesy of the pixelNeRF [6] authors. Please see the supplemental video for more qualitative results. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            87,
+            821,
+            186
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Single-shot multi-class reconstruction results. We benchmark LFNs with SRNs [3] and DVR [5] on the task of single-shot (auto-decoding with a single view), multi-class reconstruction of the 13 largest ShapeNet [59] classes. LFNs significantly outperform DVR and SRNs on almost all classes, on average by more than 1dB, while only requiring a single network evaluation per ray. Note that DVR requires additional supervision in the form of foreground-background masks. Means across classes are weighted equally. ",
+        "bbox": [
+            173,
+            257,
+            825,
+            340
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/e9428547d105bda2274eb81285bddd1db459db8eefd6001ebcc3d5b099d5dad1.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td></td><td>plane</td><td>bench</td><td>cbnt.</td><td>car</td><td>chair</td><td>disp.</td><td>lamp</td><td>spkr.</td><td>rifle</td><td>sofa</td><td>table</td><td>phone</td><td>boat</td><td>mean</td></tr><tr><td rowspan=\"3\">↑PSNR</td><td>DVR [5]</td><td>25.29</td><td>22.64</td><td>24.47</td><td>23.95</td><td>19.91</td><td>20.86</td><td>23.27</td><td>20.78</td><td>23.44</td><td>23.35</td><td>21.53</td><td>24.18</td><td>25.09</td><td>22.70</td></tr><tr><td>SRN[3]</td><td>26.62</td><td>22.20</td><td>23.42</td><td>24.40</td><td>21.85</td><td>19.07</td><td>22.17</td><td>21.04</td><td>24.95</td><td>23.65</td><td>22.45</td><td>20.87</td><td>25.86</td><td>23.28</td></tr><tr><td>LFN</td><td>29.95</td><td>23.21</td><td>25.91</td><td>28.04</td><td>22.94</td><td>20.64</td><td>24.56</td><td>22.54</td><td>27.50</td><td>25.15</td><td>24.58</td><td>22.21</td><td>27.16</td><td>24.95</td></tr><tr><td rowspan=\"3\">↑ SSIM</td><td>DVR [5]</td><td>0.905</td><td>0.866</td><td>0.877</td><td>0.909</td><td>0.787</td><td>0.814</td><td>0.849</td><td>0.798</td><td>0.916</td><td>0.868</td><td>0.840</td><td>0.892</td><td>0.902</td><td>0.860</td></tr><tr><td>SRN[3]</td><td>0.901</td><td>0.837</td><td>0.831</td><td>0.897</td><td>0.814</td><td>0.744</td><td>0.801</td><td>0.779</td><td>0.913</td><td>0.851</td><td>0.828</td><td>0.811</td><td>0.898</td><td>0.849</td></tr><tr><td>LFN</td><td>0.932</td><td>0.855</td><td>0.871</td><td>0.943</td><td>0.835</td><td>0.786</td><td>0.844</td><td>0.808</td><td>0.939</td><td>0.874</td><td>0.868</td><td>0.844</td><td>0.907</td><td>0.870</td></tr></table>",
+        "bbox": [
+            176,
+            349,
+            823,
+            433
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            446,
+            312,
+            464
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We demonstrate the efficacy of LFNs by reconstructing 360-degree light fields of a variety of simple 3D scenes. In all experiments, we parameterize LFNs via a 6-layer ReLU MLP, and the hypernetwork as a 3-layer ReLU MLP, both with layer normalization. We solve all optimization problems using the ADAM solver with a step size of $1 0 ^ { - 4 }$ . Please find more results, as well as precise hyperparameter, implementation, and dataset details, in the supplemental document and video. ",
+        "bbox": [
+            173,
+            478,
+            825,
+            549
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Reconstructing appearance and geometry of single-object and room-scale light fields. We demonstrate that LFN can parameterize 360-degree light fields of both single-object ShapeNet [59] objects and simple, room-scale environments. We train LFNs on the ShapeNet “cars” dataset with 50 observations per object from [3], as well as on simple room-scale environments as proposed in [13]. Subsequently, we evaluate the ability of LFNs to generate novel views of the underlying 3D scenes. Please see Figure 3 for qualitative results. LFNs succeed in parameterizing the 360-degree light field, enabling novel view synthesis at real-time frame-rates (see supplemental video). We further demonstrate that LFNs encode scene geometry by presenting Epipolar Plane Images and leveraging the relationship derived in Equation 8 to infer sparse depth maps. We highlight that both rendering and depth map extraction do not require ray-casting, with only a single evaluation of the network or the network and its gradient respectively. ",
+        "bbox": [
+            174,
+            563,
+            825,
+            715
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Multi-class single-view reconstruction. Following [5, 6], we benchmark LFNs with recent global conditioning methods on the task of single-view reconstruction and novel view synthesis of the 13 largest ShapeNet categories. We follow the same evaluation protocol as [60] and train a single model across all categories. See Figure 4 for qualitative and Table 1 for quantitative baseline comparisons. We significantly outperform both Differentiable Volumetric Rendering (DVR) [5] and Scene Representation Networks (SRNs) [3] on all but two classes by an average of 1dB, while requiring more than an order of magnitude fewer network evaluations per ray. Qualitatively, we find that the reconstructions from LFNs are often crisper than those of either Scene Representation Networks or DVR. Note that DVR requires additional ground-truth foreground-background segmentation masks. ",
+        "bbox": [
+            174,
+            729,
+            825,
+            854
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Class-specific single-view reconstruction. We benchmark LFNs on single-shot reconstruction on the Shapenet “cars” and “chairs” classes as proposed in SRNs [3]. See Figure 5 for qualitative and quantitative results. We report performance better than SRNs in PSRN and on par in terms of SSIM on the “cars” class, and worse in PSNR but better in terms of SSIM on the “chairs” class, while requiring an order of magnitude fewer network evaluations and rendering in real-time. We attribute the drop in performance compared to multi-class reconstruction to the smaller dataset size, causing multi-view inconsistency. ",
+        "bbox": [
+            176,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/fe52aa157497d0214fab15373ed7a9762e7b4da6397b9cc0cca6fc7ef6bb492d.jpg",
+        "image_caption": [
+            "Figure 5: Class-specific single-shot reconstruction. LFN performs approximately on par with SRNs [3] in the single-class single-shot reconstruction case, while requiring an order of magnitude fewer network evaluations, memory, and rendering time. Quantitative results report (PSNR, SSIM). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            87,
+            521,
+            160
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/b7f8172e23a60da20f1b312aacfc407e29209384f56ac67191749e5ea48404e0.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Chairs</td><td>Cars</td></tr><tr><td>SRNs [3]</td><td>22.89 /0.89</td><td>22.25 /0.89</td></tr><tr><td>LFN</td><td>22.26 / 0.90</td><td>22.42/0.89</td></tr></table>",
+        "bbox": [
+            535,
+            102,
+            810,
+            156
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/24b6c65a45c54946935e9848ea1bf66a3d875f315e661e2d54295031697d5f3c.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Class-specific</td><td>Multi-Class</td></tr><tr><td>LFN</td><td>22.34 /0.90</td><td>24.95 /0.87</td></tr><tr><td>pixelNeRF</td><td>23.45 /0.91</td><td>26.80/0.91</td></tr></table>",
+        "bbox": [
+            535,
+            238,
+            823,
+            292
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/02021fee3ced9ce221bb477ebf540075483c411f89cf83da1fdae1b980d0455d.jpg",
+        "image_caption": [
+            "Figure 6: Global vs. local conditioning. The locally conditioned pixelNeRF outperforms LFNs in single-shot reconstruction, though LFNs require three orders of magnitude less rendering time and memory. Qualitatively, for many objects LFNs are on par with pixelNERF (left), but confuse the object class on others (right). Quantitative results report (PSNR, SSIM). ‘Class-specific’ refers to average over cars and chairs as in Fig. 5 while ’multi-class’ refers to the average over all ShapeNet classes as in Fig. 1. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            224,
+            524,
+            301
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            421,
+            825,
+            478
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Global vs. local conditioning and comparison to pixelNeRF [6]. We investigate the role of global conditioning, where a single latent is inferred to describe the whole scene [3], to local conditioning, where latents are inferred per-pixel in a 2D image and leveraged to locally condition a neural implicit representation [26, 27, 6]. We benchmark with the recently proposed pixelNeRF [6]. As noted above (see Section 4.3), local conditioning does not infer a compact neural scene representation of the scene. Nevertheless, we provide the comparison here for completeness. See Figure 6 for qualitative and quantitative results. On average, LFNs perform 1dB worse than pixelNeRF in the single-class case, and 2dB worse in the multi-class setting. ",
+        "bbox": [
+            174,
+            494,
+            825,
+            606
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Real-time rendering and storage cost. See Table 2 for a quantitative comparison of the rendering complexity of LFN compared with that of volumetric and ray-marching based neural renderers [3, 45, 19, 4, 6]. All clock times were collected for rendering $2 5 6 \\times 2 5 6$ images on an NVIDIA RTX 6000 GPU. We further compare the cost of storing a single LFN with the cost of storing a conventional light field. With approximately $4 0 0 \\mathrm { k }$ parameters, a single LFN requires around $1 . 6 \\mathrm { M B }$ of storage, compared to $1 4 6 \\mathrm { M B }$ required for storing a 360-degree light field at a resolution of $2 5 6 \\times 2 5 6 \\times 1 7 \\times 1 7$ in the six-plane Lumigraph configuration. ",
+        "bbox": [
+            173,
+            622,
+            826,
+            720
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Multi-view consistency as a function of training set size. We investigate how multi-view consistency scales with the amount of data that the prior is trained on. Please find this analysis in the supplementary material. ",
+        "bbox": [
+            174,
+            737,
+            825,
+            780
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/f142a2e5e5666accb1be2dff3d84bf2a3e2977ffe295d242c4a77a2274bffd68.jpg",
+        "table_caption": [
+            "Table 2: Comparison of rendering complexity. LFNs require three orders of magnitude less compute than volumetric rendering based approaches, and admit real-time rendering. Please see Table of supplemental material for comparison on larger images based on data in [] "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>LFNs</td><td>SRNs [3]</td><td>pixelNeRF [6]</td></tr><tr><td># evaluations per ray</td><td>1</td><td>11</td><td>192</td></tr><tr><td>clock time for 256 × 256 image (ms)</td><td>2.1</td><td>120</td><td>30e3</td></tr></table>",
+        "bbox": [
+            258,
+            854,
+            733,
+            909
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/c8b890e98896a62cc67f532b6d4f06373fa82be3cfc95fd8211ac95f9b202ffb.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Cars</td><td>Chairs</td></tr><tr><td>SRNs</td><td>0.071</td><td>0.20</td></tr><tr><td>LFN</td><td>0.059</td><td>0.130</td></tr></table>",
+        "bbox": [
+            638,
+            102,
+            820,
+            156
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/530da26ccc2b5956552abe83e4bc801dceb799c43163dc51935a7c926ce33f4a.jpg",
+        "image_caption": [
+            "Figure 7: Geometry reconstruction with LFNs. By backprojecting extracted depth into 3D, LFNs enable reconstruction of 3D pointclouds (left). For rays were depth is valid, LFNs achieve lower mean L1 depth error than Scene Representation Networks (right). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            94,
+            633,
+            152
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Overfitting of single 3D scenes. We investigate overfitting a single 3D scene with a Light Field Network with positional encodings / sinusoidal activations [24, 61]. Please find this analysis in the supplementary material. ",
+        "bbox": [
+            176,
+            228,
+            823,
+            271
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Evaluation of Reconstructed Geometry. We investigate the quality of the geometry that can be computed from an LFN via Eq. 8. For every sample in the class-specific single-shot reconstruction experiment, we extract its per-view sparse depth map. We then backproject depth maps from four views into 3D to reconstruct a point cloud, and benchmark mean L1 error on valid depth estimates with Scene Representation Networks [3]. Fig. 7 displays qualitative and quantitative results. Qualitatively, point clouds succeed in capturing fine detail such as the armrests of chairs. Quantitatively, LFNs outperform SRNs on both cars and chairs. We note that LFNs have a slight advantage in this comparison, as we can only benchmark on the sparse depth values, for which LFNs have high confidence. This includes occlusion boundaries, which are areas where the sphere-tracing based SRNs incurs high error, as it is forced to take smaller and smaller steps and may not reach the surface. We highlight that we do not claim that the proposed method is competetive with methods designed for geometry reconstruction in particular, but that we only report this to demonstrate that the proposed method is capable to extract valid depth estimates from an LFN. ",
+        "bbox": [
+            174,
+            285,
+            825,
+            463
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/f7c7f6ba77efe36b20df3656c2915d05fb267b3447fd0fada506b8afe052a6cf.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            560,
+            459,
+            823,
+            515
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Limitations. First, as every existing light field approach, LFNs store only one color per oriented ray, which makes rendering views from cameras placed in between occluding objects challenging, even if the information may still be stored in the light field. Second, though we outperform globally-conditioned methods, we currently do not outperform the locally conditioned pixelNeRF. Finally, as opposed to 3D-structured representations, LFNs do not enforce strict multi-view consistency, and may be inconsistent in the case of small datasets. ",
+        "bbox": [
+            173,
+            479,
+            552,
+            520
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            520,
+            826,
+            575
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Discussion and Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            594,
+            428,
+            612
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We have proposed Light Field Networks, a novel neural scene representation that directly parameterizes the full 360-degree, 4D light field of a 3D scene via a neural implicit representation. This enables both real-time neural rendering with a single evaluation of the neural scene representation per ray, as well as sparse depth map extraction without ray-casting. Light Field Networks outperform globally conditioned baselines in single-shot novel view synthesis, while being three orders of magnitude faster and less memory-intensive than current volumetric rendering approaches. Exciting avenues for future work include combining LFNs with local conditioning, which would enable stronger out-of-distribution generalization, studying the learning of non-Lambertian scenes, and enabling camera placement in obstructed 3D space. With this work, we make important contributions to the emerging fields of neural rendering and neural scene representations, with exciting applications across computer vision, computer graphics, and robotics. ",
+        "bbox": [
+            173,
+            625,
+            825,
+            777
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Societal Impacts. Potential improvements extending our work on few-observation novel view synthesis could enable abuse by decreasing the cost of non-consensual impersonations. We refer the reader to a recent review of neural rendering [22] for an in-depth discussion of this topic. ",
+        "bbox": [
+            174,
+            791,
+            825,
+            834
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgements and Disclosure of Funding ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            852,
+            563,
+            869
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This work is supported by the NSF under Cooperative Agreement PHY-2019786 (The NSF AI Institute for Artificial Intelligence and Fundamental Interactions, http://iaifi.org/), ONR under 1015 ",
+        "bbox": [
+            174,
+            882,
+            823,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "G TA243/N00014-16-1-2007 (Understanding Scenes and Events through Joint Parsing, Cognitive Reasoning and Lifelong Learning), Mitsubishi under 026455-00001 (Building World Models from some data through analysis by synthesis), DARPA under CW3031624 (Transfer, Augmentation and Automatic Learning with Less Labels), as well as the Singapore DSTA under DST00OECI20300823 (New Representations for Vision). We thank Andrea Tagliasacchi, Tomasz Malisiewicz, Prafull Sharma, Ludwig Schubert, Kevin Smith, Bernhard Egger, Christian Richardt, Manuel Rey Area, and Jürgen and Susanne Sitzmann for interesting discussions and feedback, and Alex Yu for kindly sharing the outputs of pixelNeRF and baselines with us. ",
+        "bbox": [
+            173,
+            92,
+            825,
+            202
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            222,
+            266,
+            237
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[1] Jeong Joon Park, Peter Florence, Julian Straub, Richard Newcombe, and Steven Lovegrove. Deepsdf: Learning continuous signed distance functions for shape representation. In Proc. CVPR, 2019.   \n[2] Lars Mescheder, Michael Oechsle, Michael Niemeyer, Sebastian Nowozin, and Andreas Geiger. Occupancy networks: Learning 3d reconstruction in function space. In Proc. CVPR, 2019.   \n[3] Vincent Sitzmann, Michael Zollhöfer, and Gordon Wetzstein. Scene representation networks: Continuous 3d-structure-aware neural scene representations. In Proc. NeurIPS 2019, 2019.   \n[4] Ben Mildenhall, Pratul P Srinivasan, Matthew Tancik, Jonathan T Barron, Ravi Ramamoorthi, and Ren Ng. Nerf: Representing scenes as neural radiance fields for view synthesis. In Proc. ECCV, 2020.   \n[5] Michael Niemeyer, Lars Mescheder, Michael Oechsle, and Andreas Geiger. Differentiable volumetric rendering: Learning implicit 3d representations without 3d supervision. In Proc. CVPR, 2020.   \n[6] Alex Yu, Vickie Ye, Matthew Tancik, and Angjoo Kanazawa. pixelnerf: Neural radiance fields from one or few images. Proc. CVPR, 2020.   \n[7] Ben Mildenhall, Pratul P Srinivasan, Rodrigo Ortiz-Cayon, Nima Khademi Kalantari, Ravi Ramamoorthi, Ren Ng, and Abhishek Kar. Local light field fusion: Practical view synthesis with prescriptive sampling guidelines. ACM Transactions on Graphics (TOG), 38(4):1–14, 2019.   \n[8] Shuaifeng Zhi, Tristan Laidlow, Stefan Leutenegger, and Andrew J Davison. In-place scene labelling and understanding with implicit scene representation. arXiv preprint arXiv:2103.15875, 2021.   \n[9] A. Kohli, V. Sitzmann, and G. Wetzstein. Semantic Implicit Neural Scene Representations with Semisupervised Training. In Proc. 3DV, 2020.   \n[10] Edgar Sucar, Shikun Liu, Joseph Ortiz, and Andrew J Davison. imap: Implicit mapping and positioning in real-time. arXiv preprint arXiv:2103.12352, 2021.   \n[11] Adam R Kosiorek, Heiko Strathmann, Daniel Zoran, Pol Moreno, Rosalia Schneider, Sona Mokrá, ˇ and Danilo J Rezende. Nerf-vae: A geometry aware 3d scene generative model. arXiv preprint arXiv:2104.00587, 2021.   \n[12] Daniel E Worrall, Stephan J Garbin, Daniyar Turmukhambetov, and Gabriel J Brostow. Interpretable transformations with encoder-decoder networks. In Proc. ICCV, volume 4, 2017.   \n[13] SM Ali Eslami, Danilo Jimenez Rezende, Frederic Besse, Fabio Viola, Ari S Morcos, Marta Garnelo, Avraham Ruderman, Andrei A Rusu, Ivo Danihelka, Karol Gregor, et al. Neural scene representation and rendering. Science, 360(6394):1204–1210, 2018.   \n[14] Vincent Sitzmann, Justus Thies, Felix Heide, Matthias Nießner, Gordon Wetzstein, and Michael Zollhöfer. Deepvoxels: Learning persistent 3d feature embeddings. In Proc. CVPR, 2019.   \n[15] Hsiao-Yu Fish Tung, Ricson Cheng, and Katerina Fragkiadaki. Learning spatial common sense with geometry-aware recurrent networks. Proc. CVPR, 2019.   \n[16] Thu H Nguyen-Phuoc, Chuan Li, Stephen Balaban, and Yongliang Yang. Rendernet: A deep convolutional network for differentiable rendering from 3d shapes. In Proc. NIPS. 2018.   \n[17] Jun-Yan Zhu, Zhoutong Zhang, Chengkai Zhang, Jiajun Wu, Antonio Torralba, Josh Tenenbaum, and Bill Freeman. Visual object networks: image generation with disentangled 3d representations. In Proc. NIPS, pages 118–129, 2018.   \n[18] Thu Nguyen-Phuoc, Chuan Li, Lucas Theis, Christian Richardt, and Yong-Liang Yang. Hologan: Unsupervised learning of 3d representations from natural images. In Proc. ICCV, 2019.   \n[19] Stephen Lombardi, Tomas Simon, Jason Saragih, Gabriel Schwartz, Andreas Lehrmann, and Yaser Sheikh. Neural volumes: Learning dynamic renderable volumes from images. arXiv preprint arXiv:1906.07751, 2019.   \n[20] Danilo Jimenez Rezende, S. M. Ali Eslami, Shakir Mohamed, Peter Battaglia, Max Jaderberg, and Nicolas Heess. Unsupervised learning of 3d structure from images. In Proc. NIPS. 2016.   \n[21] Yiheng Xie, Towaki Takikawa, Shunsuke Saito, Or Litany, Shiqin Yan, Numair Khan, Federico Tombari, James Tompkin, Vincent Sitzmann, and Srinath Sridhar. Neural fields in visual computing and beyond. In arXiv, 2021.   \n[22] Ayush Tewari, Ohad Fried, Justus Thies, Vincent Sitzmann, Stephen Lombardi, Kalyan Sunkavalli, Ricardo Martin-Brualla, Tomas Simon, Jason Saragih, Matthias Nießner, et al. State of the art on neural rendering. In Computer Graphics Forum, volume 39, pages 701–727. Wiley Online Library, 2020.   \n[23] Vincent Sitzmann, Eric R Chan, Richard Tucker, Noah Snavely, and Gordon Wetzstein. Metasdf: Metalearning signed distance functions. Proc. NeurIPS, 2020.   \n[24] Vincent Sitzmann, Julien N.P. Martel, Alexander W. Bergman, David B. Lindell, and Gordon Wetzstein. Implicit neural representations with periodic activation functions. In Proc. NeurIPS, 2020.   \n[25] Konstantinos Rematas, Ricardo Martin-Brualla, and Vittorio Ferrari. Sharf: Shape-conditioned radiance fields from a single view. In Proc. ICML, 2021.   \n[26] Shunsuke Saito, Zeng Huang, Ryota Natsume, Shigeo Morishima, Angjoo Kanazawa, and Hao Li. Pifu: Pixel-aligned implicit function for high-resolution clothed human digitization. In Proc. ICCV, pages 2304–2314, 2019.   \n[27] Alex Trevithick and Bo Yang. Grf: Learning a general radiance field for 3d scene representation and rendering. arXiv preprint arXiv:2010.04595, 2020.   \n[28] Christian Reiser, Songyou Peng, Yiyi Liao, and Andreas Geiger. Kilonerf: Speeding up neural radiance fields with thousands of tiny mlps. arXiv preprint arXiv:2103.13744, 2021.   \n[29] Alex Yu, Ruilong Li, Matthew Tancik, Hao Li, Ren Ng, and Angjoo Kanazawa. Plenoctrees for real-time rendering of neural radiance fields. arXiv preprint arXiv:2103.14024, 2021.   \n[30] Lingjie Liu, Jiatao Gu, Kyaw Zaw Lin, Tat-Seng Chua, and Christian Theobalt. Neural sparse voxel fields. Proc. NeurIPS, 2020.   \n[31] David B Lindell, Julien NP Martel, and Gordon Wetzstein. Autoint: Automatic integration for fast neural volume rendering. Proc. CVPR, 2020.   \n[32] Thomas Neff, Pascal Stadlbauer, Mathias Parger, Andreas Kurz, Chakravarty R Alla Chaitanya, Anton Kaplanyan, and Markus Steinberger. Donerf: Towards real-time rendering of neural radiance fields using depth oracle networks. arXiv e-prints, pages arXiv–2103, 2021.   \n[33] Petr Kellnhofer, Lars Jebe, Andrew Jones, Ryan Spicer, Kari Pulli, and Gordon Wetzstein. Neural lumigraph rendering. Proc. CVPR, 2021.   \n[34] Edward H Adelson, James R Bergen, et al. The plenoptic function and the elements of early vision, volume 2. Vision and Modeling Group, Media Laboratory, Massachusetts Institute of Technology, 1991.   \n[35] Edward H Adelson and John YA Wang. Single lens stereo with a plenoptic camera. IEEE transactions on pattern analysis and machine intelligence, 14(2):99–106, 1992.   \n[36] Marc Levoy and Pat Hanrahan. Light field rendering. In Proc. SIGGRAPH, 1996.   \n[37] Steven J Gortler, Radek Grzeszczuk, Richard Szeliski, and Michael F Cohen. The lumigraph. In Proc. SIGGRAPH, 1996.   \n[38] Chris Buehler, Michael Bosse, Leonard McMillan, Steven Gortler, and Michael Cohen. Unstructured lumigraph rendering. In Proceedings of the 28th annual conference on Computer graphics and interactive techniques, pages 425–432, 2001.   \n[39] Ren Ng et al. Digital light field photography, volume 7. stanford university Stanford, 2006.   \n[40] Suren Vagharshakyan, Robert Bregovic, and Atanas Gotchev. Light field reconstruction using shearlet transform. Proc. PAMI, 40(1):133–147, 2017.   \n[41] Lixin Shi, Haitham Hassanieh, Abe Davis, Dina Katabi, and Fredo Durand. Light field reconstruction using sparsity in the continuous fourier domain. ACM Transactions on Graphics (TOG), 34(1):1–13, 2014.   \n[42] Anat Levin and Fredo Durand. Linear view synthesis using a dimensionality gap light field prior. In Proc. CVPR, pages 1831–1838. IEEE, 2010.   \n[43] Nima Khademi Kalantari, Ting-Chun Wang, and Ravi Ramamoorthi. Learning-based view synthesis for light field cameras. ACM Trans. Graph. (SIGGRAPH Asia), 35(6):193, 2016.   \n[44] Mojtaba Bemana, Karol Myszkowski, Hans-Peter Seidel, and Tobias Ritschel. X-fields: Implicit neural view-, light- and time-image interpolation. Proc. SIGGRAPH Asia 2020, 39(6), 2020.   \n[45] Lior Yariv, Yoni Kasten, Dror Moran, Meirav Galun, Matan Atzmon, Basri Ronen, and Yaron Lipman. Multiview neural surface reconstruction by disentangling geometry and appearance. Proc. NeurIPS, 2020.   \n[46] Qiangeng Xu, Weiyue Wang, Duygu Ceylan, Radomír Mech, and Ulrich Neumann. DISN: deep implicit surface network for high-quality single-view 3d reconstruction. In Proc. NIPS, 2019.   \n[47] Robert C Bolles, H Harlyn Baker, and David H Marimont. Epipolar-plane image analysis: An approach to determining structure from motion. Proc. IJCV, 1(1):7–55, 1987.   \n[48] Don Dansereau and Len Bruton. Gradient-based depth estimation from 4d light fields. In Proc. IEEE International Symposium on Circuits and Systems, volume 3, pages III–549. IEEE, 2004.   \n[49] Ivana Tosic and Kathrin Berkner. Light field scale-depth space transform for dense depth estimation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition Workshops, pages 435–442, 2014.   \n[50] Changil Kim, Henning Zimmer, Yael Pritch, Alexander Sorkine-Hornung, and Markus H Gross. Scene reconstruction from high spatio-angular resolution light fields. ACM Transactions on Graphics (TOG), 32(4):73–1, 2013.   \n[51] Lipeng Si and Qing Wang. Dense depth-map estimation and geometry inference from light fields via global optimization. In Asian Conference on Computer Vision, pages 83–98. Springer, 2016.   \n[52] Yan-Bin Jia. Plücker coordinates for lines in the space. Problem Solver Techniques for Applied Computer Science, Com-S-477/577 Course Handout. Iowa State University, https://faculty.sites.iastate.edu/jia/files/inline-files/plucker-coordinates.pdf, 2020.   \n[53] Bernd Krolla, Maximilian Diebold, Bastian Goldlücke, and Didier Stricker. Spherical light fields. In Proc. BMVC, 2014.   \n[54] Insung Ihm, Sanghoon Park, and Rae Kyoung Lee. Rendering of spherical light fields. In Proceedings The Fifth Pacific Conference on Computer Graphics and Applications, pages 59–68, 1997.   \n[55] Richard Hartley and Andrew Zisserman. Multiple View Geometry in Computer Vision. Cambridge University Press, 2nd edition, 2003.   \n[56] David Ha, Andrew Dai, and Quoc V Le. Hypernetworks. In Proc. ICLR, 2017.   \n[57] Chelsea Finn, Pieter Abbeel, and Sergey Levine. Model-agnostic meta-learning for fast adaptation of deep networks. In Proceedings of the 34th International Conference on Machine Learning - Volume 70, ICML’17, page 1126–1135. JMLR.org, 2017.   \n[58] Ethan Perez, Florian Strub, Harm de Vries, Vincent Dumoulin, and Aaron C. Courville. Film: Visual reasoning with a general conditioning layer. In AAAI, 2018.   \n[59] Angel X Chang, Thomas Funkhouser, Leonidas Guibas, Pat Hanrahan, Qixing Huang, Zimo Li, Silvio Savarese, Manolis Savva, Shuran Song, Hao Su, et al. Shapenet: An information-rich 3d model repository. arXiv preprint arXiv:1512.03012, 2015.   \n[60] Hiroharu Kato, Yoshitaka Ushiku, and Tatsuya Harada. Neural 3d mesh renderer. In Proc. CVPR, pages 3907–3916, 2018.   \n[61] Matthew Tancik, Pratul P Srinivasan, Ben Mildenhall, Sara Fridovich-Keil, Nithin Raghavan, Utkarsh Singhal, Ravi Ramamoorthi, Jonathan T Barron, and Ren Ng. Fourier features let networks learn high frequency functions in low dimensional domains. In Proc. NeurIPS, 2020. ",
+        "bbox": [
+            173,
+            244,
+            826,
+            915
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            68,
+            828,
+            916
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            90,
+            828,
+            606
+        ],
+        "page_idx": 12
+    }
+]

parse/train/ry18Ww5ee/ry18Ww5ee.md

@@ -0,0 +1,216 @@
+# HYPERBAND: BANDIT-BASED CONFIGURATION EVALUATION FOR HYPERPARAMETER OPTIMIZATION
+
+Lisha $\mathbf { L i } ^ { * }$ , Kevin Jamieson∗∗, Giulia DeSalvo†, Afshin Rostamizadeh‡, and Ameet Talwalkar∗
+
+∗UCLA, $^ { * * } \mathrm { U C }$ Berkeley, †NYU, and ‡Google {lishal,ameet}@cs.ucla.edu, kjamieson@berkeley.edu desalvo@cims.nyu.edu, rostami@google.com
+
+# ABSTRACT
+
+Performance of machine learning algorithms depends critically on identifying a good set of hyperparameters. While recent approaches use Bayesian Optimization to adaptively select configurations, we focus on speeding up random search through adaptive resource allocation. We present HYPERBAND, a novel algorithm for hyperparameter optimization that is simple, flexible, and theoretically sound. HYPERBAND is a principled early-stoppping method that adaptively allocates a predefined resource, e.g., iterations, data samples or number of features, to randomly sampled configurations. We compare HYPERBAND with popular Bayesian Optimization methods on several hyperparameter optimization problems. We observe that HYPERBAND can provide more than an order of magnitude speedups over competitors on a variety of neural network and kernel-based learning problems.
+
+# 1 INTRODUCTION
+
+The task of hyperparameter optimization is becoming increasingly important as modern data analysis pipelines grow in complexity. The quality of a predictive model critically depends on its hyperparameter configuration, but it is poorly understood how these hyperparameters interact with each other to affect the quality of the resulting model. Consequently, practitioners often default to either hand-tuning or automated brute-force methods like random search and grid search.
+
+In an effort to develop more efficient search methods, the problem of hyperparameter optimization has recently been dominated by Bayesian optimization methods (Snoek et al., 2012; Hutter et al., 2011; Bergstra et al., 2011) that focus on optimizing hyperparameter configuration selection. These methods aim to identify good configurations more quickly than standard baselines like random search by selecting configurations in an adaptive manner; see Figure 1(a). Existing empirical evidence suggests that these methods outperform random search (Thornton et al., 2013; Eggensperger et al., 2013; Snoek et al., 2015). However, these methods tackle a fundamentally challenging problem of simultaneously fitting and optimizing a high-dimensional, non-convex function with unknown smoothness, and possibly noisy evaluations. To overcome these difficulties, some Bayesian optimization methods resort to heuristics, at the expense of consistency guarantees, to model the objective function or speed up resource intensive subroutines.1 Moreover, these adaptive configuration selection methods are intrinsically sequential and thus difficult to parallelize.
+
+An orthogonal approach to hyperparameter optimization focuses on speeding up configuration evaluation; see Figure 1(b). These methods are adaptive in computation, allocating more resources to promising hyperparameter configurations while quickly eliminating poor ones. Resources can take various forms, including size of training set, number of features, or number of iterations for iterative algorithms. By adaptively allocating these resources, these methods aim to examine orders of magnitude more hyperparameter configurations than methods that uniformly train all configurations to completion, thereby quickly identifying good hyperparameters. While there are methods that combine Bayesian optimization with adaptive resource allocation (Swersky et al., 2013; 2014; Domhan et al., 2015), we focus on speeding up random search as it offers a simple, parallelizable, and theoretically principled launching point and is shown to outperform grid search (Bergstra & Bengio, 2012).
+
+![](images/ae6bdddace4d80ce3fb0a30136854610155426c3e0064679912f920bf5640551.jpg)  
+Figure 1: (a) The heatmap shows the validation error over a two dimensional search space, with red corresponding to areas with lower validation error, and putative configurations selected in a sequential manner as indicated by the numbers. (b) The plot shows the validation error as a function of the resources allocated to each configuration (i.e., each line in the plot). Configuration evaluation methods allocate more resources to promising configurations. (c) The validation loss as a function of total resources allocated for two configurations. The shaded areas bound the maximum distance from the terminal validation loss and monotonically decreases with the resource.
+
+Our novel configuration evaluation method, HYPERBAND, relies on a principled early-stopping strategy to allocate resources, allowing it to evaluate orders of magnitude more configurations than uniform allocation strategies. HYPERBAND is a general-purpose technique that makes minimal assumptions, unlike prior configuration evaluation approaches (Swersky et al., 2013; Domhan et al., 2015; Swersky et al., 2014; Gyorgy & Kocsis, 2011; Agarwal et al., 2011). In this work, we describe ¨ HYPERBAND, provide intuition for the algorithm through a detailed example, and present a wide range of empirical results comparing HYPERBAND with well established competitors. We also briefly describe the theoretical underpinnings of HYPERBAND, however a thorough theoretical treatment is beyond the scope of this paper and is deferred to Li et al. (2016).
+
+# 2 RELATED WORK
+
+Bayesian optimization techniques model the conditional probability $p ( f | \lambda )$ of a configuration’s performance on a metric $f$ given a set of hyperparameters $\lambda$ . For instance, SMAC uses random forests to model $p ( f | \lambda )$ as a Gaussian distribution (Hutter et al., 2011). TPE is a non-standard Bayesian optimization algorithm based on tree-structured Parzen density estimators (Bergstra et al., 2011). A third popular method, Spearmint, uses Gaussian processes (GP) to model $p ( f | \lambda )$ and performs slice sampling over the GP’s hyperparameters (Snoek et al., 2012).
+
+Adaptive configuration evaluation is not a new idea. Maron & Moore (1993) considered a setting where training time is negligible (e.g., $k$ -nearest-neighbor classification) and evaluation on a large validation set is accelerated by evaluating on an increasing subset of the validation set, stopping early configurations that are performing poorly. Since subsets of the validation set provide unbiased estimates of its expected performance, this is an instance of the stochastic best-arm identification problem for multi-armed bandits (see Jamieson & Nowak (2014) for a brief survey).
+
+In contrast, this paper assumes that evaluation time is negligible and the goal is to early-stop longrunning training procedures by evaluating partially trained models on the validation set. Previous approaches either require strong assumptions or use heuristics to perform adaptive resource allocation. Several works propose methods that make strong assumptions on the convergence behavior of training algorithms, providing theoretical performance guarantees under these assumptions (Gyorgy & Kocsis, ¨ 2011; Agarwal et al., 2011; Swersky et al., 2013; 2014; Domhan et al., 2015; Sabharwal et al., 2016). Unfortunately, these assumptions are often hard to verify, and empirical performance can drastically suffer when they are violated. One recent work of particular interest proposes a heuristic based on sequential analysis to determine stopping times for training configurations on increasing subsets of the data (Krueger et al., 2015). However, it has a few shortcomings: (1) it is designed to speedup multi-fold cross-validation and is not significantly faster than standard holdout, (2) it is not an anytime algorithm and requires the set of configurations to be evaluated as an input, and (3) the theoretical correctness and empirical performance of this method are highly dependent on a user-defined “safety-zone.”2 Lastly, in an effort avoid heuristics and strong assumptions, Sparks et al. (2015) proposed a halving style algorithm that did not require explicit convergence behavior, and Jamieson & Talwalkar (2015) analyzed a similar algorithm, providing theoretical guarantees and encouraging empirical results. Unfortunately, these halving style algorithms suffer from the $n$ vs $B / n$ issue which we will discuss in Section 3.
+
+Finally, Klein et al. (2016) recently introduced Fabolas, a Bayesian optimization method that combines adaptive selection and evaluation. Similar to Swersky et al. (2013; 2014), it models the conditional validation error as a Gaussian process using a kernel that captures the covariance with downsampling rate to allow for adaptive evaluation. While we intended to compare HYPERBAND with Fabolas, we encountered some technical difficulties when using the package3 and are working with the authors of Klein et al. (2016) to resolve the issues.
+
+# 3 HYPERBAND ALGORITHM
+
+HYPERBAND extends the SUCCESSIVEHALVING algorithm proposed for hyperparameter optimization in Jamieson & Talwalkar (2015) and calls it as a subroutine. The idea behind SUCCESSIVEHALVING follows directly from its name: uniformly allocate a budget to a set of hyperparameter configurations, evaluate the performance of all configurations, throw out the worst half, and repeat until one configurations remains. The algorithm allocates exponentially more resources to more promising configurations. Unfortunately, SUCCESSIVEHALVING requires the number of configurations $n$ as an input to the algorithm. Given some finite time budget $B$ (e.g. an hour of training time to choose a hyperparameter configuration), $B / n$ resources are allocated on average across the configurations. However, for a fixed $B$ , it is not clear a priori whether we should (a) consider many configurations (large $n$ ) with a small average training time; or (b) consider a small number of configurations (small $n$ ) with longer average training times.
+
+We use a simple example to better understand this tradeoff. Figure 1(c) shows the validation loss as a function of total resources allocated for two configurations with terminal validation losses $\nu _ { 1 }$ and $\nu _ { 2 }$ The shaded areas bound the maximum deviation from the terminal validation loss and will be referred to as “envelope” functions. It is possible to differentiate between the two configurations when the envelopes diverge. Simple arithmetic shows that this happens when the width of the envelopes is less than $\nu _ { 2 } - \nu _ { 1 }$ , i.e. when the intermediate losses are guaranteed to be less than $\frac { \nu _ { 2 } - \nu _ { 1 } } { 2 }$ away from the terminal losses. There are two takeaways from this observation: more resources are needed to differentiate between the two configurations when either (1) the envelope functions are wider or (2) the terminal losses are closer together.
+
+However, in practice, the optimal allocation strategy is unknown because we do not have knowledge of the envelope functions nor the distribution of terminal losses. Hence, if more resources are required before configurations can differentiate themselves in terms of quality (e.g., if an iterative training method converges very slowly for a given dataset or if randomly selected hyperparameter configurations perform similarly well) then it would be reasonable to work with a small number of configurations. In contrast, if the quality of a configuration is typically revealed using minimal resources (e.g., if iterative training methods converge very quickly for a given dataset or if randomly selected hyperparameter configurations are of low-quality with high probability) then $n$ is the bottleneck and we should choose $n$ to be large.
+
+# 3.1 HYPERBAND
+
+HYPERBAND, shown in Algorithm 1, addresses this “ $\cdot _ { n }$ versus $B / n ^ { \prime \prime }$ problem by considering several possible values of $n$ for a fixed $B$ , in essence performing a grid search over feasible value of $n$ . Associated with each value of $n$ is a minimum resource $r$ that is allocated to all configurations before some are discarded; a larger value of $n$ corresponds to a smaller $r$ and hence more aggressive early stopping. There are two components to HYPERBAND; (1) the inner loop invokes SUCCESSIVEHALVING for fixed values of $n$ and $r$ (lines 3-9) and (2) the outer loop which iterates over different values of $n$ and $r$ (lines 1-2). We will refer to each such run of SUCCESSIVEHALVING within HYPERBAND as a “bracket.” Each bracket is designed to use about $B$ total resources and corresponds to a different tradeoff between $n$ and $B / n$ . A single execution of HYPERBAND takes a finite number of iterations, and in practice can be repeated indefinitely.
+
+HYPERBAND requires two inputs (1) $R$ , the maximum amount of resource that can be allocated to a single configuration, and $( 2 ) \eta$ , an input that controls the proportion of configurations discarded in each round of SUCCESSIVEHALVING. The two inputs dictate how many different brackets are considered; specifically, $s _ { \operatorname* { m a x } } + 1$ different values for $n$ are considered with $s _ { \operatorname* { m a x } } = \lfloor \log _ { \eta } ( R ) \rfloor$ . HYPERBAND begins with the most aggressive bracket $s = s _ { \mathrm { m a x } }$ , which sets $n$ to maximize exploration, subject to the constraint that at least one configuration is allocated $R$ resources. Each subsequent bracket reduces $n$ by a factor of approximately $\eta$ until the final bracket, $s = 0$ , in which every configuration is allocated $R$ resources (this bracket simply performs classical random search). Hence, HYPERBAND performs a geometric search in the average budget per configuration to address the “ $n$ versus $B / n ^ { \prime \prime }$ problem, at the cost of approximately $s _ { \operatorname* { m a x } } + 1$ times more work than running SUCCESSIVEHALVING for a fixed $n$ . By doing so, HYPERBAND is able to exploit situations in which adaptive allocation works well, while protecting itself in situations where more conservative allocations are required.
+
+<table><tr><td colspan="2">Algorithm1: HYPERBAND algorithm for hyperparameter optimization.</td></tr><tr><td colspan="2">input : R,n (default n = 3) initialization: Smax = [logn(R)],B = (smax +1)R 1 for s ∈ {smax,Smax - 1,...,0} do n=[R(+1）], Bn</td></tr><tr><td>2 3 4</td><td>r=Rn-s // begin SuccEssIvEHALvING with (n,r) inner loop T=get_hyperparameter_configuration(n)</td></tr><tr><td>5 6</td><td>fori∈ {0,..,s} do ni = [nn-i]</td></tr><tr><td>7</td><td>ri=rni L={run_then_return_val_loss(t,ri):t∈T}</td></tr><tr><td>8 9</td><td>T=top_k(T,L,[ni/nl)</td></tr><tr><td></td><td></td></tr><tr><td>10 end</td><td>end</td></tr><tr><td></td><td></td></tr><tr><td></td><td>11 return Configuration with the smallest intermediate loss seen so far.</td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr></table>
+
+$R$ represents the maximum amount of resources that can be allocated to any given configuration. In most cases, there is a natural upper bound on the maximum budget per configuration that is often dictated by the resource type (e.g., training set size for dataset downsampling; limitations based on memory constraint for feature downsampling; rule of thumb regarding number of epochs when iteratively training neural networks). $R$ is also the number of configurations evaluated in the bracket that performs the most exploration, i.e $s = s _ { \mathrm { m a x } }$ . In practice one may want $n \leq n _ { \operatorname* { m a x } }$ to limit overhead associated with training many configurations on a small budget, i.e. costs associated with initialization, loading a model, and validation. In this case, set $s _ { \operatorname* { m a x } } = \mathrm { \bar { \lfloor } l o g } _ { \eta } ( n _ { \operatorname* { m a x } } ) \rfloor$ .
+
+The value of $\eta$ can be viewed as a knob that can be tuned based on practical user constraints. Larger values of $\eta$ correspond to a more aggressive elimination schedule and thus fewer rounds of elimination; specifically, each round retains $1 / \eta$ configurations for a total of $\lfloor \log _ { \eta } ( n ) \rfloor + 1$ rounds of elimination with $n$ configurations. If one wishes to receive a result faster at the cost of a sub-optimal asymptotic constant, one can increase $\eta$ to reduce the budget per bracket $B = ( \lfloor \log _ { \eta } ( R ) \rfloor \bar { + } 1 ) R$ We stress that results are not very sensitive to the choice of $\eta$ . In practice we suggest taking $\eta$ to be equal to 3 or 4.
+
+HYPERBAND requires the following methods to be defined for any given learning problem: get hyperparameter configuration $( n )$ returns a set of $n$ i.i.d. samples from some distribution defined over the hyperparameter configuration space; run then return val loss( $^ { \prime \prime }$ $r$ ) takes a hyperparameter configuration $\mathbf { \rho } ( t )$ and resource allocation $( r )$ and returns the validation loss after training for the allocated resources; and top k(configs, losses, $k$ ) takes a set of configurations as well as their associated losses and returns the top $k$ performing configurations.
+
+We next present a simple example to provide intuition. We work with the MNIST dataset and optimize hyperparameters for the LeNet convolutional neural network trained using mini-batch SGD. Our search space includes learning rate, batch size, and number of kernels for the two layers of the network as hyperparameters (details are shown in Table 3 in Appendix A).
+
+We further define the number of iterations as the resource to allocate, with one unit of resource corresponding to one epoch or a full pass over the dataset. We set $R$ to 81 and use the default value of $\eta = 3$ , resulting in $s _ { \operatorname* { m a x } } = 4$ and thus 5 brackets of SUCCESSIVEHALVING with different tradeoffs between $n$ and $B / n$ . The resources allocated within each bracket are displayed in Table 1.
+
+<table><tr><td>i</td><td>s=4 ni</td><td>Ti</td><td>s=3 ni</td><td>ri</td><td>s=2 ni</td><td>ri</td><td>s=1 ni ri</td><td></td><td>s=0 ni ri</td></tr><tr><td></td><td>81</td><td>1</td><td>27</td><td>3</td><td>9</td><td>9</td><td>6</td><td>27</td><td>5 81</td></tr><tr><td></td><td></td><td></td><td>93</td><td>9</td><td>3</td><td>27</td><td>2 81</td><td></td><td></td></tr><tr><td>01234</td><td></td><td></td><td></td><td>27</td><td>1</td><td>81</td><td></td><td></td><td></td></tr><tr><td></td><td></td><td>3927</td><td>1</td><td>81</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td>81</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr></table>
+
+Table 1: Values of $n _ { i }$ and $r _ { i }$ for the brackets of HYPERBAND when $R = 8 1$ and $\eta = 3$ .
+
+![](images/3d3c3917961981737c6cf8d68513c508b7d8dd1924bd15323af9a5378763c7bc.jpg)  
+Figure 2: Performance of individual brackets $s$ and HYPERBAND.
+
+Figure 2 compares the empirical performance of the different brackets of HYPERBAND if they were used separately, as well as standard HYPERBAND (all results are averaged over 70 trials). In practice we do not know a priori which bracket $s \in \{ 0 , \ldots , 4 \}$ will be most effective, and in this case neither the most $s = 4$ ) nor least aggressive $( s = 0$ ) setting is optimal. However, note that HYPERBAND does nearly as well as the optimal bracket $s = 3$ ) and vastly outperforms the baseline uniform allocation (i.e. random search), which is equivalent to bracket $s = 0$ .
+
+# 3.3 OVERVIEW OF THEORETICAL RESULTS
+
+Although a detailed theoretical analysis is beyond the scope of this paper, we provide an intuitive, high-level description of theoretical properties of HYPERBAND. Suppose there are $n$ configurations, each with a given terminal validation error $\nu _ { i }$ for $i = 1 , \ldots , n$ . Without loss of generality, index the configurations by performance so that $\nu _ { 1 }$ corresponds to the best performing configuration, $\nu _ { 2 }$ to the second best, and so on. Now consider the task of identifying the best configuration. The optimal strategy would allocate to each configuration $i$ the minimum resource required to distinguish it from $\nu _ { 1 }$ , i.e., enough so that the envelope functions depicted in Figure 1(c) bound the intermediate loss to be less than $\frac { \nu _ { i } - \nu _ { 1 } } { 2 }$ away from the terminal value. As shown in Jamieson & Talwalkar (2015) and Li et al. (2016), the budget required by SUCCESSIVEHALVING is in fact only a small factor away from this optimal approach because it capitalizes on configurations that are easy to distinguish from $\nu _ { 1 }$ In contrast, the naive uniform allocation strategy, which allocates $B / n$ to each configuration, has to allocate to every configuration the resource required to distinguish $\nu _ { 2 }$ from $\nu _ { 1 }$ .
+
+The relative size of the budget required for uniform allocation and SUCCESSIVEHALVING depends on the envelope functions bounding deviation from terminal losses as well as the distribution from which $\nu _ { i }$ ’s are drawn. The budget required for SUCCESSIVEHALVING is smaller when the optimal $n$ versus $B / n$ tradeoff requires fewer resources per configuration. Hence, if the envelope functions tighten quickly as a function of resource allocated, or the average distances between terminal losses is large, then SUCCESSIVEHALVING can be substantially faster than uniform allocation. Of course we do not have knowledge of either function in practice, so we will hedge our aggressiveness with HYPERBAND. Remarkably, despite having no knowledge of the envelope functions or the distribution of $\nu _ { i }$ ’s, HYPERBAND requires a budget that is only log factors larger than the optimal for SUCCESSIVEHALVING. See Li et al. (2016) for details.
+
+![](images/e015b5e58eee8fcf8bc732d9926d39f0a51b69fd4cc0c30a54d1f3a481a833ff.jpg)  
+Figure 3: Average test error across 10 trials is shown in all plots. Label “SMAC early” corresponds to SMAC with the early stopping criterion proposed in Domhan et al. (2015) and label “bracket $s = 4 ^ { \prime \prime }$ corresponds to repeating the most exploratory bracket of HYPERBAND.
+
+# 4 HYPERPARAMETER OPTIMIZATION EXPERIMENTS
+
+In this section, we evaluate the empirical behavior of HYPERBAND with iterations, data subsamples, and features as resources. For all experiments, we compare HYPERBAND with three well known Bayesian optimization algorithms — SMAC, TPE, and Spearmint. Additionally, we show results for SUCCESSIVEHALVING corresponding to repeating the most exploration bracket of HYPERBAND. Finally for all experiments, we benchmark against standard random search and random $\_ { 2 \times }$ , which is a variant of random search with twice the budget of other methods.
+
+# 4.1 EARLY STOPPING ITERATIVE ALGORITHMS FOR NEURAL NETWORKS
+
+We study a convolutional neural network with the same architecture as that used in Snoek et al. (2012) and Domhan et al. (2015) from cuda-convnet. The search spaces used in the two previous works differ, and we used a search space similar to that of Snoek et al. (2012) with 6 hyperparameters for stochastic gradient decent and 2 hyperparameters for the response normalization layers. In line with the two previous works, we used a batch size of 100 for all experiments. For these experiments, we also compare against a variant of SMAC named SMAC early that uses the early termination criterion proposed in Domhan et al. (2015) for neural networks. We view SMAC with early stopping to be a combination of adaptive configuration selection and configuration evaluation. See Appendix A for more details about the experimental setup.
+
+Datasets: We considered three image classification datasets: CIFAR-10 (Krizhevsky, 2009), rotated MNIST with background images (MRBI) (Larochelle et al., 2007), and Street View House Numbers (SVHN) (Netzer et al., 2011). CIFAR-10 and SVHN contain $3 2 \times 3 2$ RGB images while MRBI contains $2 8 \times 2 8$ grayscale images. The splits used for each dataset are as follows: (1) CIFAR-10 has 40k, 10k, and 10k instances; (2) MRBI has 10k, 2k, and $5 0 \mathrm { k }$ instances; and (3) SVHN has close to $6 0 0 \mathrm { k }$ , 6k, and $2 6 \mathrm { k }$ instances for training, validation, and test respectively. For all datasets, the only preprocessing performed on the raw images was demeaning.
+
+HYPERBAND Configuration: For these experiments, one unit of resource corresponds to $1 0 0 \mathrm { { m i n i } }$ batch iterations. For CIFAR-10 and MRBI, $R$ is set to 300 (or 30k total iterations). For SVHN, $R$ is set to 600 (or $6 0 \mathrm { k }$ total iterations) to accommodate the larger training set. $\eta$ was set to 4 for all experiments, resulting in 5 SUCCESSIVEHALVING brackets for HYPERBAND.
+
+Results: Ten independent trials were performed for each searcher. For CIFAR-10, the results in Figure 3(a) show that HYPERBAND is more than an order of magnitude faster than its competitors. In Figure 6 of Appendix A, we extend the $x$ -axis for CIFAR-10 out to $1 0 0 R$ . The results show that Bayesian optimization methods ultimately converge to similar errors as HYPERBAND. For MRBI, HYPERBAND is more than an order of magnitude faster than standard configuration selection approaches and $5 \times$ faster than SMAC with early stopping. For SVHN, while HYPERBAND finds a good configuration faster, Bayesian optimization methods are competitive and SMAC with early stopping outperforms HYPERBAND. This result demonstrates that there is merit to incorporating early stopping with configuration selection approaches.
+
+Across the three datasets, HYPERBAND and SMAC early are the only two methods that consistently outperform random $_ - 2 \times$ . On these datasets, HYPERBAND is over $2 0 \times$ faster than random search while SMAC early is $\leq 7 \times$ faster than random search within the evaluation window. In fact, the first result returned by HYPERBAND after using a budget of $5 R$ is often competitive with results returned by other searchers after using $5 0 R$ . Additionally, HYPERBAND is less variable than other searchers across trials, which is highly desirable in practice (see Appendix A for plots with error bars).
+
+For computationally expensive problems in high dimensional search spaces, it may make sense to just repeat the most exploratory brackets. Similarly, if meta-data is available about a problem or it is known that the quality of a configuration is evident after allocating a small amount of resource, then one should just repeat the most exploration bracket. Indeed, for these experiments, repeating the most exploratory bracket of HYPERBAND outperforms cycling through all the brackets. In fact, bracket $s = 4$ vastly outperforms all other methods on CIFAR-10 and MRBI and is nearly tied with SMAC early for first on SVHN.
+
+Finally, CIFAR-10 is a very popular dataset and state-of-the-art models achieve much better accuracy than what is shown in Figure 3. The difference in performance is mainly attributable to higher model complexities and data manipulation (i.e. using reflection or random cropping to artificially increase the dataset size). If we limit the comparison to published results that use the same architecture and exclude data manipulation, the best human expert result for the dataset is $18 \%$ error and hyperparameter optimized result is $1 5 . 0 \%$ for Snoek et al. $( 2 0 1 2 ) ^ { 4 }$ and $1 7 . 2 \%$ for Domhan et al. (2015). These results are better than our results on CIFAR-10 because they use $2 5 \%$ more data by including the validation set and also train for more epochs. The best model found by HYPERBAND achieved a test error of $1 7 . 0 \%$ when trained on the combined training and validation data for 300 epochs.
+
+# 4.2 DATA DOWNSAMPLING KERNEL REGULARIZED LEAST SQUARES CLASSIFICATION
+
+In this experiment, we use HYPERBAND with data samples as the resource to optimize the hyperparameters of a kernel-based classification task on CIFAR-10. We use the multi-class regularized least squares classification model which is known to have comparable performance to SVMs (Rifkin & Klautau, 2004; Agarwal et al., 2014) but can be trained significantly faster. The hyperparameters considered in the search space include preprocessing method, regularization, kernel type, kernel length scale, and other kernel specific hyperparameters (see Appendix A for more details). HYPERBAND is run with $\eta = 4$ and $R = 4 0 0$ , with each unit of resource representing 100 datapoints. Similar to previous experiments, these inputs result in a total of 5 brackets. Each hyperparameter optimization algorithm is run for ten trials on Amazon $^ { \mathrm { E C 2 ~ m 4 } . 2 \times 1 \mathrm { a r g e } }$ instances; for a given trial, HYPERBAND is allowed to run for two outer loops, bracket $s = 4$ is repeated 10 times, and all other searchers are run for 12 hours.
+
+Figure 4 shows that HYPERBAND returns a good configuration after just the first SUCCESSIVEHALVING bracket in approximately 20 minutes; other searchers fail to reach this error rate on average even after the entire 12 hours. Notably, HYPERBAND was able to evaluate over 250 configurations in this first bracket of SUCCESSIVEHALVING, while competitors were able to evaluate only three configurations in the same amount of time. Consequently, HYPERBAND is over $3 0 \times$ faster than Bayesian optimization methods and $7 0 \times$ faster than random search. Bracket $s = 4$ sightly outperforms HYPERBAND but the terminal performance for the two algorithms are the same. Random $2 \times$ is competitive with SMAC and TPE.
+
+# 4.3 FEATURE SUBSAMPLING TO SPEED UP APPROXIMATE KERNEL CLASSIFICATION
+
+We next demonstrate the performance of HYPERBAND when using features as a resource, focusing on random feature approximations for kernel methods. Features are randomly generated using the method described in Rahimi & Recht (2007) to approximate the RBF kernel, and these random features are then used as inputs to a ridge regression classifier. We consider hyperparameters of a random feature kernel approximation classifier trained on CIFAR-10, including preprocessing method, kernel length scale, and $l _ { 2 }$ penalty. We impose an upper bound of $1 0 0 \mathrm { k }$ random features for the kernel approximation so that the data will comfortably fit into a machine with 60GB of memory. Additionally, we set one unit of resource to be 100 features for an $R = 1 0 0 0$ , which gives 5 different brackets with $\eta = 4$ . Each searcher is run for 10 trials, with each trial lasting 12 hours on a n1-standard-16 machine from Google Cloud Compute. The results in Figure 5 show that HYPERBAND is around 6x faster than Bayesian methods and random search. HYPERBAND performs similarly to bracket $s = 4$ . Random $\_ { 2 \times }$ outperforms Bayesian optimization algorithms.
+
+![](images/36cad590c6ca90ff30afd753a183bf032971c1412bfd298ced67cec0d73ee2e7.jpg)  
+Figure 4: Average test error of the best kernel regularized least square classification model found by each searcher on CIFAR-10. The color coded dashed lines indicate when the last trial of a given searcher finished.
+
+![](images/bf3a98516a5ca827ad59b6ab39a6e7ee1b71fb7c18742e3ae9b77865cf43386e.jpg)  
+Figure 5: Average test error of the best random features model found by each searcher on CIFAR-10. The test error for HYPERBAND and bracket $s = 4$ are calculated in every evaluation instead of at the end of a bracket.
+
+# 4.4 EXPERIMENTAL DISCUSSION
+
+For a given $R$ , the most exploratory SUCCESSIVEHALVING round performed by HYPERBAND evaluates $\eta ^ { \mathrm { { \lfloor \log _ { \eta } ( R ) \rfloor } } }$ configurations using a budget of $( \lfloor \log _ { \eta } ( R ) \rfloor + 1 ) R$ , which gives an upper bound on the potential speedup over random search. If training time scales linearly with the resource, the maximum speedup offered by HYPERBAND compared to random search is $\frac { \eta ^ { \lfloor \log _ { \eta } ( R ) \rfloor } } { ( \lfloor \log _ { \eta } ( R ) \rfloor + 1 ) }$ . For the values of $\eta$ and $R$ used in our experiments, the maximum speedup over random search is approximately $5 0 \times$ given linear training time. However, we observe a range of speedups from $6 \times$ to $7 0 \times$ faster than random search. The differences in realized speedup can be explained by two factors: (1) the scaling properties of total evaluation time as a function of the allocated resource and (2) the difficulty of finding a good configuration.
+
+If training time is superlinear as a function of the resource, then HYPERBAND can offer higher speedups. More generally, if training scales like a polynomial of degree $p > 1$ , the maximum speedup of HYPERBAND over random search is approximately $\frac { \eta ^ { p - 1 } - 1 } { \eta ^ { p - 1 } } \eta ^ { \lfloor \log _ { \eta } ( R ) \rfloor }$ . Hence, higher speedups were observed for the the kernel least square classifier experiment discussed in Section 4.2 because the training time scaled quadratically as a function of the resource.
+
+If 10 randomly sampled configurations is sufficient to find a good hyperparameter setting, then the benefit of evaluating orders of magnitude more configurations is muted. Generally the difficulty of the problem scales with the dimension of the search space since coverage diminishes with dimensionality. For low dimensional problems, the number of configurations evaluated by random search and Bayesian methods is exponential in the number of dimensions so good coverage can be achieved; i.e. if $d = 3$ as in the features subsampling experiment, then $n = \bar { O ( 2 ^ { d } = 8 ) }$ . Hence, HYPERBAND is only $6 \times$ faster than random search on the feature subsampling experiment. For the neural network experiments however, we hypothesize that faster speedups are observed for HYPERBAND because the dimension of the search space is higher.
+
+# 5 FUTURE WORK
+
+We have introduced a novel bandit-based method for adaptive configuration evaluation with demonstrated competitive empirical performance. Future work involves exploring (i) embedding HYPERBAND into parallel and distributed computing environments; (ii) adjusting for training methods with different convergence rates; and (iii) combining HYPERBAND with non-random sampling methods.
+
+# REFERENCES
+
+omputationally budgeted model selection. In COLT, 2011.   
+A. Agarwal, S. Kakade, N. Karampatziakis, L. Song, and G. Valiant. Least squares revisited: Scalable approaches for multi-class prediction. In ICML, 2014.   
+J. Bergstra and Y. Bengio. Random search for hyper-parameter optimization. In JMLR, 2012.   
+J. Bergstra et al. Algorithms for hyper-parameter optimization. In NIPS, 2011.   
+T. Domhan, J. T. Springenberg, and F. Hutter. Speeding up automatic hyperparameter optimization of deep neural networks by extrapolation of learning curves. In IJCAI, 2015.   
+K. Eggensperger et al. Towards an empirical foundation for assessing bayesian optimization of hyperparameters. In NIPS Bayesian Optimization Workshop, 2013.   
+A. Gyorgy and L. Kocsis. Efficient multi-start strategies for local search algorithms. ¨ JAIR, 41, 2011.   
+F. Hutter, H. Hoos, and K. Leyton-Brown. Sequential model-based optimization for general algorithm configuration. In Proc. of LION-5, 2011.   
+K. Jamieson and R. Nowak. Best-arm identification algorithms for multi-armed bandits in the fixed confidence setting. In Information Sciences and Systems (CISS), 2014 48th Annual Conference on, pp. 1–6. IEEE, 2014.   
+K. Jamieson and A. Talwalkar. Non-stochastic best arm identification and hyperparameter optimization. In AISTATS, 2015.   
+A. Klein, S. Falkner, S. Bartels, P. Hennig, and F. Hutter. Fast bayesian optimization of machine learning hyperparameters on large datasets. arXiv preprint arXiv:1605.07079, 2016.   
+A. Krizhevsky. Learning multiple layers of features from tiny images. In Technical report, Department of Computer Science, Univsersity of Toronto, 2009.   
+T. Krueger, D. Panknin, and M. Braun. Fast cross-validation via sequential testing. Journal of Machine Learning Research, 16:1103–1155, 2015.   
+H. Larochelle et al. An empirical evaluation of deep architectures on problems with many factors of variation. In ICML, 2007.   
+L. Li, K. Jamieson, G. DeSalvo, A. Rostamizadeh, and A. Talwalkar. Hyperband: A novel banditbased approach to hyperparameter optimization. arXiv:1603.06560, 2016.   
+O. Maron and A. Moore. Hoeffding races: Accelerating model selection search for classification and function approximation. In NIPS, 1993.   
+Y. Netzer et al. Reading digits in natural images with unsupervised feature learning. In NIPS Workshop on Deep Learning and Unsupervised Feature Learning, 2011.   
+A. Rahimi and B. Recht. Random features for large-scale kernel machines. In NIPS, 2007.   
+G. Ratsch, T. Onoda, and K.R. M ¨ uller. Soft margins for adaboost. ¨ Machine Learning, 42:287–320, 2001.   
+R. Rifkin and A. Klautau. In defense of one-vs-all classification. JMLR, 2004.   
+A. Sabharwal, H. Samulowitz, and G. Tesauro. Selecting near-optimal learners via incremental data allocation. In AAAI, 2016.   
+P. Sermanet, S. Chintala, and Y. LeCun. Convolutional neural networks applied to house numbers digit classification. In ICPR, 2012.   
+J. Snoek, H. Larochelle, and R. Adams. Practical bayesian optimization of machine learning algorithms. In NIPS, 2012.
+
+J. Snoek et al. Bayesian optimization using deep neural networks. In ICML, 2015. E. Sparks, A. Talwalkar, D. Haas, M. J. Franklin, M. I. Jordan, and T. Kraska. Automating model search for large scale machine learning,. In Symposium on Cloud Computing, 2015. K. Swersky, J. Snoek, and R. Adams. Multi-task bayesian optimization. In NIPS, 2013. K. Swersky, J. Snoek, and R. P. Adams. Freeze-thaw bayesian optimization. arXiv:1406.3896, 2014. C. Thornton et al. Auto-weka: Combined selection and hyperparameter optimization of classification algorithms. In KDD, 2013.
+
+# A ADDITIONAL EXPERIMENTAL RESULTS
+
+In this section, we present a comparison of HYPERBAND with the CVST algorithm from Krueger et al. (2015) and provide additional details for experiments presented in Section 3 and 4.
+
+# A.1 COMPARISON WITH CVST
+
+The CVST algorithm from Krueger et al. (2015) focuses on speeding up standard k-fold crossvalidation. We did not include it as one of the competitors in Section 4 because the experiments we selected were too computational expensive for multi-fold cross-validation and CVST is not an any time algorithm. Nonetheless, the CVST algorithm is an interesting approach and was shown to have promising empirical performance in Krueger et al. (2015). Hence, we performed a small scale comparison modeled after their empirical studies between CVST and HYPERBAND.
+
+We replicated the classification experiments in Krueger et al. (2015) that train a support vector machine on the datasets from the IDA benchmark (Ratsch et al., 2001). All experiments were ¨ performed on Google Cloud Compute’s n1-standard-1 instances. Following Krueger et al. (2015), we evaluated HYPERBAND and CVST on the same 2d grid of 610 hyperparameters and recorded the best test error and duration for 50 trials . The only modification we made to their original experimental setup was the data splits; instead of half for test and half for training, we used 1/11th for test and 10/11th for training. HYPERBAND performed holdout evaluation using 1/10th of the training data as the validation set. We set $\eta = 3$ , and $R$ was set for each dataset so that a minimum resource of 50 datapoints is allocated to each configuration. Table 2 shows that CVST and HYPERBAND achieve comparable test errors (the differences are well within the error bars), while HYPERBAND is significantly faster than CVST on all datasets. More granularly, while CVST on average has slightly lower mean error, HYPERBAND is within $0 . 2 \%$ of CVST on 5 of the 7 datasets. Additionally, for each of the 7 datasets, HYPERBAND does as well as or better than CVST in over half of the trials.
+
+<table><tr><td rowspan="2">Dataset</td><td colspan="2">CVST</td><td colspan="2">Hyperband</td><td rowspan="2">Ratio Duration</td></tr><tr><td>Test Error</td><td>Duration</td><td>Test Error</td><td>Duration</td></tr><tr><td>banana</td><td>9.8%±1.6%</td><td>12.3±5.0</td><td>9.9%±1.5%</td><td>1.8±0.1</td><td>6.7±2.8</td></tr><tr><td>german</td><td>26.0%±4.5%</td><td>2.7±1.1</td><td>27.6%±4.8%</td><td>0.7±0.0</td><td>4.1±1.7</td></tr><tr><td>image</td><td>2.9%±1.1%</td><td>3.5±1.0</td><td>3.3%±1.4%</td><td>1.0±0.0</td><td>3.4±0.9</td></tr><tr><td>splice</td><td>8.6%±1.8%</td><td>10.6±3.1</td><td>8.7%±1.8%</td><td>3.9±0.1</td><td>2.7±0.8</td></tr><tr><td>ringnorm</td><td>1.4%±0.4%</td><td>21.3±2.3</td><td>1.5%±0.4%</td><td>6.5±0.3</td><td>3.3±0.4</td></tr><tr><td>twonorm</td><td>2.4%±0.5%</td><td>27.9±10.0</td><td>2.4%±0.5%</td><td>6.5±0.2</td><td>4.3±1.5</td></tr><tr><td>waveform</td><td>9.3%±1.3%</td><td>13.7±2.7</td><td>9.5%±1.3%</td><td>2.9±0.2</td><td>4.8±1.0</td></tr></table>
+
+Table 2: The test error and duration columns show the average value plus/minus the standard deviation across 50 trials. Duration is measured in minutes and indicates how long it took each method to evaluate the grid of 610 hyperparameters used in Krueger et al. (2015). The ratio column shows the ratio of the duration for HYPERBAND over that for CVST with associated standard deviation.
+
+# A.2 LENET EXPERIMENT
+
+We trained the LeNet convolutional neural network on MNIST using mini-batch SGD. Code is available for the network at http://deeplearning.net/tutorial/lenet.html. The search space for the LeNet example discussed in Section 3.2 is shown in Table 3.
+
+Table 3: Hyperparameter space for the LeNet application of Section 3.2. Note that the number of kernels in Layer-1 is upper bounded by the number of kernels in Layer-2.   
+
+<table><tr><td rowspan=1 colspan=1>Hyperparameter</td><td rowspan=1 colspan=1>Scale</td><td rowspan=1 colspan=1>Min</td><td rowspan=1 colspan=1>Max</td></tr><tr><td rowspan=1 colspan=1>Learning Rate</td><td rowspan=1 colspan=1>log</td><td rowspan=1 colspan=1>1e-3</td><td rowspan=1 colspan=1>1e-1</td></tr><tr><td rowspan=1 colspan=1>Batch size</td><td rowspan=1 colspan=1>log</td><td rowspan=1 colspan=1>1e1</td><td rowspan=1 colspan=1>1e3</td></tr><tr><td rowspan=1 colspan=1>Layer-2 Num Kernels (k2)</td><td rowspan=1 colspan=1>linear</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>60</td></tr><tr><td rowspan=1 colspan=1>Layer-1 Num Kernels (k1)</td><td rowspan=1 colspan=1>linear</td><td rowspan=1 colspan=1>5</td><td rowspan=1 colspan=1>k2</td></tr></table>
+
+# A.3 EXPERIMENTS USING ALEX KRIZHEVSKY’S CNN ARCHITECTURE
+
+For the experiments discussed in Section 4.1, the exact architecture used is the $1 8 \%$ model provided on cuda-convnet for CIFAR-10.5   
+Table 4: Hyperparameters and associated ranges for the three-layer convolutional network.   
+
+<table><tr><td>Hyperparameter</td><td>Scale</td><td>Min</td><td>Max</td></tr><tr><td>Learning Parameters</td><td></td><td></td><td></td></tr><tr><td>Initial Learning Rate</td><td>log</td><td>5*10-5</td><td>5</td></tr><tr><td>Conv1 l2 Penalty</td><td>log</td><td>5*10-5</td><td>5</td></tr><tr><td>Conv2 l2 Penalty</td><td>log</td><td>5*10-5</td><td>5</td></tr><tr><td>Conv3 l2 Penalty</td><td>10g</td><td>5*10-5</td><td>5</td></tr><tr><td>FC4 l2 Penalty</td><td>log</td><td>5*10-3</td><td>500</td></tr><tr><td>Learning Rate Reductions</td><td>integer</td><td>0</td><td>3</td></tr><tr><td>Local Response Normalization</td><td></td><td></td><td></td></tr><tr><td>Scale</td><td>log</td><td>5*10-6</td><td>5</td></tr><tr><td>Power</td><td>linear</td><td>0.01</td><td>3</td></tr></table>
+
+Search Space: The search space used for the experiments is shown in Table 4. The learning rate reductions hyperparameter indicates how many times the learning rate was reduced by a factor of 10 over the maximum iteration window. For example, on CIFAR-10, which has a maximum iteration of 30,000, a learning rate reduction of 2 corresponds to reducing the learning every 10,000 iterations, for a total of 2 reductions over the 30,000 iteration window. All hyperparameters with the exception of the learning rate decay reduction overlap with those in Snoek et al. (2012). Two hyperparameters in Snoek et al. (2012) were excluded from our experiments: (1) the width of the response normalization layer was excluded due to limitations of the Caffe framework and (2) the number of epochs was excluded because it is incompatible with dynamic resource allocation.
+
+Datasets: CIFAR-10 and SVHN contain $3 2 \times 3 2$ RGB images while MRBI contains $2 8 \times 2 8$ grayscale images. For all datasets, the only preprocessing performed on the raw images was demeaning. For CIFAR-10, the training (40,000 instances) and validation (10,000 instances) sets were sampled from data batches 1-5 with balanced classes. The original test set (10,000 instances) is used for testing. For MRBI, the training (10,000 instances) and validation (2,000 instances) sets were sampled from the original training set with balanced classes. The original test set (50,000 instances) is used for testing. Lastly, for SVHN, the train, validation, and test splits were created using the same procedure as that in Sermanet et al. (2012).
+
+Computational Considerations: The experiments took the equivalent of over 1 year of GPU hours on NVIDIA GRID K520 cards available on Amazon $^ { \mathrm { E C 2 } } ~ \mathfrak { g } ^ { 2 } \cdot 8 \times \mathrm { 1 a r g e }$ instances. We set a total budget constraint in terms of iterations instead of compute time to make comparisons hardware independent.6 Comparing progress by iterations instead of time ignores overhead costs not associated with training like cost of configuration selection for Bayesian methods and model initialization and validation costs for HYPERBAND. While overhead is hardware dependent, the overhead for HYPERBAND is below $5 \%$ on EC2 g2.8xlarge machines, so comparing progress by time passed would not impact results significantly.
+
+Due to the high computational cost of these experiments, we were not able to run all searchers out to convergence. However, we did double the budget for each trial of CIFAR-10 to allow for a comparison of the searchers as they near convergence. Figure 6 shows while Bayesian optimization methods achieve similar performance as HYPERBAND and SUCCESSIVEHALVING, it takes them much longer to achieve a comparable error rate.
+
+Comparison with Early Stopping: Adaptive allocation for hyperparameter optimization can be thought of as a form of early stopping where less promising configurations are halted before completion. Domhan et al. (2015) propose an early stopping method for neural networks and combine it with SMAC to speed up hyperparameter optimization. Their method stops training a configuration if the probability of the configuration beating the current best is below a specified threshold. This probability is estimated by extrapolating learning curves fit to the intermediate validation error losses of a configuration. If a configuration is terminated early, the predicted terminal value from the estimated learning curves is used as the validation error passed to the hyperparameter optimization algorithm. Hence, if the learning curve fit is poor, it could impact the performance of the configuration selection algorithm. While this approach is heuristic in nature, it does demonstrate promising empirical performance so we included SMAC with early termination as a competitor. We used the conservative termination criterion with default parameters and recorded the validation loss every 400 iterations and evaluated the termination criterion 3 times within the training period (every $^ { 8 \mathrm { k } }$ iterations for CIFAR-10 and MRBI and every 16k iterations for SVHN).7 Comparing performance by the total multiple of $R$ used is conservative because it does not account for the time spent fitting the learning curve in order to check the termination criterion.
+
+![](images/ae5a0b96eda6a0ac54c3a011acc3b8a86249325bfc21f84ae6dceea5ef706198.jpg)  
+Figure 6: Average test error across 10 trials is shown in all plots. Error bars indicate the maximum and minimum ranges of the test error corresponding to the model with the best validation error
+
+# A.4 KERNEL CLASSIFICATION EXPERIMENTS
+
+We trained the regularized least-squares classification model using a block coordinate descent solver. Our models take less than 10 minutes to train on CIFAR-10 using an 8 core machine, while the default SVM method in Scikit-learn is single core and takes hours. Table 5 shows the hyperparameters and associated ranges considered in the kernel least squares classification experiment discussed in
+
+Table 5: Hyperparameter space for kernel regularized least squares classification problem discussed in Section 4.2.   
+
+<table><tr><td rowspan=1 colspan=1>Hyperparameter</td><td rowspan=1 colspan=1>Type</td><td rowspan=1 colspan=2>Values</td></tr><tr><td rowspan=1 colspan=1>preprocessor</td><td rowspan=1 colspan=1>Categorical</td><td rowspan=1 colspan=2>min/max, standardize, normalize</td></tr><tr><td rowspan=1 colspan=1>kernel</td><td rowspan=1 colspan=1>Categorical</td><td rowspan=1 colspan=2>rbf, polynomial, sigmoid</td></tr><tr><td rowspan=1 colspan=1>C</td><td rowspan=1 colspan=1>Continuous</td><td rowspan=1 colspan=2>log [10-3,105]</td></tr><tr><td rowspan=1 colspan=1>gamma</td><td rowspan=1 colspan=1>Continuous</td><td rowspan=1 colspan=1>log</td><td rowspan=1 colspan=1>log [10-5,10]</td></tr><tr><td rowspan=1 colspan=1>degree</td><td rowspan=1 colspan=1>if kernel=poly</td><td rowspan=1 colspan=2>integer [2,5]</td></tr><tr><td rowspan=1 colspan=1>coef0</td><td rowspan=1 colspan=1>if kernel=poly,sigmoid</td><td rowspan=1 colspan=2>uniform [-1.0, 1.0]</td></tr></table>
+
+Section 4.2. The cost term C is divided by the number of samples so that the tradeoff between the squared error and the $l _ { 2 }$ penalty would remain constant as the resource increased (squared error is summed across observations and not averaged). The regularization term $\lambda$ is equal to the inverse of the scaled cost term C. Additionally, the average test error with associated minimum and maximum ranges across 10 trials are show in Figure 7.
+
+![](images/0537019f71cbec3f59ef7dd3d2c74807334937c8b1ed218639387bf20e2b6c40.jpg)  
+Figure 7: Average test error of the best kernel regularized least square classification model found by each searcher on CIFAR-10. The color coded dashed lines indicate when the last trial of a given searcher finished. Error bars correspond to observed minimum and maximum test error across 10 trials.
+
+Table 6: Hyperparameter space for random feature kernel approximation classification problem discussed in Section 4.3.   
+
+<table><tr><td rowspan=1 colspan=1>Hyperparameter</td><td rowspan=1 colspan=1>Type</td><td rowspan=1 colspan=1>Values</td></tr><tr><td rowspan=1 colspan=1>preprocessor</td><td rowspan=1 colspan=1>Categorical</td><td rowspan=1 colspan=1>none,min/max,standardize, normalize</td></tr><tr><td rowspan=1 colspan=1>入</td><td rowspan=1 colspan=1>Continuous</td><td rowspan=1 colspan=1>log [10-3,105]</td></tr><tr><td rowspan=1 colspan=1>gamma</td><td rowspan=1 colspan=1>Continuous</td><td rowspan=1 colspan=1>log[10-5,10]</td></tr></table>
+
+Table 6 shows the hyperparameters and associated ranges considered in the random features kernel approximation classification experiment discussed in Section 4.3. The regularization term $\lambda$ is divided by the number of features so that the tradeoff between the squared error and the $l _ { 2 }$ penalty would remain constant as the resource increased. Additionally, the average test error with associated minimum and maximum ranges across 10 trials are show in Figure 8.
+
+![](images/9dacf9af6c00852356c1671d0f5e9dfe221f9f91f66341195e6107fb62ae7dce.jpg)  
+Figure 8: Average test error of the best random features model found by each searcher on CIFAR-10. The test error for HYPERBAND and bracket $s = 4$ are calculated in every evaluation instead of at the end of a bracket. Error bars correspond to observed minimum and maximum test error across 10 trials.

parse/train/ry18Ww5ee/ry18Ww5ee_content_list.json

@@ -0,0 +1,1097 @@
+[
+    {
+        "type": "text",
+        "text": "HYPERBAND: BANDIT-BASED CONFIGURATION EVALUATION FOR HYPERPARAMETER OPTIMIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            828,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Lisha $\\mathbf { L i } ^ { * }$ , Kevin Jamieson∗∗, Giulia DeSalvo†, Afshin Rostamizadeh‡, and Ameet Talwalkar∗ ",
+        "bbox": [
+            184,
+            169,
+            828,
+            185
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "∗UCLA, $^ { * * } \\mathrm { U C }$ Berkeley, †NYU, and ‡Google {lishal,ameet}@cs.ucla.edu, kjamieson@berkeley.edu desalvo@cims.nyu.edu, rostami@google.com ",
+        "bbox": [
+            184,
+            185,
+            671,
+            227
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            263,
+            544,
+            279
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Performance of machine learning algorithms depends critically on identifying a good set of hyperparameters. While recent approaches use Bayesian Optimization to adaptively select configurations, we focus on speeding up random search through adaptive resource allocation. We present HYPERBAND, a novel algorithm for hyperparameter optimization that is simple, flexible, and theoretically sound. HYPERBAND is a principled early-stoppping method that adaptively allocates a predefined resource, e.g., iterations, data samples or number of features, to randomly sampled configurations. We compare HYPERBAND with popular Bayesian Optimization methods on several hyperparameter optimization problems. We observe that HYPERBAND can provide more than an order of magnitude speedups over competitors on a variety of neural network and kernel-based learning problems. ",
+        "bbox": [
+            233,
+            295,
+            766,
+            449
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            477,
+            336,
+            492
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The task of hyperparameter optimization is becoming increasingly important as modern data analysis pipelines grow in complexity. The quality of a predictive model critically depends on its hyperparameter configuration, but it is poorly understood how these hyperparameters interact with each other to affect the quality of the resulting model. Consequently, practitioners often default to either hand-tuning or automated brute-force methods like random search and grid search. ",
+        "bbox": [
+            174,
+            508,
+            825,
+            578
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In an effort to develop more efficient search methods, the problem of hyperparameter optimization has recently been dominated by Bayesian optimization methods (Snoek et al., 2012; Hutter et al., 2011; Bergstra et al., 2011) that focus on optimizing hyperparameter configuration selection. These methods aim to identify good configurations more quickly than standard baselines like random search by selecting configurations in an adaptive manner; see Figure 1(a). Existing empirical evidence suggests that these methods outperform random search (Thornton et al., 2013; Eggensperger et al., 2013; Snoek et al., 2015). However, these methods tackle a fundamentally challenging problem of simultaneously fitting and optimizing a high-dimensional, non-convex function with unknown smoothness, and possibly noisy evaluations. To overcome these difficulties, some Bayesian optimization methods resort to heuristics, at the expense of consistency guarantees, to model the objective function or speed up resource intensive subroutines.1 Moreover, these adaptive configuration selection methods are intrinsically sequential and thus difficult to parallelize. ",
+        "bbox": [
+            174,
+            585,
+            825,
+            752
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "An orthogonal approach to hyperparameter optimization focuses on speeding up configuration evaluation; see Figure 1(b). These methods are adaptive in computation, allocating more resources to promising hyperparameter configurations while quickly eliminating poor ones. Resources can take various forms, including size of training set, number of features, or number of iterations for iterative algorithms. By adaptively allocating these resources, these methods aim to examine orders of magnitude more hyperparameter configurations than methods that uniformly train all configurations to completion, thereby quickly identifying good hyperparameters. While there are methods that combine Bayesian optimization with adaptive resource allocation (Swersky et al., 2013; 2014; Domhan et al., 2015), we focus on speeding up random search as it offers a simple, parallelizable, and theoretically principled launching point and is shown to outperform grid search (Bergstra & Bengio, 2012). ",
+        "bbox": [
+            174,
+            758,
+            825,
+            898
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/ae6bdddace4d80ce3fb0a30136854610155426c3e0064679912f920bf5640551.jpg",
+        "image_caption": [
+            "Figure 1: (a) The heatmap shows the validation error over a two dimensional search space, with red corresponding to areas with lower validation error, and putative configurations selected in a sequential manner as indicated by the numbers. (b) The plot shows the validation error as a function of the resources allocated to each configuration (i.e., each line in the plot). Configuration evaluation methods allocate more resources to promising configurations. (c) The validation loss as a function of total resources allocated for two configurations. The shaded areas bound the maximum distance from the terminal validation loss and monotonically decreases with the resource. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            99,
+            812,
+            237
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our novel configuration evaluation method, HYPERBAND, relies on a principled early-stopping strategy to allocate resources, allowing it to evaluate orders of magnitude more configurations than uniform allocation strategies. HYPERBAND is a general-purpose technique that makes minimal assumptions, unlike prior configuration evaluation approaches (Swersky et al., 2013; Domhan et al., 2015; Swersky et al., 2014; Gyorgy & Kocsis, 2011; Agarwal et al., 2011). In this work, we describe ¨ HYPERBAND, provide intuition for the algorithm through a detailed example, and present a wide range of empirical results comparing HYPERBAND with well established competitors. We also briefly describe the theoretical underpinnings of HYPERBAND, however a thorough theoretical treatment is beyond the scope of this paper and is deferred to Li et al. (2016). ",
+        "bbox": [
+            174,
+            378,
+            825,
+            506
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            529,
+            344,
+            545
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Bayesian optimization techniques model the conditional probability $p ( f | \\lambda )$ of a configuration’s performance on a metric $f$ given a set of hyperparameters $\\lambda$ . For instance, SMAC uses random forests to model $p ( f | \\lambda )$ as a Gaussian distribution (Hutter et al., 2011). TPE is a non-standard Bayesian optimization algorithm based on tree-structured Parzen density estimators (Bergstra et al., 2011). A third popular method, Spearmint, uses Gaussian processes (GP) to model $p ( f | \\lambda )$ and performs slice sampling over the GP’s hyperparameters (Snoek et al., 2012). ",
+        "bbox": [
+            174,
+            561,
+            825,
+            646
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Adaptive configuration evaluation is not a new idea. Maron & Moore (1993) considered a setting where training time is negligible (e.g., $k$ -nearest-neighbor classification) and evaluation on a large validation set is accelerated by evaluating on an increasing subset of the validation set, stopping early configurations that are performing poorly. Since subsets of the validation set provide unbiased estimates of its expected performance, this is an instance of the stochastic best-arm identification problem for multi-armed bandits (see Jamieson & Nowak (2014) for a brief survey). ",
+        "bbox": [
+            174,
+            652,
+            825,
+            736
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In contrast, this paper assumes that evaluation time is negligible and the goal is to early-stop longrunning training procedures by evaluating partially trained models on the validation set. Previous approaches either require strong assumptions or use heuristics to perform adaptive resource allocation. Several works propose methods that make strong assumptions on the convergence behavior of training algorithms, providing theoretical performance guarantees under these assumptions (Gyorgy & Kocsis, ¨ 2011; Agarwal et al., 2011; Swersky et al., 2013; 2014; Domhan et al., 2015; Sabharwal et al., 2016). Unfortunately, these assumptions are often hard to verify, and empirical performance can drastically suffer when they are violated. One recent work of particular interest proposes a heuristic based on sequential analysis to determine stopping times for training configurations on increasing subsets of the data (Krueger et al., 2015). However, it has a few shortcomings: (1) it is designed to speedup multi-fold cross-validation and is not significantly faster than standard holdout, (2) it is not an anytime algorithm and requires the set of configurations to be evaluated as an input, and (3) the theoretical correctness and empirical performance of this method are highly dependent on a user-defined “safety-zone.”2 Lastly, in an effort avoid heuristics and strong assumptions, Sparks et al. (2015) proposed a halving style algorithm that did not require explicit convergence behavior, and Jamieson & Talwalkar (2015) analyzed a similar algorithm, providing theoretical guarantees and encouraging empirical results. Unfortunately, these halving style algorithms suffer from the $n$ vs $B / n$ issue which we will discuss in Section 3. ",
+        "bbox": [
+            174,
+            743,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            172
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Finally, Klein et al. (2016) recently introduced Fabolas, a Bayesian optimization method that combines adaptive selection and evaluation. Similar to Swersky et al. (2013; 2014), it models the conditional validation error as a Gaussian process using a kernel that captures the covariance with downsampling rate to allow for adaptive evaluation. While we intended to compare HYPERBAND with Fabolas, we encountered some technical difficulties when using the package3 and are working with the authors of Klein et al. (2016) to resolve the issues. ",
+        "bbox": [
+            174,
+            180,
+            825,
+            263
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 HYPERBAND ALGORITHM ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            285,
+            421,
+            300
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "HYPERBAND extends the SUCCESSIVEHALVING algorithm proposed for hyperparameter optimization in Jamieson & Talwalkar (2015) and calls it as a subroutine. The idea behind SUCCESSIVEHALVING follows directly from its name: uniformly allocate a budget to a set of hyperparameter configurations, evaluate the performance of all configurations, throw out the worst half, and repeat until one configurations remains. The algorithm allocates exponentially more resources to more promising configurations. Unfortunately, SUCCESSIVEHALVING requires the number of configurations $n$ as an input to the algorithm. Given some finite time budget $B$ (e.g. an hour of training time to choose a hyperparameter configuration), $B / n$ resources are allocated on average across the configurations. However, for a fixed $B$ , it is not clear a priori whether we should (a) consider many configurations (large $n$ ) with a small average training time; or (b) consider a small number of configurations (small $n$ ) with longer average training times. ",
+        "bbox": [
+            174,
+            315,
+            825,
+            469
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We use a simple example to better understand this tradeoff. Figure 1(c) shows the validation loss as a function of total resources allocated for two configurations with terminal validation losses $\\nu _ { 1 }$ and $\\nu _ { 2 }$ The shaded areas bound the maximum deviation from the terminal validation loss and will be referred to as “envelope” functions. It is possible to differentiate between the two configurations when the envelopes diverge. Simple arithmetic shows that this happens when the width of the envelopes is less than $\\nu _ { 2 } - \\nu _ { 1 }$ , i.e. when the intermediate losses are guaranteed to be less than $\\frac { \\nu _ { 2 } - \\nu _ { 1 } } { 2 }$ away from the terminal losses. There are two takeaways from this observation: more resources are needed to differentiate between the two configurations when either (1) the envelope functions are wider or (2) the terminal losses are closer together. ",
+        "bbox": [
+            174,
+            476,
+            825,
+            602
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "However, in practice, the optimal allocation strategy is unknown because we do not have knowledge of the envelope functions nor the distribution of terminal losses. Hence, if more resources are required before configurations can differentiate themselves in terms of quality (e.g., if an iterative training method converges very slowly for a given dataset or if randomly selected hyperparameter configurations perform similarly well) then it would be reasonable to work with a small number of configurations. In contrast, if the quality of a configuration is typically revealed using minimal resources (e.g., if iterative training methods converge very quickly for a given dataset or if randomly selected hyperparameter configurations are of low-quality with high probability) then $n$ is the bottleneck and we should choose $n$ to be large. ",
+        "bbox": [
+            174,
+            608,
+            825,
+            733
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 HYPERBAND ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            751,
+            303,
+            765
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "HYPERBAND, shown in Algorithm 1, addresses this “ $\\cdot _ { n }$ versus $B / n ^ { \\prime \\prime }$ problem by considering several possible values of $n$ for a fixed $B$ , in essence performing a grid search over feasible value of $n$ . Associated with each value of $n$ is a minimum resource $r$ that is allocated to all configurations before some are discarded; a larger value of $n$ corresponds to a smaller $r$ and hence more aggressive early stopping. There are two components to HYPERBAND; (1) the inner loop invokes SUCCESSIVEHALVING for fixed values of $n$ and $r$ (lines 3-9) and (2) the outer loop which iterates over different values of $n$ and $r$ (lines 1-2). We will refer to each such run of SUCCESSIVEHALVING within HYPERBAND as a “bracket.” Each bracket is designed to use about $B$ total resources and corresponds to a different tradeoff between $n$ and $B / n$ . A single execution of HYPERBAND takes a finite number of iterations, and in practice can be repeated indefinitely. ",
+        "bbox": [
+            174,
+            776,
+            825,
+            861
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "HYPERBAND requires two inputs (1) $R$ , the maximum amount of resource that can be allocated to a single configuration, and $( 2 ) \\eta$ , an input that controls the proportion of configurations discarded in each round of SUCCESSIVEHALVING. The two inputs dictate how many different brackets are considered; specifically, $s _ { \\operatorname* { m a x } } + 1$ different values for $n$ are considered with $s _ { \\operatorname* { m a x } } = \\lfloor \\log _ { \\eta } ( R ) \\rfloor$ . HYPERBAND begins with the most aggressive bracket $s = s _ { \\mathrm { m a x } }$ , which sets $n$ to maximize exploration, subject to the constraint that at least one configuration is allocated $R$ resources. Each subsequent bracket reduces $n$ by a factor of approximately $\\eta$ until the final bracket, $s = 0$ , in which every configuration is allocated $R$ resources (this bracket simply performs classical random search). Hence, HYPERBAND performs a geometric search in the average budget per configuration to address the “ $n$ versus $B / n ^ { \\prime \\prime }$ problem, at the cost of approximately $s _ { \\operatorname* { m a x } } + 1$ times more work than running SUCCESSIVEHALVING for a fixed $n$ . By doing so, HYPERBAND is able to exploit situations in which adaptive allocation works well, while protecting itself in situations where more conservative allocations are required. ",
+        "bbox": [
+            173,
+            166,
+            826,
+            333
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/f7e9112071dff565d9c3e9a959f21115de8abce07abac47c832a37834b3bdab2.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">Algorithm1: HYPERBAND algorithm for hyperparameter optimization.</td></tr><tr><td colspan=\"2\">input : R,n (default n = 3) initialization: Smax = [logn(R)],B = (smax +1)R 1 for s ∈ {smax,Smax - 1,...,0} do n=[R(+1）], Bn</td></tr><tr><td>2 3 4</td><td>r=Rn-s // begin SuccEssIvEHALvING with (n,r) inner loop T=get_hyperparameter_configuration(n)</td></tr><tr><td>5 6</td><td>fori∈ {0,..,s} do ni = [nn-i]</td></tr><tr><td>7</td><td>ri=rni L={run_then_return_val_loss(t,ri):t∈T}</td></tr><tr><td>8 9</td><td>T=top_k(T,L,[ni/nl)</td></tr><tr><td></td><td></td></tr><tr><td>10 end</td><td>end</td></tr><tr><td></td><td></td></tr><tr><td></td><td>11 return Configuration with the smallest intermediate loss seen so far.</td></tr><tr><td></td><td></td></tr><tr><td></td><td></td></tr></table>",
+        "bbox": [
+            174,
+            359,
+            823,
+            589
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "$R$ represents the maximum amount of resources that can be allocated to any given configuration. In most cases, there is a natural upper bound on the maximum budget per configuration that is often dictated by the resource type (e.g., training set size for dataset downsampling; limitations based on memory constraint for feature downsampling; rule of thumb regarding number of epochs when iteratively training neural networks). $R$ is also the number of configurations evaluated in the bracket that performs the most exploration, i.e $s = s _ { \\mathrm { m a x } }$ . In practice one may want $n \\leq n _ { \\operatorname* { m a x } }$ to limit overhead associated with training many configurations on a small budget, i.e. costs associated with initialization, loading a model, and validation. In this case, set $s _ { \\operatorname* { m a x } } = \\mathrm { \\bar { \\lfloor } l o g } _ { \\eta } ( n _ { \\operatorname* { m a x } } ) \\rfloor$ . ",
+        "bbox": [
+            174,
+            617,
+            825,
+            729
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The value of $\\eta$ can be viewed as a knob that can be tuned based on practical user constraints. Larger values of $\\eta$ correspond to a more aggressive elimination schedule and thus fewer rounds of elimination; specifically, each round retains $1 / \\eta$ configurations for a total of $\\lfloor \\log _ { \\eta } ( n ) \\rfloor + 1$ rounds of elimination with $n$ configurations. If one wishes to receive a result faster at the cost of a sub-optimal asymptotic constant, one can increase $\\eta$ to reduce the budget per bracket $B = ( \\lfloor \\log _ { \\eta } ( R ) \\rfloor \\bar { + } 1 ) R$ We stress that results are not very sensitive to the choice of $\\eta$ . In practice we suggest taking $\\eta$ to be equal to 3 or 4. ",
+        "bbox": [
+            174,
+            736,
+            825,
+            833
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "HYPERBAND requires the following methods to be defined for any given learning problem: get hyperparameter configuration $( n )$ returns a set of $n$ i.i.d. samples from some distribution defined over the hyperparameter configuration space; run then return val loss( $^ { \\prime \\prime }$ $r$ ) takes a hyperparameter configuration $\\mathbf { \\rho } ( t )$ and resource allocation $( r )$ and returns the validation loss after training for the allocated resources; and top k(configs, losses, $k$ ) takes a set of configurations as well as their associated losses and returns the top $k$ performing configurations. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We next present a simple example to provide intuition. We work with the MNIST dataset and optimize hyperparameters for the LeNet convolutional neural network trained using mini-batch SGD. Our search space includes learning rate, batch size, and number of kernels for the two layers of the network as hyperparameters (details are shown in Table 3 in Appendix A). ",
+        "bbox": [
+            174,
+            133,
+            823,
+            189
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We further define the number of iterations as the resource to allocate, with one unit of resource corresponding to one epoch or a full pass over the dataset. We set $R$ to 81 and use the default value of $\\eta = 3$ , resulting in $s _ { \\operatorname* { m a x } } = 4$ and thus 5 brackets of SUCCESSIVEHALVING with different tradeoffs between $n$ and $B / n$ . The resources allocated within each bracket are displayed in Table 1. ",
+        "bbox": [
+            173,
+            196,
+            825,
+            253
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/23cf1c410953dacf182dacef88892ebee23752c2ae55308f41860114276d163e.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 1: Values of $n _ { i }$ and $r _ { i }$ for the brackets of HYPERBAND when $R = 8 1$ and $\\eta = 3$ . "
+        ],
+        "table_body": "<table><tr><td>i</td><td>s=4 ni</td><td>Ti</td><td>s=3 ni</td><td>ri</td><td>s=2 ni</td><td>ri</td><td>s=1 ni ri</td><td></td><td>s=0 ni ri</td></tr><tr><td></td><td>81</td><td>1</td><td>27</td><td>3</td><td>9</td><td>9</td><td>6</td><td>27</td><td>5 81</td></tr><tr><td></td><td></td><td></td><td>93</td><td>9</td><td>3</td><td>27</td><td>2 81</td><td></td><td></td></tr><tr><td>01234</td><td></td><td></td><td></td><td>27</td><td>1</td><td>81</td><td></td><td></td><td></td></tr><tr><td></td><td></td><td>3927</td><td>1</td><td>81</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td>81</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr></table>",
+        "bbox": [
+            174,
+            291,
+            558,
+            392
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/3d3c3917961981737c6cf8d68513c508b7d8dd1924bd15323af9a5378763c7bc.jpg",
+        "image_caption": [
+            "Figure 2: Performance of individual brackets $s$ and HYPERBAND. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            602,
+            267,
+            794,
+            414
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Figure 2 compares the empirical performance of the different brackets of HYPERBAND if they were used separately, as well as standard HYPERBAND (all results are averaged over 70 trials). In practice we do not know a priori which bracket $s \\in \\{ 0 , \\ldots , 4 \\}$ will be most effective, and in this case neither the most $s = 4$ ) nor least aggressive $( s = 0$ ) setting is optimal. However, note that HYPERBAND does nearly as well as the optimal bracket $s = 3$ ) and vastly outperforms the baseline uniform allocation (i.e. random search), which is equivalent to bracket $s = 0$ . ",
+        "bbox": [
+            173,
+            468,
+            825,
+            553
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 OVERVIEW OF THEORETICAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            580,
+            480,
+            594
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Although a detailed theoretical analysis is beyond the scope of this paper, we provide an intuitive, high-level description of theoretical properties of HYPERBAND. Suppose there are $n$ configurations, each with a given terminal validation error $\\nu _ { i }$ for $i = 1 , \\ldots , n$ . Without loss of generality, index the configurations by performance so that $\\nu _ { 1 }$ corresponds to the best performing configuration, $\\nu _ { 2 }$ to the second best, and so on. Now consider the task of identifying the best configuration. The optimal strategy would allocate to each configuration $i$ the minimum resource required to distinguish it from $\\nu _ { 1 }$ , i.e., enough so that the envelope functions depicted in Figure 1(c) bound the intermediate loss to be less than $\\frac { \\nu _ { i } - \\nu _ { 1 } } { 2 }$ away from the terminal value. As shown in Jamieson & Talwalkar (2015) and Li et al. (2016), the budget required by SUCCESSIVEHALVING is in fact only a small factor away from this optimal approach because it capitalizes on configurations that are easy to distinguish from $\\nu _ { 1 }$ In contrast, the naive uniform allocation strategy, which allocates $B / n$ to each configuration, has to allocate to every configuration the resource required to distinguish $\\nu _ { 2 }$ from $\\nu _ { 1 }$ . ",
+        "bbox": [
+            174,
+            611,
+            825,
+            777
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The relative size of the budget required for uniform allocation and SUCCESSIVEHALVING depends on the envelope functions bounding deviation from terminal losses as well as the distribution from which $\\nu _ { i }$ ’s are drawn. The budget required for SUCCESSIVEHALVING is smaller when the optimal $n$ versus $B / n$ tradeoff requires fewer resources per configuration. Hence, if the envelope functions tighten quickly as a function of resource allocated, or the average distances between terminal losses is large, then SUCCESSIVEHALVING can be substantially faster than uniform allocation. Of course we do not have knowledge of either function in practice, so we will hedge our aggressiveness with HYPERBAND. Remarkably, despite having no knowledge of the envelope functions or the distribution of $\\nu _ { i }$ ’s, HYPERBAND requires a budget that is only log factors larger than the optimal for SUCCESSIVEHALVING. See Li et al. (2016) for details. ",
+        "bbox": [
+            173,
+            785,
+            825,
+            922
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/e015b5e58eee8fcf8bc732d9926d39f0a51b69fd4cc0c30a54d1f3a481a833ff.jpg",
+        "image_caption": [
+            "Figure 3: Average test error across 10 trials is shown in all plots. Label “SMAC early” corresponds to SMAC with the early stopping criterion proposed in Domhan et al. (2015) and label “bracket $s = 4 ^ { \\prime \\prime }$ corresponds to repeating the most exploratory bracket of HYPERBAND. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            98,
+            807,
+            247
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 HYPERPARAMETER OPTIMIZATION EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            333,
+            622,
+            349
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we evaluate the empirical behavior of HYPERBAND with iterations, data subsamples, and features as resources. For all experiments, we compare HYPERBAND with three well known Bayesian optimization algorithms — SMAC, TPE, and Spearmint. Additionally, we show results for SUCCESSIVEHALVING corresponding to repeating the most exploration bracket of HYPERBAND. Finally for all experiments, we benchmark against standard random search and random $\\_ { 2 \\times }$ , which is a variant of random search with twice the budget of other methods. ",
+        "bbox": [
+            174,
+            366,
+            826,
+            450
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 EARLY STOPPING ITERATIVE ALGORITHMS FOR NEURAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            473,
+            687,
+            486
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We study a convolutional neural network with the same architecture as that used in Snoek et al. (2012) and Domhan et al. (2015) from cuda-convnet. The search spaces used in the two previous works differ, and we used a search space similar to that of Snoek et al. (2012) with 6 hyperparameters for stochastic gradient decent and 2 hyperparameters for the response normalization layers. In line with the two previous works, we used a batch size of 100 for all experiments. For these experiments, we also compare against a variant of SMAC named SMAC early that uses the early termination criterion proposed in Domhan et al. (2015) for neural networks. We view SMAC with early stopping to be a combination of adaptive configuration selection and configuration evaluation. See Appendix A for more details about the experimental setup. ",
+        "bbox": [
+            174,
+            498,
+            825,
+            625
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Datasets: We considered three image classification datasets: CIFAR-10 (Krizhevsky, 2009), rotated MNIST with background images (MRBI) (Larochelle et al., 2007), and Street View House Numbers (SVHN) (Netzer et al., 2011). CIFAR-10 and SVHN contain $3 2 \\times 3 2$ RGB images while MRBI contains $2 8 \\times 2 8$ grayscale images. The splits used for each dataset are as follows: (1) CIFAR-10 has 40k, 10k, and 10k instances; (2) MRBI has 10k, 2k, and $5 0 \\mathrm { k }$ instances; and (3) SVHN has close to $6 0 0 \\mathrm { k }$ , 6k, and $2 6 \\mathrm { k }$ instances for training, validation, and test respectively. For all datasets, the only preprocessing performed on the raw images was demeaning. ",
+        "bbox": [
+            173,
+            631,
+            825,
+            728
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "HYPERBAND Configuration: For these experiments, one unit of resource corresponds to $1 0 0 \\mathrm { { m i n i } }$ batch iterations. For CIFAR-10 and MRBI, $R$ is set to 300 (or 30k total iterations). For SVHN, $R$ is set to 600 (or $6 0 \\mathrm { k }$ total iterations) to accommodate the larger training set. $\\eta$ was set to 4 for all experiments, resulting in 5 SUCCESSIVEHALVING brackets for HYPERBAND. ",
+        "bbox": [
+            174,
+            736,
+            825,
+            791
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Results: Ten independent trials were performed for each searcher. For CIFAR-10, the results in Figure 3(a) show that HYPERBAND is more than an order of magnitude faster than its competitors. In Figure 6 of Appendix A, we extend the $x$ -axis for CIFAR-10 out to $1 0 0 R$ . The results show that Bayesian optimization methods ultimately converge to similar errors as HYPERBAND. For MRBI, HYPERBAND is more than an order of magnitude faster than standard configuration selection approaches and $5 \\times$ faster than SMAC with early stopping. For SVHN, while HYPERBAND finds a good configuration faster, Bayesian optimization methods are competitive and SMAC with early stopping outperforms HYPERBAND. This result demonstrates that there is merit to incorporating early stopping with configuration selection approaches. ",
+        "bbox": [
+            173,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Across the three datasets, HYPERBAND and SMAC early are the only two methods that consistently outperform random $_ - 2 \\times$ . On these datasets, HYPERBAND is over $2 0 \\times$ faster than random search while SMAC early is $\\leq 7 \\times$ faster than random search within the evaluation window. In fact, the first result returned by HYPERBAND after using a budget of $5 R$ is often competitive with results returned by other searchers after using $5 0 R$ . Additionally, HYPERBAND is less variable than other searchers across trials, which is highly desirable in practice (see Appendix A for plots with error bars). ",
+        "bbox": [
+            174,
+            103,
+            823,
+            188
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For computationally expensive problems in high dimensional search spaces, it may make sense to just repeat the most exploratory brackets. Similarly, if meta-data is available about a problem or it is known that the quality of a configuration is evident after allocating a small amount of resource, then one should just repeat the most exploration bracket. Indeed, for these experiments, repeating the most exploratory bracket of HYPERBAND outperforms cycling through all the brackets. In fact, bracket $s = 4$ vastly outperforms all other methods on CIFAR-10 and MRBI and is nearly tied with SMAC early for first on SVHN. ",
+        "bbox": [
+            174,
+            194,
+            825,
+            291
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Finally, CIFAR-10 is a very popular dataset and state-of-the-art models achieve much better accuracy than what is shown in Figure 3. The difference in performance is mainly attributable to higher model complexities and data manipulation (i.e. using reflection or random cropping to artificially increase the dataset size). If we limit the comparison to published results that use the same architecture and exclude data manipulation, the best human expert result for the dataset is $18 \\%$ error and hyperparameter optimized result is $1 5 . 0 \\%$ for Snoek et al. $( 2 0 1 2 ) ^ { 4 }$ and $1 7 . 2 \\%$ for Domhan et al. (2015). These results are better than our results on CIFAR-10 because they use $2 5 \\%$ more data by including the validation set and also train for more epochs. The best model found by HYPERBAND achieved a test error of $1 7 . 0 \\%$ when trained on the combined training and validation data for 300 epochs. ",
+        "bbox": [
+            174,
+            299,
+            825,
+            424
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 DATA DOWNSAMPLING KERNEL REGULARIZED LEAST SQUARES CLASSIFICATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            444,
+            772,
+            457
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this experiment, we use HYPERBAND with data samples as the resource to optimize the hyperparameters of a kernel-based classification task on CIFAR-10. We use the multi-class regularized least squares classification model which is known to have comparable performance to SVMs (Rifkin & Klautau, 2004; Agarwal et al., 2014) but can be trained significantly faster. The hyperparameters considered in the search space include preprocessing method, regularization, kernel type, kernel length scale, and other kernel specific hyperparameters (see Appendix A for more details). HYPERBAND is run with $\\eta = 4$ and $R = 4 0 0$ , with each unit of resource representing 100 datapoints. Similar to previous experiments, these inputs result in a total of 5 brackets. Each hyperparameter optimization algorithm is run for ten trials on Amazon $^ { \\mathrm { E C 2 ~ m 4 } . 2 \\times 1 \\mathrm { a r g e } }$ instances; for a given trial, HYPERBAND is allowed to run for two outer loops, bracket $s = 4$ is repeated 10 times, and all other searchers are run for 12 hours. ",
+        "bbox": [
+            174,
+            469,
+            826,
+            622
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Figure 4 shows that HYPERBAND returns a good configuration after just the first SUCCESSIVEHALVING bracket in approximately 20 minutes; other searchers fail to reach this error rate on average even after the entire 12 hours. Notably, HYPERBAND was able to evaluate over 250 configurations in this first bracket of SUCCESSIVEHALVING, while competitors were able to evaluate only three configurations in the same amount of time. Consequently, HYPERBAND is over $3 0 \\times$ faster than Bayesian optimization methods and $7 0 \\times$ faster than random search. Bracket $s = 4$ sightly outperforms HYPERBAND but the terminal performance for the two algorithms are the same. Random $2 \\times$ is competitive with SMAC and TPE. ",
+        "bbox": [
+            174,
+            628,
+            825,
+            739
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 FEATURE SUBSAMPLING TO SPEED UP APPROXIMATE KERNEL CLASSIFICATION ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            761,
+            758,
+            773
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We next demonstrate the performance of HYPERBAND when using features as a resource, focusing on random feature approximations for kernel methods. Features are randomly generated using the method described in Rahimi & Recht (2007) to approximate the RBF kernel, and these random features are then used as inputs to a ridge regression classifier. We consider hyperparameters of a random feature kernel approximation classifier trained on CIFAR-10, including preprocessing method, kernel length scale, and $l _ { 2 }$ penalty. We impose an upper bound of $1 0 0 \\mathrm { k }$ random features for the kernel approximation so that the data will comfortably fit into a machine with 60GB of memory. Additionally, we set one unit of resource to be 100 features for an $R = 1 0 0 0$ , which gives 5 different brackets with $\\eta = 4$ . Each searcher is run for 10 trials, with each trial lasting 12 hours on a n1-standard-16 machine from Google Cloud Compute. The results in Figure 5 show that HYPERBAND is around 6x faster than Bayesian methods and random search. HYPERBAND performs similarly to bracket $s = 4$ . Random $\\_ { 2 \\times }$ outperforms Bayesian optimization algorithms. ",
+        "bbox": [
+            174,
+            786,
+            825,
+            883
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/36cad590c6ca90ff30afd753a183bf032971c1412bfd298ced67cec0d73ee2e7.jpg",
+        "image_caption": [
+            "Figure 4: Average test error of the best kernel regularized least square classification model found by each searcher on CIFAR-10. The color coded dashed lines indicate when the last trial of a given searcher finished. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            227,
+            102,
+            444,
+            247
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/bf3a98516a5ca827ad59b6ab39a6e7ee1b71fb7c18742e3ae9b77865cf43386e.jpg",
+        "image_caption": [
+            "Figure 5: Average test error of the best random features model found by each searcher on CIFAR-10. The test error for HYPERBAND and bracket $s = 4$ are calculated in every evaluation instead of at the end of a bracket. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            552,
+            102,
+            769,
+            247
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            354,
+            825,
+            424
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.4 EXPERIMENTAL DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            440,
+            413,
+            454
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For a given $R$ , the most exploratory SUCCESSIVEHALVING round performed by HYPERBAND evaluates $\\eta ^ { \\mathrm { { \\lfloor \\log _ { \\eta } ( R ) \\rfloor } } }$ configurations using a budget of $( \\lfloor \\log _ { \\eta } ( R ) \\rfloor + 1 ) R$ , which gives an upper bound on the potential speedup over random search. If training time scales linearly with the resource, the maximum speedup offered by HYPERBAND compared to random search is $\\frac { \\eta ^ { \\lfloor \\log _ { \\eta } ( R ) \\rfloor } } { ( \\lfloor \\log _ { \\eta } ( R ) \\rfloor + 1 ) }$ . For the values of $\\eta$ and $R$ used in our experiments, the maximum speedup over random search is approximately $5 0 \\times$ given linear training time. However, we observe a range of speedups from $6 \\times$ to $7 0 \\times$ faster than random search. The differences in realized speedup can be explained by two factors: (1) the scaling properties of total evaluation time as a function of the allocated resource and (2) the difficulty of finding a good configuration. ",
+        "bbox": [
+            173,
+            467,
+            826,
+            602
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "If training time is superlinear as a function of the resource, then HYPERBAND can offer higher speedups. More generally, if training scales like a polynomial of degree $p > 1$ , the maximum speedup of HYPERBAND over random search is approximately $\\frac { \\eta ^ { p - 1 } - 1 } { \\eta ^ { p - 1 } } \\eta ^ { \\lfloor \\log _ { \\eta } ( R ) \\rfloor }$ . Hence, higher speedups were observed for the the kernel least square classifier experiment discussed in Section 4.2 because the training time scaled quadratically as a function of the resource. ",
+        "bbox": [
+            174,
+            609,
+            825,
+            684
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "If 10 randomly sampled configurations is sufficient to find a good hyperparameter setting, then the benefit of evaluating orders of magnitude more configurations is muted. Generally the difficulty of the problem scales with the dimension of the search space since coverage diminishes with dimensionality. For low dimensional problems, the number of configurations evaluated by random search and Bayesian methods is exponential in the number of dimensions so good coverage can be achieved; i.e. if $d = 3$ as in the features subsampling experiment, then $n = \\bar { O ( 2 ^ { d } = 8 ) }$ . Hence, HYPERBAND is only $6 \\times$ faster than random search on the feature subsampling experiment. For the neural network experiments however, we hypothesize that faster speedups are observed for HYPERBAND because the dimension of the search space is higher. ",
+        "bbox": [
+            173,
+            691,
+            826,
+            816
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 FUTURE WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            837,
+            334,
+            852
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We have introduced a novel bandit-based method for adaptive configuration evaluation with demonstrated competitive empirical performance. Future work involves exploring (i) embedding HYPERBAND into parallel and distributed computing environments; (ii) adjusting for training methods with different convergence rates; and (iii) combining HYPERBAND with non-random sampling methods. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            287,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "omputationally budgeted model selection. In COLT, 2011.   \nA. Agarwal, S. Kakade, N. Karampatziakis, L. Song, and G. Valiant. Least squares revisited: Scalable approaches for multi-class prediction. In ICML, 2014.   \nJ. Bergstra and Y. Bengio. Random search for hyper-parameter optimization. In JMLR, 2012.   \nJ. Bergstra et al. Algorithms for hyper-parameter optimization. In NIPS, 2011.   \nT. Domhan, J. T. Springenberg, and F. Hutter. Speeding up automatic hyperparameter optimization of deep neural networks by extrapolation of learning curves. In IJCAI, 2015.   \nK. Eggensperger et al. Towards an empirical foundation for assessing bayesian optimization of hyperparameters. In NIPS Bayesian Optimization Workshop, 2013.   \nA. Gyorgy and L. Kocsis. Efficient multi-start strategies for local search algorithms. ¨ JAIR, 41, 2011.   \nF. Hutter, H. Hoos, and K. Leyton-Brown. Sequential model-based optimization for general algorithm configuration. In Proc. of LION-5, 2011.   \nK. Jamieson and R. Nowak. Best-arm identification algorithms for multi-armed bandits in the fixed confidence setting. In Information Sciences and Systems (CISS), 2014 48th Annual Conference on, pp. 1–6. IEEE, 2014.   \nK. Jamieson and A. Talwalkar. Non-stochastic best arm identification and hyperparameter optimization. In AISTATS, 2015.   \nA. Klein, S. Falkner, S. Bartels, P. Hennig, and F. Hutter. Fast bayesian optimization of machine learning hyperparameters on large datasets. arXiv preprint arXiv:1605.07079, 2016.   \nA. Krizhevsky. Learning multiple layers of features from tiny images. In Technical report, Department of Computer Science, Univsersity of Toronto, 2009.   \nT. Krueger, D. Panknin, and M. Braun. Fast cross-validation via sequential testing. Journal of Machine Learning Research, 16:1103–1155, 2015.   \nH. Larochelle et al. An empirical evaluation of deep architectures on problems with many factors of variation. In ICML, 2007.   \nL. Li, K. Jamieson, G. DeSalvo, A. Rostamizadeh, and A. Talwalkar. Hyperband: A novel banditbased approach to hyperparameter optimization. arXiv:1603.06560, 2016.   \nO. Maron and A. Moore. Hoeffding races: Accelerating model selection search for classification and function approximation. In NIPS, 1993.   \nY. Netzer et al. Reading digits in natural images with unsupervised feature learning. In NIPS Workshop on Deep Learning and Unsupervised Feature Learning, 2011.   \nA. Rahimi and B. Recht. Random features for large-scale kernel machines. In NIPS, 2007.   \nG. Ratsch, T. Onoda, and K.R. M ¨ uller. Soft margins for adaboost. ¨ Machine Learning, 42:287–320, 2001.   \nR. Rifkin and A. Klautau. In defense of one-vs-all classification. JMLR, 2004.   \nA. Sabharwal, H. Samulowitz, and G. Tesauro. Selecting near-optimal learners via incremental data allocation. In AAAI, 2016.   \nP. Sermanet, S. Chintala, and Y. LeCun. Convolutional neural networks applied to house numbers digit classification. In ICPR, 2012.   \nJ. Snoek, H. Larochelle, and R. Adams. Practical bayesian optimization of machine learning algorithms. In NIPS, 2012. ",
+        "bbox": [
+            171,
+            136,
+            828,
+            926
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "J. Snoek et al. Bayesian optimization using deep neural networks. In ICML, 2015. E. Sparks, A. Talwalkar, D. Haas, M. J. Franklin, M. I. Jordan, and T. Kraska. Automating model search for large scale machine learning,. In Symposium on Cloud Computing, 2015. K. Swersky, J. Snoek, and R. Adams. Multi-task bayesian optimization. In NIPS, 2013. K. Swersky, J. Snoek, and R. P. Adams. Freeze-thaw bayesian optimization. arXiv:1406.3896, 2014. C. Thornton et al. Auto-weka: Combined selection and hyperparameter optimization of classification algorithms. In KDD, 2013. ",
+        "bbox": [
+            171,
+            102,
+            828,
+            242
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A ADDITIONAL EXPERIMENTAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            537,
+            118
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "In this section, we present a comparison of HYPERBAND with the CVST algorithm from Krueger et al. (2015) and provide additional details for experiments presented in Section 3 and 4. ",
+        "bbox": [
+            174,
+            133,
+            823,
+            161
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A.1 COMPARISON WITH CVST ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            179,
+            403,
+            193
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "The CVST algorithm from Krueger et al. (2015) focuses on speeding up standard k-fold crossvalidation. We did not include it as one of the competitors in Section 4 because the experiments we selected were too computational expensive for multi-fold cross-validation and CVST is not an any time algorithm. Nonetheless, the CVST algorithm is an interesting approach and was shown to have promising empirical performance in Krueger et al. (2015). Hence, we performed a small scale comparison modeled after their empirical studies between CVST and HYPERBAND. ",
+        "bbox": [
+            174,
+            204,
+            825,
+            289
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We replicated the classification experiments in Krueger et al. (2015) that train a support vector machine on the datasets from the IDA benchmark (Ratsch et al., 2001). All experiments were ¨ performed on Google Cloud Compute’s n1-standard-1 instances. Following Krueger et al. (2015), we evaluated HYPERBAND and CVST on the same 2d grid of 610 hyperparameters and recorded the best test error and duration for 50 trials . The only modification we made to their original experimental setup was the data splits; instead of half for test and half for training, we used 1/11th for test and 10/11th for training. HYPERBAND performed holdout evaluation using 1/10th of the training data as the validation set. We set $\\eta = 3$ , and $R$ was set for each dataset so that a minimum resource of 50 datapoints is allocated to each configuration. Table 2 shows that CVST and HYPERBAND achieve comparable test errors (the differences are well within the error bars), while HYPERBAND is significantly faster than CVST on all datasets. More granularly, while CVST on average has slightly lower mean error, HYPERBAND is within $0 . 2 \\%$ of CVST on 5 of the 7 datasets. Additionally, for each of the 7 datasets, HYPERBAND does as well as or better than CVST in over half of the trials. ",
+        "bbox": [
+            173,
+            295,
+            825,
+            477
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/165de66b3887b7fae621ec1ec1c3a6b20049fbbddb4db113e07ea67ee1b416ce.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Dataset</td><td colspan=\"2\">CVST</td><td colspan=\"2\">Hyperband</td><td rowspan=\"2\">Ratio Duration</td></tr><tr><td>Test Error</td><td>Duration</td><td>Test Error</td><td>Duration</td></tr><tr><td>banana</td><td>9.8%±1.6%</td><td>12.3±5.0</td><td>9.9%±1.5%</td><td>1.8±0.1</td><td>6.7±2.8</td></tr><tr><td>german</td><td>26.0%±4.5%</td><td>2.7±1.1</td><td>27.6%±4.8%</td><td>0.7±0.0</td><td>4.1±1.7</td></tr><tr><td>image</td><td>2.9%±1.1%</td><td>3.5±1.0</td><td>3.3%±1.4%</td><td>1.0±0.0</td><td>3.4±0.9</td></tr><tr><td>splice</td><td>8.6%±1.8%</td><td>10.6±3.1</td><td>8.7%±1.8%</td><td>3.9±0.1</td><td>2.7±0.8</td></tr><tr><td>ringnorm</td><td>1.4%±0.4%</td><td>21.3±2.3</td><td>1.5%±0.4%</td><td>6.5±0.3</td><td>3.3±0.4</td></tr><tr><td>twonorm</td><td>2.4%±0.5%</td><td>27.9±10.0</td><td>2.4%±0.5%</td><td>6.5±0.2</td><td>4.3±1.5</td></tr><tr><td>waveform</td><td>9.3%±1.3%</td><td>13.7±2.7</td><td>9.5%±1.3%</td><td>2.9±0.2</td><td>4.8±1.0</td></tr></table>",
+        "bbox": [
+            225,
+            487,
+            772,
+            616
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Table 2: The test error and duration columns show the average value plus/minus the standard deviation across 50 trials. Duration is measured in minutes and indicates how long it took each method to evaluate the grid of 610 hyperparameters used in Krueger et al. (2015). The ratio column shows the ratio of the duration for HYPERBAND over that for CVST with associated standard deviation. ",
+        "bbox": [
+            173,
+            626,
+            825,
+            683
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A.2 LENET EXPERIMENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            705,
+            362,
+            719
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We trained the LeNet convolutional neural network on MNIST using mini-batch SGD. Code is available for the network at http://deeplearning.net/tutorial/lenet.html. The search space for the LeNet example discussed in Section 3.2 is shown in Table 3. ",
+        "bbox": [
+            176,
+            731,
+            825,
+            773
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/9e59e6321d8b274fe4b85e29536e384bf0800d4d9af10380c342281ba08c7404.jpg",
+        "table_caption": [
+            "Table 3: Hyperparameter space for the LeNet application of Section 3.2. Note that the number of kernels in Layer-1 is upper bounded by the number of kernels in Layer-2. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Hyperparameter</td><td rowspan=1 colspan=1>Scale</td><td rowspan=1 colspan=1>Min</td><td rowspan=1 colspan=1>Max</td></tr><tr><td rowspan=1 colspan=1>Learning Rate</td><td rowspan=1 colspan=1>log</td><td rowspan=1 colspan=1>1e-3</td><td rowspan=1 colspan=1>1e-1</td></tr><tr><td rowspan=1 colspan=1>Batch size</td><td rowspan=1 colspan=1>log</td><td rowspan=1 colspan=1>1e1</td><td rowspan=1 colspan=1>1e3</td></tr><tr><td rowspan=1 colspan=1>Layer-2 Num Kernels (k2)</td><td rowspan=1 colspan=1>linear</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>60</td></tr><tr><td rowspan=1 colspan=1>Layer-1 Num Kernels (k1)</td><td rowspan=1 colspan=1>linear</td><td rowspan=1 colspan=1>5</td><td rowspan=1 colspan=1>k2</td></tr></table>",
+        "bbox": [
+            323,
+            786,
+            674,
+            861
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A.3 EXPERIMENTS USING ALEX KRIZHEVSKY’S CNN ARCHITECTURE ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            103,
+            676,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/cf3cfdda733846ddfaa9e17281e0c1e18a4fdc26d027b4446ee74ef84eae15f4.jpg",
+        "table_caption": [
+            "For the experiments discussed in Section 4.1, the exact architecture used is the $1 8 \\%$ model provided on cuda-convnet for CIFAR-10.5 ",
+            "Table 4: Hyperparameters and associated ranges for the three-layer convolutional network. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Hyperparameter</td><td>Scale</td><td>Min</td><td>Max</td></tr><tr><td>Learning Parameters</td><td></td><td></td><td></td></tr><tr><td>Initial Learning Rate</td><td>log</td><td>5*10-5</td><td>5</td></tr><tr><td>Conv1 l2 Penalty</td><td>log</td><td>5*10-5</td><td>5</td></tr><tr><td>Conv2 l2 Penalty</td><td>log</td><td>5*10-5</td><td>5</td></tr><tr><td>Conv3 l2 Penalty</td><td>10g</td><td>5*10-5</td><td>5</td></tr><tr><td>FC4 l2 Penalty</td><td>log</td><td>5*10-3</td><td>500</td></tr><tr><td>Learning Rate Reductions</td><td>integer</td><td>0</td><td>3</td></tr><tr><td>Local Response Normalization</td><td></td><td></td><td></td></tr><tr><td>Scale</td><td>log</td><td>5*10-6</td><td>5</td></tr><tr><td>Power</td><td>linear</td><td>0.01</td><td>3</td></tr></table>",
+        "bbox": [
+            292,
+            167,
+            707,
+            327
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Search Space: The search space used for the experiments is shown in Table 4. The learning rate reductions hyperparameter indicates how many times the learning rate was reduced by a factor of 10 over the maximum iteration window. For example, on CIFAR-10, which has a maximum iteration of 30,000, a learning rate reduction of 2 corresponds to reducing the learning every 10,000 iterations, for a total of 2 reductions over the 30,000 iteration window. All hyperparameters with the exception of the learning rate decay reduction overlap with those in Snoek et al. (2012). Two hyperparameters in Snoek et al. (2012) were excluded from our experiments: (1) the width of the response normalization layer was excluded due to limitations of the Caffe framework and (2) the number of epochs was excluded because it is incompatible with dynamic resource allocation. ",
+        "bbox": [
+            174,
+            383,
+            825,
+            510
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Datasets: CIFAR-10 and SVHN contain $3 2 \\times 3 2$ RGB images while MRBI contains $2 8 \\times 2 8$ grayscale images. For all datasets, the only preprocessing performed on the raw images was demeaning. For CIFAR-10, the training (40,000 instances) and validation (10,000 instances) sets were sampled from data batches 1-5 with balanced classes. The original test set (10,000 instances) is used for testing. For MRBI, the training (10,000 instances) and validation (2,000 instances) sets were sampled from the original training set with balanced classes. The original test set (50,000 instances) is used for testing. Lastly, for SVHN, the train, validation, and test splits were created using the same procedure as that in Sermanet et al. (2012). ",
+        "bbox": [
+            173,
+            516,
+            825,
+            627
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Computational Considerations: The experiments took the equivalent of over 1 year of GPU hours on NVIDIA GRID K520 cards available on Amazon $^ { \\mathrm { E C 2 } } ~ \\mathfrak { g } ^ { 2 } \\cdot 8 \\times \\mathrm { 1 a r g e }$ instances. We set a total budget constraint in terms of iterations instead of compute time to make comparisons hardware independent.6 Comparing progress by iterations instead of time ignores overhead costs not associated with training like cost of configuration selection for Bayesian methods and model initialization and validation costs for HYPERBAND. While overhead is hardware dependent, the overhead for HYPERBAND is below $5 \\%$ on EC2 g2.8xlarge machines, so comparing progress by time passed would not impact results significantly. ",
+        "bbox": [
+            173,
+            635,
+            825,
+            746
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Due to the high computational cost of these experiments, we were not able to run all searchers out to convergence. However, we did double the budget for each trial of CIFAR-10 to allow for a comparison of the searchers as they near convergence. Figure 6 shows while Bayesian optimization methods achieve similar performance as HYPERBAND and SUCCESSIVEHALVING, it takes them much longer to achieve a comparable error rate. ",
+        "bbox": [
+            174,
+            753,
+            825,
+            823
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Comparison with Early Stopping: Adaptive allocation for hyperparameter optimization can be thought of as a form of early stopping where less promising configurations are halted before completion. Domhan et al. (2015) propose an early stopping method for neural networks and combine it with SMAC to speed up hyperparameter optimization. Their method stops training a configuration if the probability of the configuration beating the current best is below a specified threshold. This probability is estimated by extrapolating learning curves fit to the intermediate validation error losses of a configuration. If a configuration is terminated early, the predicted terminal value from the estimated learning curves is used as the validation error passed to the hyperparameter optimization algorithm. Hence, if the learning curve fit is poor, it could impact the performance of the configuration selection algorithm. While this approach is heuristic in nature, it does demonstrate promising empirical performance so we included SMAC with early termination as a competitor. We used the conservative termination criterion with default parameters and recorded the validation loss every 400 iterations and evaluated the termination criterion 3 times within the training period (every $^ { 8 \\mathrm { k } }$ iterations for CIFAR-10 and MRBI and every 16k iterations for SVHN).7 Comparing performance by the total multiple of $R$ used is conservative because it does not account for the time spent fitting the learning curve in order to check the termination criterion. ",
+        "bbox": [
+            176,
+            829,
+            823,
+            872
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/ae5a0b96eda6a0ac54c3a011acc3b8a86249325bfc21f84ae6dceea5ef706198.jpg",
+        "image_caption": [
+            "Figure 6: Average test error across 10 trials is shown in all plots. Error bars indicate the maximum and minimum ranges of the test error corresponding to the model with the best validation error "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            119,
+            777,
+            541
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            614,
+            825,
+            795
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.4 KERNEL CLASSIFICATION EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            815,
+            496,
+            828
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We trained the regularized least-squares classification model using a block coordinate descent solver. Our models take less than 10 minutes to train on CIFAR-10 using an 8 core machine, while the default SVM method in Scikit-learn is single core and takes hours. Table 5 shows the hyperparameters and associated ranges considered in the kernel least squares classification experiment discussed in ",
+        "bbox": [
+            174,
+            840,
+            825,
+            896
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/a8537bdb124d8b857bf2de22480f5ce2165e62749790d9f27db648073757d8c2.jpg",
+        "table_caption": [
+            "Table 5: Hyperparameter space for kernel regularized least squares classification problem discussed in Section 4.2. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Hyperparameter</td><td rowspan=1 colspan=1>Type</td><td rowspan=1 colspan=2>Values</td></tr><tr><td rowspan=1 colspan=1>preprocessor</td><td rowspan=1 colspan=1>Categorical</td><td rowspan=1 colspan=2>min/max, standardize, normalize</td></tr><tr><td rowspan=1 colspan=1>kernel</td><td rowspan=1 colspan=1>Categorical</td><td rowspan=1 colspan=2>rbf, polynomial, sigmoid</td></tr><tr><td rowspan=1 colspan=1>C</td><td rowspan=1 colspan=1>Continuous</td><td rowspan=1 colspan=2>log [10-3,105]</td></tr><tr><td rowspan=1 colspan=1>gamma</td><td rowspan=1 colspan=1>Continuous</td><td rowspan=1 colspan=1>log</td><td rowspan=1 colspan=1>log [10-5,10]</td></tr><tr><td rowspan=1 colspan=1>degree</td><td rowspan=1 colspan=1>if kernel=poly</td><td rowspan=1 colspan=2>integer [2,5]</td></tr><tr><td rowspan=1 colspan=1>coef0</td><td rowspan=1 colspan=1>if kernel=poly,sigmoid</td><td rowspan=1 colspan=2>uniform [-1.0, 1.0]</td></tr></table>",
+        "bbox": [
+            233,
+            101,
+            763,
+            205
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Section 4.2. The cost term C is divided by the number of samples so that the tradeoff between the squared error and the $l _ { 2 }$ penalty would remain constant as the resource increased (squared error is summed across observations and not averaged). The regularization term $\\lambda$ is equal to the inverse of the scaled cost term C. Additionally, the average test error with associated minimum and maximum ranges across 10 trials are show in Figure 7. ",
+        "bbox": [
+            173,
+            272,
+            826,
+            343
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/0537019f71cbec3f59ef7dd3d2c74807334937c8b1ed218639387bf20e2b6c40.jpg",
+        "image_caption": [
+            "Figure 7: Average test error of the best kernel regularized least square classification model found by each searcher on CIFAR-10. The color coded dashed lines indicate when the last trial of a given searcher finished. Error bars correspond to observed minimum and maximum test error across 10 trials. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            331,
+            359,
+            661,
+            580
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/046f439b35b4f5671137972912bb4557a425a738d0531023477e185ff71722f5.jpg",
+        "table_caption": [
+            "Table 6: Hyperparameter space for random feature kernel approximation classification problem discussed in Section 4.3. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Hyperparameter</td><td rowspan=1 colspan=1>Type</td><td rowspan=1 colspan=1>Values</td></tr><tr><td rowspan=1 colspan=1>preprocessor</td><td rowspan=1 colspan=1>Categorical</td><td rowspan=1 colspan=1>none,min/max,standardize, normalize</td></tr><tr><td rowspan=1 colspan=1>入</td><td rowspan=1 colspan=1>Continuous</td><td rowspan=1 colspan=1>log [10-3,105]</td></tr><tr><td rowspan=1 colspan=1>gamma</td><td rowspan=1 colspan=1>Continuous</td><td rowspan=1 colspan=1>log[10-5,10]</td></tr></table>",
+        "bbox": [
+            250,
+            676,
+            746,
+            738
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Table 6 shows the hyperparameters and associated ranges considered in the random features kernel approximation classification experiment discussed in Section 4.3. The regularization term $\\lambda$ is divided by the number of features so that the tradeoff between the squared error and the $l _ { 2 }$ penalty would remain constant as the resource increased. Additionally, the average test error with associated minimum and maximum ranges across 10 trials are show in Figure 8. ",
+        "bbox": [
+            173,
+            801,
+            825,
+            872
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/9dacf9af6c00852356c1671d0f5e9dfe221f9f91f66341195e6107fb62ae7dce.jpg",
+        "image_caption": [
+            "Figure 8: Average test error of the best random features model found by each searcher on CIFAR-10. The test error for HYPERBAND and bracket $s = 4$ are calculated in every evaluation instead of at the end of a bracket. Error bars correspond to observed minimum and maximum test error across 10 trials. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            331,
+            367,
+            663,
+            590
+        ],
+        "page_idx": 14
+    }
+]