Add files using upload-large-folder tool

parse/train/DPHsCQ8OpA/DPHsCQ8OpA.md

@@ -0,0 +1,335 @@
+# Habitat 2.0: Training Home Assistants to Rearrange their Habitat
+
+Andrew Szot2, ⇤ Alex Clegg1, Eric Undersander1, Erik Wijmans1,2, Yili Zhao1, John Turner1, Noah Maestre1, Mustafa Mukadam1, Devendra Chaplot1, Oleksandr Maksymets1, Aaron Gokaslan1, Vladimir Vondrus, Sameer Dharur2, Franziska Meier1, Wojciech Galuba1, Angel Chang4, Zsolt ${ \bf K i r a } ^ { 2 }$ , Vladlen Koltun3, Jitendra Malik1,5, Manolis Savva4, Dhruv Batra1,2 1Facebook AI Research, 2Georgia Tech, 3Intel Research, 4Simon Fraser University 5UC Berkeley
+
+# Abstract
+
+We introduce Habitat 2.0 (H2.0), a simulation platform for training virtual robots in interactive 3D environments and complex physics-enabled scenarios. We make comprehensive contributions to all levels of the embodied AI stack – data, simulation, and benchmark tasks. Specifically, we present: (i) ReplicaCAD: an artist-authored, annotated, reconfigurable 3D dataset of apartments (matching real spaces) with articulated objects (e.g. cabinets and drawers that can open/close); (ii) H2.0: a high-performance physics-enabled 3D simulator with speeds exceeding 25,000 simulation steps per second $\mathbf { 8 5 0 } \times$ real-time) on an 8-GPU node, representing $1 0 0 \times$ speed-ups over prior work; and, (iii) Home Assistant Benchmark (HAB): a suite of common tasks for assistive robots (tidy the house, stock groceries, set the table) that test a range of mobile manipulation capabilities. These large-scale engineering contributions allow us to systematically compare deep reinforcement learning (RL) at scale and classical sense-plan-act (SPA) pipelines in long-horizon structured tasks, with an emphasis on generalization to new objects, receptacles, and layouts. We find that (1) flat RL policies struggle on HAB compared to hierarchical ones; (2) a hierarchy with independent skills suffers from ‘hand-off problems’, and (3) SPA pipelines are more brittle than RL policies.
+
+![](images/d31e703e21f8014d3a60910756387dd60282a6d64c30913f2766c42e9a6615b2.jpg)  
+Figure 1: A mobile manipulator (Fetch robot) simulated in Habitat 2.0 performing rearrangement tasks in a ReplicaCAD apartment – (left) opening a drawer before picking up an item from it, and (right) placing an object into the bowl after navigating to the table. Best viewed in motion at https://aihabitat.org/docs/habitat2.
+
+# 1 Introduction
+
+Consider a home assistant robot illustrated in Fig. 1 – a mobile manipulator (Fetch [1]) performing tasks like stocking groceries into the fridge, clearing the table and putting dishes into the dishwasher, fetching objects on command and putting them back, etc. Developing such embodied intelligent systems is a goal of deep scientific and societal value. So how should we accomplish this goal?
+
+Training and testing such robots in hardware directly is slow, expensive, and difficult to reproduce. We aim to advance the entire ‘research stack’ for developing such embodied agents in simulation – (1) data: curating house-scale interactive 3D assets (e.g. kitchens with cabinets, drawers, fridges that can open/close) that support studying generalization to unseen objects, receptacles, and home layouts, (2) simulation: developing the next generation of high-performance photo-realistic 3D simulators that support rich interactive environments, (3) tasks: setting up challenging representative benchmarks to enable reproducible comparisons and systematic tracking of progress over the years. To support this long-term research agenda, we present:
+
+• ReplicaCAD: an artist-authored fully-interactive recreation of ‘FRL-apartment’ spaces from the Replica dataset [2] consisting of 111 unique layouts of a single apartment background with 92 authored objects including dynamic parameters, semantic class and surface annotations, and efficient collision proxies, representing $9 0 0 +$ person-hours of professional 3D artist effort. ReplicaCAD (illustrated in figures and videos) was created with the consent of and compensation to artists, and will be shared under a Creative Commons license for non-commercial use with attribution (CC-BY-NC).
+
+• Habitat 2.0 (H2.0): a high-performance physics-enabled 3D simulator, representing approximately 2 years of development effort and the next generation of the Habitat project [3] (Habitat 1. 0). H2.0 supports piecewise-rigid objects (e.g. door, cabinets, and drawers that can rotate about an axis or slide), articulated robots (e.g. mobile manipulators like Fetch [1], fixed-base arms like Franka [4], quadrupeds like AlienGo [5]), and rigid-body mechanics (kinematics and dynamics). The design philosophy of $\mathrm { H } 2 . 0$ is to prioritize performance (or speed) over the breadth of simulation capabilities. $\mathrm { H } 2 . 0$ by design and choice does not support non-rigid dynamics (deformables, fluids, films, cloths, ropes), physical state transformations (cutting, drilling, welding, melting), audio or tactile sensing – many of which are capabilities provided by other simulators [6–8]. The benefit of this focus is that we were able to design and optimize $\mathrm { H } 2 . 0$ to be exceedingly fast – simulating a Fetch robot interacting in ReplicaCAD scenes at 1200 steps per second (SPS), where each ‘step’ involves rendering 1 RGBD observation ( $1 2 8 \times 1 2 8$ pixels) and simulating rigid-body dynamics for $^ { 1 / 3 0 }$ sec. Thus, 30 SPS would be considered ‘real time’ and $1 2 0 0 \mathrm { S P S }$ is $4 0 \times$ real-time. $\mathrm { H } 2 . 0$ also scales well – achieving 8,200 SPS $2 7 3 \times$ real-time) multi-process on a single GPU and over 25,000 SPS ( $8 5 0 \times$ real-time) on a single node with 8 GPUs. For reference, existing simulators typically achieve 10-400 SPS (see Tab. 1). These $1 0 0 \times$ simulation-speedups correspond to cutting experimentation time from 6 months to under 2 days, unlocking experiments that were hitherto infeasible, allowing us to answer questions that were hitherto unanswerable. As we will show, they also directly translate to training-time speed-up and accuracy improvements from training agents (for object rearrangement tasks) on more experience.
+
+• Home Assistant Benchmark (HAB): a suite of common tasks for assistive robots (TidyHouse, PrepareGroceries, SetTable) that are specific instantiations of the generalized rearrangement problem [9]. Specifically, a mobile manipulator (Fetch) is asked to rearrange a list of objects from initial to desired positions – picking/placing objects from receptacles (counter, sink, sofa, table), opening/closing containers (drawers, fridges) as necessary. We use the GeometricGoal specification prescribed by Batra et al. [9] – i.e., initial and desired 3D (center-of-mass) position of each target object $i$ to be rearranged $\left( s _ { i } ^ { 0 } , s _ { i } ^ { * } \right) _ { i = 1 } ^ { N }$ The choice of GeometricGoal is deliberate – we aim to create the PointNav [10] equivalent for mobile manipulators. As witnessed in the navigation literature, such a task becomes the testbed for exploring ideas [11–19] and a starting point for more semantic tasks [20–22]. The robot operates entirely from onboard sensing – head- and arm-mounted RGB-D cameras, proprioceptive joint-position sensors (for the arm), and egomotion sensors (for the mobile base) – and may not access any privileged state information (no prebuilt maps, no 3D models of rooms or objects, no physically-implausible sensors providing knowledge of mass, friction, articulation of containers, etc.). Notice that an object’s center-of-mass provides no information about its size or orientation. The target object may be located inside a container (drawer, fridge), on top of supporting surfaces (shelf, table, sofa) of varying heights and sizes, and surrounded by clutter; all of which must be sensed and maneuvered. Receptacles like drawers and fridges start closed, meaning that the agent must open and close articulated objects to succeed. An episode is considered successful if all target objects are placed within $\mathrm { 1 5 c m }$ of their desired positions (without considering orientation). The robot uses continuous end-effector control for the arm and velocity control for the base. We deliberately focus on gross motor control (the base and arm) and not fine motor control (the gripper), following
+
+<table><tr><td rowspan="2"></td><td colspan="2">Rendering</td><td colspan="2">Physics</td><td rowspan="2">Scene Complexity</td><td rowspan="2">Speed (steps/sec)</td></tr><tr><td>Library</td><td>Supports</td><td>Library</td><td>Supports</td></tr><tr><td>Habitat [3]</td><td>Magnum</td><td>3D scans</td><td>none</td><td>continuous navigation (navmesh)</td><td>building-scale</td><td>3,000</td></tr><tr><td>AI2-THOR [6]</td><td>Unity</td><td>Unity</td><td>Unity</td><td>rigid dynamics,animated interactions</td><td>room-scale</td><td>30-60</td></tr><tr><td>ManipulaTHOR [33]</td><td>Unity</td><td>Unity</td><td>Unity</td><td>AI2-THOR + manipulation</td><td>room-scale</td><td>30-40</td></tr><tr><td>ThreeDWorld [7]</td><td>Unity</td><td>Unity</td><td>Unity (PhysX) + FLEX</td><td>rigid + particle dynamics</td><td>room/house-scale</td><td>5-168</td></tr><tr><td>SAPIEN [34]</td><td>OpenGL/OptiX</td><td>configurable</td><td>PhysX</td><td>rigid/articulated dynamics</td><td>object-level</td><td>200-400t</td></tr><tr><td>RLBench [35]</td><td>CoppeliaSim (OpenGL)</td><td>Gouraud shading</td><td>CoppeliaSim (Bullet/ODE)</td><td>rigid/articulated dynamics</td><td>table-top</td><td>1-60t</td></tr><tr><td>iGibson [36]</td><td>PyRender</td><td>PBR shading</td><td>PyBullet</td><td>rigid/articulated dynamics</td><td>house-scale</td><td>100</td></tr><tr><td>Habitat 2.0 (H2.0)</td><td>Magnum</td><td>3D scans + PBR shading</td><td>Bullet</td><td>rigid/articulated dynamics + navmesh</td><td>house-scale</td><td>1,200</td></tr></table>
+
+Table 1: High-level comparison of different simulators. Note: Speeds were taken directly from respective publications or obtained via direct personal correspondence with the authors when not publicly available (indicated by †). Benchmarking was conducted by different teams on different hardware with different underlying 3D assets simulating different capabilities. Thus, these should be considered qualitative comparisons representing what a user expects to experience on a single instance of the simulator (no parallelization).
+
+the ‘abstracted grasping’ recommendations from [9]. Specifically, once the end-effector reaches $1 5 \mathrm { c m }$ (or closer) to an object, a discrete grasp action becomes available that, if executed, snaps the object into its parallel-jaw gripper 2. We conduct a systematic study of two distinct techniques – monolithic ‘sensors-to-actions’ policies trained with reinforcement learning (RL) at scale, and classical senseplan-act pipelines (SPA) [26] – with a particular emphasis on systematic generalization to new objects, receptacles, apartment layouts (not just robot starting pose). Our findings include:
+
+1. Flat vs hierarchical: Monolithic RL policies successfully learn diverse individual skills (pick/place, navigate, open/close drawer). However, crafting a combined reward function and learning scheme that elicits chaining of such skills for the long-horizon HAB tasks remained out of our reach. We saw significantly stronger results with a hierarchical approach that assumes knowledge of a perfect task planner (via STRIPS [27]) to break it down into a sequence of skills.
+
+2. Hierarchy cuts both ways: However, a hierarchy with independent skills suffers from ‘hand-off problems’ where a succeeding skill isn’t set up for success by the preceding one – e.g., navigating to a bad location for subsequent manipulation, only partially opening a drawer to grab an object inside, or knocking an object out of reach that is later needed.
+
+3. Brittleness of SensePlanAct: For simple skills, SPA performs just as well as monolithic RL. However, it is significantly more brittle since it needs to map all obstacles in the workspace for planning. More complex settings involving clutter, challenging receptacles, and imperfect navigation can poorly frame the target object and obstacles in the robot’s camera, leading to incorrect plans.
+
+We hope our work will serve as a benchmark for many years to come. $\mathrm { H } 2 . 0$ is free, open-sourced under the MIT license, and under active development. 3 We believe it will reduce the community’s reliance on commercial lock-ins [28, 29] and non-photorealistic simulation engines [30–32].
+
+# 2 Related Work
+
+What is a simulator? Abstractly speaking, a simulator has two components: (1) a physics engine that evolves the world state $s$ over time $s _ { t } \to s _ { t + 1 }$ , and (2) a renderer that generates sensor observations $o$ from states: $s _ { t } \to o _ { t }$ . The boundary between the two is often blurred as a matter of convenience. Many physics engines implement minimal renderers to visualize results, and some rendering engines include integrations with a physics engine. PyBullet [37], MuJoCo [28], DART [38], ODE [39], PhysX/FleX [40, 41], and Chrono [42] are primarily physics engines with some level of rendering, while Magnum [43], ORRB [44], and PyRender [45] are primarily renderers. Game engines like Unity [46] and Unreal [47] provide tightly coupled integration of physics and rendering. Some simulators [3, 48, 49] involve largely static environments – the agent can move but not change the state of the environment (e.g. open cabinets). Thus, they are heavily invested in rendering with fairly lightweight physics (e.g. collision checking with the agent approximated as a cylinder).
+
+How are interactive simulators built today? Either by relying on game engines [6, 50, 51] or via a ‘homebrew’ integration of existing rendering and physics libraries [7, 34, 36, 52]. Both options have problems. Game engines tend to be optimized for human needs (high image-resolution, ${ \sim } 6 0$ FPS, persistent display) not for AI’s needs [53] ( $1 0 \mathbf { k } +$ FPS, low-res, ‘headless’ deployment on a cluster). Reliance on them leads to limited control over the performance characteristics. On the other hand, they represent decades of knowledge and engineering effort whose value cannot be discounted. This is perhaps why ‘homebrew’ efforts involve a high-level (typically Python-based) integration of existing libraries. Unfortunately but understandably, this results in simulation speeds of 10-100s of SPS, which is orders of magnitude sub-optimal. $\mathrm { H } 2 . 0$ involved a deep low-level $( \mathbf { C } + + )$ integration of rendering (via Magnum [43]) and physics (via Bullet [37]), enabling precise control of scheduling and task-aware optimizations, resulting in substantial performance improvements.
+
+Object rearrangement. Task- and motion-planning [54] and mobile manipulation have a long history in AI and robotics, whose full survey is beyond the scope of this document. Batra et al. [9] provide a good summary of the historical background of rearrangement, a review of recent efforts, a general framework, and a set of recommendations that we adopt here. Broadly speaking, our work is distinguished from prior literature by a combination of the emphasis on visual perception, lack of access to state, systematic generalization, and the experimental setup of visually-complex and ecologically-realistic home-scale environments. We now situate w.r.t. a few recent efforts. [55] study replanning in the presence of partial observability but do not consider mobile manipulation. [52] tackle ‘interactive navigation’, where the robot can bump into and push objects during navigation, but does not have an arm. Some works [56–58] abstract away gross motor control entirely by using symbolic interaction capabilities (e.g. a ‘pick up $X ^ { \prime }$ action) or a ‘magic pointer’ [9]. We use abstracted grasping but not abstract manipulation. [19] develop hierarchical methods for mobile manipulation, combining RL policies for goal-generation and motion-planning for executing them. We use the opposite combination of planning and learning – using task-planning to generate goals and RL for skills. [33] is perhaps the most similar to our work. Their task involves moving a single object from one location to another, excluding interactions with container objects (opening a drawer or fridge to place an object inside). We will see that rearrangement of multiple objects while handling containment is a much more challenging task. Interestingly, our experiments show evidence for the opposite conclusion reached therein – monolithic end-to-end trained RL methods are outperformed by a modular approach that is trained stage-wise to handle long-horizon rearrangement tasks.
+
+# 3 Replica to ReplicaCAD: Creating Interactive Digital Twins of Real Spaces
+
+We begin by describing our dataset that provides a rich set of indoor layouts for studying rearrangement tasks. Our starting point was Replica [2], a dataset of highly photo-realistic 3D reconstructions at room and building scale. Unfortunately, static 3D scans are unsuitable for studying rearrangement tasks because objects in a static scan cannot be moved or manipulated.
+
+![](images/29c20691773a3d6c9be805d76b477d1e7d648f77a54db9cc010d80415ea9439c.jpg)  
+Figure 2: Left: The original Replica scene. Right: the artist recreated scene ReplicaCAD. All objects (furniture, mugs) including articulated ones (drawers, fridge) in ReplicaCAD are fully physically simulated and interactive.
+
+Asset Creation. ReplicaCAD is an artist-created, fully-interactive recreation of ‘FRL-apartment’ spaces from the Replica dataset [2]. First, a team of 3D artists authored individual 3D models (geometry, textures, and material specifications) to faithfully recreate nearly all objects (furniture, kitchen utensils, books, etc.; 92 in total) in all 6 rooms from the FRL-apartment spaces as well as an accompanying static backdrop (floor and walls). Fig. 2 compares a layout of ReplicaCAD with the original Replica scan. Next, each object was prepared for rigid-body simulation by authoring physical parameters (mass, friction, restitution), collision proxy shapes, and semantic annotations. Several objects (e.g. refrigerator, kitchen counter) were made ‘articulated’ through sub-part segmentation (annotating fridge door, counter cabinet) and authoring of URDF files describing joint configurations (e.g. fridge door swings around a hinge) and dynamic properties (e.g. joint type and limits). For each large furniture object (e.g. table), we annotated surface regions (e.g. table tops) and containment volumes (e.g. drawer space) to enable programmatic placement of small objects on top of or within.
+
+Human Layout Generation. Next, a 3D artist authored an additional 5 semantically plausible ‘macro variations’ of the scenes – producing new scene layouts consisting only of larger furniture from the same 3D object assets. Each of these macro variations was further perturbed through 20 ‘micro variations’ that re-positioned objects – e.g. swapping the locations of similarly sized tables or a sofa and two chairs. This resulted in a total of 105 scene layouts that exhibit major and minor semantically-meaningful variations in furniture placement and scene layout, enabling controlled testing of generalization. Illustrations of these variations can be found in Appendix A.
+
+Procedural Clutter Generation. To maximize the value of the human-authored assets we also develop a pipeline that allows us to generate new clutter procedurally. Specifically, we dynamically populate the annotated supporting surfaces (e.g. table-top, shelves in a cabinet) and containment volumes (e.g. fridge interior, drawer spaces) with object instances from appropriate categories (e.g., plates, food items). These inserted objects can come from ReplicaCAD or the YCB dataset [59]. We compute physically-stable insertions of clutter offline (i.e. letting an inserted bowl ‘settle’ on a shelf) and then load these stable arrangements into the scene dynamically at run-time.
+
+ReplicaCAD is fully integrated with the $\mathrm { H } 2 . 0$ and a supporting configuration file structure enables simple import, instancing, and programmatic alternation of any of these interactive scenes. Overall, ReplicaCAD represents $9 0 0 +$ person-hours of professional 3D artist effort so far (with augmentations in progress). It was created with the consent of and compensation to artists, and will be shared under a Creative Commons license for non-commercial use with attribution (CC-BY-NC). Further ReplicaCAD details and statistics are in Appendix A.
+
+# 4 Habitat 2.0 (H2.0): a Lazy Simulator
+
+$\mathrm { H } 2 . 0$ ’s design philosophy is that speed is more important than the breadth of capabilities. H2.0 achieves fast rigid-body simulation in large photo-realistic 3D scenes by being lazy and only simulating what is absolutely needed. We instantiate this principle via 3 key ideas – localized physics and rendering (Sec. 4.1), interleaved physics and rendering (Sec. 4.2), and simplify-and-reuse (Sec. B.1). We also describe motion planning integration in Appendix B.2.
+
+# 4.1 Localized Physics and Rendering
+
+Realistic indoor 3D scenes can span houses with multiple rooms (kitchen, living room), hundreds of objects (sofa, table, mug) and ‘containers’ (fridge, drawer, cabinet), and thousands of parts (fridge shelf, cabinet door). Simulating physics for every part at all times is slow and unnecessary. We leverage Bullet’s built-in island sleep system to minimize simulation overhead for idle objects. In addition, we make several optimizations: (1) We employ a navigation mesh to move the robot base kinematically (which has been shown to transfer well to real the world [60]) rather than simulating wheel-ground contact. (2) For multi-body articulated furniture, we remove static parts (e.g. the walls and floor of a cabinet) from the Bullet multi-body and instead load these as separate static rigid objects. This improves the sleeping behavior of the entire simulation, for example, an idle object resting on the floor of the cabinet can sleep even while the cabinet door is moving. (3) We use the sleeping state of objects to optimize rendering by caching and re-using scene graph transformation matrices and frustum-culling results.
+
+# 4.2 Interleaved rendering and physics
+
+Most physics engines (e.g. Bullet) run on the CPU, while rendering (e.g. via Magnum) typically occurs on the GPU. After our initial optimizations, we found each to take nearly equal compute-time. This represents a glaring inefficiency – as illustrated in Fig. 3, at any given time either the CPU is sitting idle waiting for the GPU or vice-versa. Thus, interleaving them leads to significant gains. However, this is complicated by a sequential dependency – state transitions depend on robot actions $\mathcal { T } : ( s _ { t } , a _ { t } )  s _ { t + 1 }$ , robot actions depend on the sensor observations: $\pi : o _ { t }  a _ { t }$ , and observations depend on the state $\mathcal { O } : s _ { t } \to o _ { t }$ . Thus, it ostensibly appears that physics and rendering outputs $( s _ { t + 1 }$ , $o _ { t }$ ) cannot be computed in parallel from $s _ { t }$ because computation of $a _ { t }$ cannot begin till $o _ { t }$ is available. We break this sequential dependency by changing the agent policy to be $\pi ( a _ { t } \mid o _ { t - 1 } )$ instead of $\pi ( \boldsymbol { a } _ { t } | \boldsymbol { o } _ { t } )$ . Thus, our agent predicts the current action $a _ { t }$ not from the current observations $o _ { t }$ but from an observation from 1 timestep ago $o _ { t - 1 }$ , essentially ‘living in the past and acting in the future’.
+
+This simple change means that we can generate $s _ { t + 1 }$ on the CPU at the same time as $o _ { t }$ is being generated on the GPU.
+
+This strategy not only increases simulation throughput, but also offers two other fortuitous benefits – increased biological plausibility and improved sim2real transfer potential. The former is due to closer analogy to all sensors (biological or artificial) having a sensing latency (e.g., the human visual system has approximately $1 5 0 \mathrm { m s }$ latency [61]). The latter is due to a line of prior work [62–64] showing that introducing this latency in simulators improves the transfer of learned agents to reality.
+
+# 4.3 Benchmarking
+
+# Sequential
+
+![](images/c0089e7ca17e45ffbc71a94bdf423ef62f05acbf8c0db3185ddb1276f7ae0112.jpg)  
+Figure 3: Interleaved physics and rendering. Top shows the normal sequential method of performing physics $( s _ { t } , a _ { t } ) \to s _ { t + 1 }$ then rendering $s _ { t + 1 } \to o _ { t + 1 }$ . Bottom shows $\mathrm { H } 2 . 0$ ’s interleaved physics and rendering.
+
+We benchmark using a Fetch robot, equipped with (up to) two RGB-D cameras ( $1 2 8 \times 1 2 8$ pixels) in ReplicaCAD scenes under three scenarios: (1) Idle- $1 \times \mathrm { R G B }$ : with the robot initialized in the center of the living room somewhat far from furniture or any other object and taking random actions and equipped with a single RGB camera, (2) Idle- $2 \times \mathrm { R G B } { \cdot } \mathrm { D }$ , Idle-RGB with two RGB-D cameras, (3) Interact: with the robot initialized fairly close to the fridge and taking actions from a pre-computed trajectory that results in representative interaction with objects and equipped with two RGB-D cameras. Each simulation step consists of 1 rendering pass and 4 physics-steps, each simulating $1 / 1 2 0$ sec for a total of $1 / _ { 3 0 }$ sec. New joint position goals are set every $1 / _ { 3 0 }$ sec and a joint controller computes the joint torques to achieve the joint goals for the current joint state every $\mathbb { I } / 1 2 0$ sec. This is a fairly standard experimental configuration in robotics (with $3 0 \mathrm { F P S }$ cameras and $1 2 0 \mathrm { H z }$ control). In this setting, a simulator operating at 30 steps per (wallclock) second (SPS) corresponds to ‘real time’.
+
+Benchmarking was done on machines with dual Intel Xeon Gold 6226R CPUs – 32 cores/64 threads (32C/64T) total – and 8 NVIDIA GeForce 2080 Ti GPUs. For single-GPU benchmarking processes are confined to 8C/16T of one CPU, simulating an 8C/16T single GPU workstation. For single-GPU multi-process benchmarking, 16 processes were used. For multi-GPU benchmarking, 64 processes were used with 8 processes assigned to each GPU. We used python-3.8 and gcc-9.3 for compiling H2.0. We report average SPS over 10 runs and a $9 5 \%$ confidence-interval computed via standard error of the mean. Note that 8 processes do not fully utilize a $2 0 8 0 \mathrm { T i }$ and thus multi-process multi-GPU performance may be better on machines with more CPU cores.
+
+<table><tr><td></td><td colspan="7">1 Process</td><td colspan="6">1 GPU</td><td colspan="6">8 GPUs</td></tr><tr><td></td><td colspan="2">Idle 1×RGB</td><td colspan="2">Idle 2×RGB-D</td><td colspan="2">Interact 2×RGB-D</td><td colspan="2">Idle 1×RGB</td><td colspan="2">Idle 2×RGB-D</td><td colspan="2">Interact 2×RGB-D</td><td colspan="2">Idle 1×RGB</td><td colspan="2">Idle 2×RGB-D</td><td colspan="2">Interact 2×RGB-D</td></tr><tr><td>H2.0 (Full)</td><td>1191</td><td>±36</td><td>669</td><td>±13</td><td>510</td><td>±6</td><td>8186</td><td>±47</td><td>1926</td><td>±19</td><td>1660</td><td>±6</td><td>25734</td><td>±301</td><td>9542</td><td>±71</td><td>7699</td><td>±177</td></tr><tr><td>- render opts.</td><td>781</td><td>±9</td><td>364</td><td>±2</td><td>282</td><td>±2</td><td>6709</td><td>±89</td><td>1076</td><td>±6</td><td>1035</td><td>±3</td><td>18844</td><td>±285</td><td>6397</td><td>±43</td><td>5517</td><td>±31</td></tr><tr><td>- physics opts.</td><td>271</td><td>±3</td><td>252</td><td>±3</td><td>358</td><td>±6</td><td>2290</td><td>±5</td><td>1270</td><td>±30</td><td>1606</td><td>±6</td><td>7942</td><td>±50</td><td>5535</td><td>±41</td><td>6119</td><td>±51</td></tr><tr><td>- all opts.</td><td>242</td><td>±2</td><td>177</td><td>±3</td><td>224</td><td></td><td>2223</td><td>±3</td><td>814</td><td>±2</td><td>941</td><td>±2</td><td>7192</td><td>±55</td><td>3965</td><td>±30</td><td>4829</td><td>±50</td></tr></table>
+
+Table 2: Benchmarking $\mathrm { H } 2 . 0$ performance: simulation steps per second (higher better) over 10 runs and a $9 5 \%$ confidence-interval In Idle, the agent is executing random actions but not interacting with the scene, while Interact uses a precomputed trajectory and thus results in representative interaction with objects. To put these numbers into context, see Tab. 1. Reproduce these numbers at https://aihabitat.org/docs/habitat2.
+
+Table 2 reports benchmarking numbers for H2.0. We make a few observations. The ablations for $\mathrm { H } 2 . 0$ (denoted by ‘- render opts’, ‘-physics opts’, and ‘-all opts.’) show that principles followed in our system design lead to significant performance improvements.
+
+Our ‘Idle- $\mathbf { \cdot l } \times \mathbf { R G B } ^ { \mathbf { \cdot } }$ setting is similar to the benchmarking setup of iGibson [36], which reports 100 SPS. In contrast, $\mathrm { H } 2 . 0$ single-process with all optimizations turned off is $240 \%$ faster (242 vs 100 SPS). H2.0 single-process with optimizations on is $\sim 1 2 0 0 \%$ faster than iGibson (1191 vs 100 SPS). The comparison to iGibson is particularly illustrative since it uses the ‘same’ physics engine (PyBullet) as $\mathrm { H } 2 . 0$ (Bullet). We can clearly see the benefit of working with the low-level $\mathrm { C } { + } { + }$ Bullet rather than PyBullet and the deep integration between rendering and physics. However, we note the comparison between the two benchmarks is not exact since the robot type, number of objects, and object assets are different. A direct comparison against other simulators is not feasible due to different capabilities, assets, hardware, and experimental settings. But a qualitative order-of-magnitude survey is illustrative – AI2-THOR [6] achieves 60/30 SPS in idle/interact, SAPIEN [34] achieves 200/400 SPS (personal communication), TDW [7] achieves 5 SPS in interact, and RLBench [35] achieves between 1 and 60 SPS depending on the sensor suite (personal communication). Finally, $\mathrm { H } 2 . 0$ scales well – achieving 8,186 SPS ( $2 7 2 \times$ real-time) multi-process on a single GPU and 25,734 SPS $8 5 0 \times$ real-time) on a single node with 8 GPUs. These $1 0 0 \times$ simulation-speedups correspond to cutting experimentation time from 6-month cycle to under 2 days. iGibson also supports multi-process parallization for speeding simulation speeds beyond the reported single process numbers in the current version of the paper [36], and we recommend following updates of their work for more details.
+
+# 5 The Pick Task: a Base Case of Rearrangement
+
+We first carry out systematic analyses on a relatively simple robotic manipulation task: picking up one object from a cluttered ‘receptacle’. This forms a ‘base case’ and an instructive starting point that we eventually expand to the more challenging Home Assistant Benchmark (HAB) (Sec. 6).
+
+Task Definition: Pick $( s ^ { 0 } )$ . Fig. 4 illustrates an episode in the pick task. Our agent (a Fetch robot [1]) is spawned close to a receptacle (a table) that holds multiple objects (e.g. cracker box, bowl). The task for the robot is to pick up a target object with center-of-mass coordinates $s ^ { 0 } \in R ^ { 3 }$ (provided in robot’s coordinate system) as efficiently as possible without excessive collisions. We study systematic generalization to new clutter layout on the receptacle, to new objects, and to new receptacles. Agent embodiment and sensing. Fetch [1] is a wheeled base with a 7-DoF arm manipulator and a parallel-jaw gripper, equipped with two RGBD cameras ${ \mathrm { 9 0 ^ { \circ } F o V } } _ { : }$ , $1 2 8 \times 1 2 8$ pixels) mounted on its ‘head’ and arm.
+
+It can sense its proprioceptive-state – arm joint angles (7- dim), end-effector position (3-dim), and base-egomotion (6-dim, also known as $\mathrm { G P S } { + }$ Compass in the navigation literature [3]). Note: the episodes in Pick are constructed such that the robot does not need to move its base. Thus, the egomotion sensor does not play a role in Pick but will be important in HAB tasks (Section 6).
+
+Action space: gross motor control. The agent performs end-effector control at $3 0 \mathrm { H z }$ . At every step, it outputs the desired change in end-effector position $( \delta x , \delta y , \delta z )$ ; the desired end-effector position is fed into an inverse kinematics solver from PyBullet [37] to derive desired states for all joints, which are used to set the joint motor targets, achieved using PD control. The maximum endeffector displacement per step is $1 . 5 \mathrm { c m }$ , and the maximum impulse of the joint motors is 10Ns with a position gain of $\mathrm { K p } { = } 0 . 3$ . In Pick, the base is fixed but in HAB, the agent also emits linear and angular velocities for the base.
+
+![](images/15ed35344ef4ea61224e12b045d232d431512a150b6d70a0f8356590a0609349.jpg)  
+Figure 4: Fetch with head and arm cameras picking up a bowl from the counter.
+
+Abstracted grasping. The agent controls the gripper by emitting a scalar. If this scalar is positive and the gripper is not currently holding an object and the end-effector is within $1 5 c m$ of an object, then the object closest to the end-effector is snapped into the parallel-jaw gripper. The grasping is perfect and objects do not slide out. If the scalar is negative and the gripper is currently holding an object, then the object currently held in the gripper is released and simulated as falling. In all other cases, nothing happens. For analysis of other action spaces see Appendix F.6.
+
+Evaluation. An object is considered successfully picked if the arm returns to a known ‘resting position’ with the target object grasped. The agent fails if the accumulated contact force experienced by the arm/body exceeds a threshold of 5k Newtons. If the agent picks up the wrong object, the episode terminates. Once the object is grasped, the drop action is masked out meaning the agent will never release the object. The episode horizon is 200 steps.
+
+Methods. We compare two methods representing two distinctive approaches to this problem: 1. MonolithicRL: a ‘sensors-to-actions’ policy trained end-to-end with reinforcement learning (RL). The visual input is encoded using a CNN, concatenated with embeddings of proprioceptive-sensing and goal coordinates, and fed to a recurrent actor-critic network, trained with DD-PPO [11] for 100
+
+Million steps of experience (see Appendix C for details). This baseline translates our community’s most-successful paradigm yet from navigation to manipulation.
+
+2. SensePlanAct (SPA) pipeline: Sensing consists of constructing an accumulative 3D point-cloud of the scene from depth sensors, which is then used for collision queries. Motion planning is done using Bidirectional RRT [65] in the arm joint configuration space (see Appendix D). The controller was described in ‘Action Space’ above and is consistent with MonolithicRL. We also create SensePlanAct-Priviledged (SPA-Priv), that uses privileged information – perfect knowledge of scene geometry (from the simulator) and a perfect controller (arm is kinematically set to desired joint poses). The purpose of this baseline is to provide an upper-bound on the performance of SPA.
+
+Systematic Generalization. With $\mathrm { H } 2 . 0$ we can compare how learning based systems generalize compared to SPA architectures. Tab. 3 shows the results of a systematic generalization study of 4 unseen objects, 3 unseen receptacles, and 20 unseen apartment layouts (from 1 unseen ‘macro variation’ in ReplicaCAD). In training the agent sees 9 objects from the YCB dataset kitchen and food categories (chef can, cracker box, sugar box, tomato soup can, tuna fish cap, pudding box, gelatin box, potted meat can, and
+
+<table><tr><td rowspan="2">Method</td><td rowspan="2">Seen</td><td colspan="3">Unseen</td></tr><tr><td>Layouts</td><td>Objects</td><td>Receptacles</td></tr><tr><td>MonolithicRL 91.7 ±1.1</td><td></td><td>86.3 ±1.4</td><td>74.7 ±1.8</td><td>52.7 ±2.0</td></tr><tr><td>SPA</td><td>70.2 ±1.9</td><td>72.7 ±1.8</td><td>72.7 ±1.8</td><td>60.3 ±2.0</td></tr><tr><td>SPA-Priv</td><td>77.0 ±1.7</td><td>80.0±1.6</td><td>79.2 ±1.7</td><td>60.7 ±2.0</td></tr></table>
+
+Table 3: Pick generalization analysis: success rates with mean and standard error on 600 episodes (and across 3 seeds for MonolithicRL).
+
+bowl). During evaluation it is tested on 4 unseen objects (apple, orange, mug, sponge). Likewise, the agent is trained on the counter, sink, light table, cabinet, fridge, dark table, and sofa receptacles (view in Fig. 11) but evaluated on the unseen receptacles of tv stand, shelves, and chair (view in Fig. 12).
+
+MonolithicRL generalizes fairly well from seen to unseen layouts $( 9 1 . 7  8 6 . 3 \%$ ), significantly outperforming SPA $( 7 2 . 7 \% )$ and even SPA-Priv $( 8 0 . 0 \% )$ . However, generalization to new objects is challenging $( 9 1 . 7  7 4 . 7 \% )$ as a result of the new visual feature distribution and new object obstacles. Generalization to new receptacles is poor $( 9 1 . 7  5 2 . 7 \% )$ ). However, the performance drop of SPA (and qualitative results) suggest that the unseen receptacles (shelf, armchair, tv stand) may be objectively more difficult to pick up objects from since the shelf and armchair are tight constrained areas whereas the majority of the training receptacles, such as counters and tables, have no such constraints (see Fig. 12). We believe the performance of MonolithicRL will improve as more receptacles 3D assets become available since the training distribution was only 4 receptacles. We cannot make any such claims for SPA.
+
+In the supplementary we also analyze different sensor input modalities (Appendix F.1), the surprising success of “blind" policies (Appendix F.2), the effect of different camera placements (Appendix F.3), different action spaces (Appendix F.6), the effect of the time delay on performance (Appendix F.5), and qualitative evidence of self-tracking (Appendix F.4).
+
+# 6 Home Assistant Benchmark (HAB)
+
+We now describe our benchmark of common household assistive robotic tasks. We stress that these tasks illustrate the capabilities of $\mathrm { H } 2 . 0$ but do not delineate them – a lot more is possible but not feasible to pack into a single coherent document with clear scientific takeaways.
+
+Task Definition. We study three (families of) long-range tasks that correspond to common activities:
+
+1. TidyHouse: Move 5 objects from random (unimpeded) locations back to where they belong (see Fig. 19a). This task requires no opening or closing and no objects are contained.
+
+• Start: 5 target objects objects spawned in 6 possible receptacles (excluding fridge and drawer).
+
+• Goal: Each target object is assigned a goal in a different receptacle than the starting receptacle.
+
+• Task length: 5000 steps.
+
+2. PrepareGroceries: Remove 2 objects from the fridge to the counters and place one object back in the fridge (see Fig. 19b). This task requires no opening or closing and no objects are contained.
+
+• Start: 2 target objects in the fridge and one on the left counter. The fridge is fully opened.   
+• Goal: The goal for the target objects in the fridge are on the right counter and light table. The goal for the other target object is in the fridge.   
+• Task length: 4000 steps
+
+3. SetTable: Get a bowl from a drawer, a fruit from fridge, place the fruit in the bowl on the table (see Fig. 19c).
+
+• Start: A target bowl object is in one of the drawers and a target fruit object in the middle fridge shelf. Both the fridge and drawer start closed.   
+• Goal: The goal for the bowl is on the light table, the goal for the fruit is on top of the bowl. Both the fridge and drawer must be closed.   
+• Task length: 4500 steps.
+
+The list is in increasing order of complexity – from no interaction with containers (TidyHouse), to picking and placing from the fridge container (PrepareGroceries), to opening and closing containers (SetTable). Note that these descriptions are provided purely for human understanding; the robot operates entirely from a GeometricGoal specification [9] – given by the initial and desired 3D (center-of-mass) position of each target object $i$ to be moved $\left( s _ { i } ^ { 0 } , s _ { i } ^ { * } \right) _ { i = 1 } ^ { N }$ . Thus, Pick $( s _ { i } ^ { 0 } )$ is a special case where $N = 1$ and $s _ { i } ^ { * }$ is a constant (arm resting) location. For each task episode, we sample a ReplicaCAD layout with YCB [59] objects randomly placed on feasible placement regions (see procedural clutter generation in Section 3). Each task has 5 clutter objects per receptacle. Unless specified, objects are sampled from the ‘food’ and ‘kitchen’ YCB item categories in the YCB dataset.
+
+The agent is evaluated on unseen layouts and configurations of objects, and so cannot simply memorize. We characterize task difficulty by the required number of rigid-body transitions (e.g., picking up a bowl, opening a drawer). The task evaluation, agent embodiment, sensing, and action space remain unchanged from Section 5, with the addition of base control via velocity commands. Details on episode statistics, as well as the evaluation protocols are in Appendix G.
+
+Methods. We extend the methods from Sec. 5 to better handle the above long-horizon tasks with a high-level STRIPS planner using a parameterized set of skills: Pick, Place, Open fridge door, Close fridge door, Open drawer, Close drawer, and Navigate. The full details of the planner implementation and how methods are extended are in Appendix H. Here, we provide a brief overview.
+
+1. MonolithicRL: Essentially unchanged from Sec. 5, with the exception of accepting a list of start and goal coordinates $\left( s _ { i } ^ { 0 } , s _ { i } ^ { * } \right) _ { i = 1 } ^ { N }$ , as opposed to just $s _ { 1 } ^ { 0 }$ .
+
+2. TaskPlanning $^ +$ SkillsRL $\mathbf { \hat { \Pi } } \mathbf { T P } { + } \mathbf { S R L }$ ): a hierarchical approach that assumes knowledge of a perfect task planner (implemented with STRIPS [27]) and the initial object containment needed by the task planner to break down a task into a sequence of parameterized skills: Navigate, Pick, Place, Open fridge door, Close fridge door, Open drawer, Close drawer. Each skill is functionally identical to MonolithicRL in Sec. $5 -$ taking as input a single 3D position, either $s _ { i } ^ { 0 }$ or $s _ { i } ^ { * }$ . For instance, in the SetTable task, let $( a ^ { 0 } , a ^ { * } )$ and $( b ^ { 0 ^ { * } } , b ^ { * } )$ denote the start and goal positions of the apple and bowl, respectively. The task planner converts this task into:
+
+Open Drawer Transport Bowl Close Drawer $\begin{array} { r } { \overbrace { \mathrm { ` a u r i g a t e } ( b ^ { 0 } ) } ^ { \substack { } } , \mathtt { O p e n ~ d r a w e r } ( b ^ { 0 } ) , \overbrace { \mathrm { ` e i c k } ( b ^ { 0 } ) , \mathtt { N a v i z a t e } ( b ^ { * } ) , \mathtt { P l a c e } ( b ^ { * } ) } ^ { \substack { } } , \overbrace { \mathrm { ` N a v i z a t e } ( b ^ { 0 } ) , \mathrm { C l o s s e ~ d r a w e r } ( b ^ { 0 } ) } ^ { \substack { } } , \overbrace { \mathrm { ` r a n s e ~ d r a w e r } ( b ^ { 0 } ) } ^ { \substack { } } , \overbrace { \mathrm { ` r a n s e ~ d r a w e r } ( b ^ { 0 } ) } ^ { \substack { } } , \overbrace { \mathrm { ` r a n s e ~ d r a w e r } ( b ^ { 0 } ) } ^ { \substack { } } , } \end{array}$ Navigate(a0), Open fridge door(a0) , Navigate(a⇤), Place(a⇤) , Navigate(a0), Close fridge door(a0) . {zOpen Fridge {zTransport Apple {zClose Fridge Simply listing out this sequence highlights the challenging nature of these tasks.
+
+3. TaskPlanning $^ +$ SensePlanAct $\mathbf { \left( T P + S P A \right) }$ ): Same task planner as above, with each skill implemented via SPA from Sec. 5 except for Navigate where the same learned navigation policy from $\mathbf { T P + S P A }$ is used. $\mathbf { T P + S P A }$ -Priv is analogously defined. Crafting an SPA pipeline for opening/closing unknown articulated containers is an open unsolved problem in robotics – involving detecting and tracking articulation [66, 67] without models, constrained full-body planning [68–70] without hand engineering constraints, and designing controllers to handle continuous contact [71, 72] – making it out of scope for this work. Thus, we do not report $\mathbf { T P + S P A }$ on SetTable.
+
+Results and Findings. Figure 5 shows progressive success rates for different methods on all tasks. Due to the difficulty of the full task, for analysis, the $\mathrm { X }$ -axis lists the sequence of agent-environment interactions (pick, place, open, close) required to accomplish the task, same as that used by the task-planner.4 The number of interactions is a proxy for task difficulty and the plot is analogous to precision-recall curves (with the ideal curve being a straight line at $100 \%$ ). Furthermore, since navigation is often executed between successive skills, we include versions of the task planning methods with an oracle navigation skill. We make the following observations (See Appendix I for skill learning curves and SPA failure statistics):
+
+![](images/466c4f4e555f3a5b4258f50b6975f469bf591c4386810bdaa984cd3907fe63d3.jpg)  
+Figure 5: Success rates for Home Assistant Benchmark tasks. Due to the difficulty of full HAB tasks, we analyze performance as completing a part of the overall task. For the TP methods that use an explicit navigation skill, we indicate with an arrow in the interaction names where navigation occurs and include versions for learned and oracle navigation. Results are on unseen layouts with mean and standard error computed for 100 episodes.
+
+1. MonolithicRL performs abysmally. We were able to train individual skills with RL to reasonable degrees of success (see Appendix I.2). However, crafting a combined reward function and learning scheme that elicits chaining of such skills for a long-horizon task, without any architectural inductive bias about the task structure, remained out of our reach despite prolonged effort.
+
+2. Learning a navigation policy to chain together skills is challenging as illustrated by the performance drop between learned and oracle navigation. In navigation for the sake of navigation (PointNav [10]), the agent is provided coordinates of the reachable goal location. In navigation for manipulation (Navigate), the agent is provided coordinates of a target object’s center-of-mass but needs to navigate to an unspecified non-unique suitable location from where the object is manipulable.
+
+3. Compounding errors hurt performance of task planning methods. Even with the relatively easier skills in TidyHouse in Figure 5a all methods with oracle navigation gradually decrease in performance as the number of required interactions increases.
+
+4. Sense-plan-act variants scale poorly to increasing task complexity. In the easiest setting, Tidy House with oracle navigation (Figure 5a), $\mathbf { T P + S P A }$ performs better than $\mathbf { T P + S R L }$ . However, this trend is reversed with learned navigation since $\mathbf { T P + S P A }$ methods, which rely on egocentric perception for planning, are not necessarily correctly positioned to sense the workspace. In the more complex task of PrepareGroceries (Figure 5b), $\mathbf { \hat { T } P + S R L }$ outperforms $\mathbf { T P + S P A }$ both with and without oracle navigation due to the perception challenge of the tight and cluttered fridge. $\mathbf { T P + S P A }$ fails to find a goal configuration 3x more often and fails to find a plan in the allowed time $3 \mathbf { x }$ more often in PrepareGroceries than TidyHouse.
+
+# 7 Societal Impacts, Limitations, and Conclusion
+
+ReplicaCAD was modeled upon apartments in one country (USA). Different cultures and regions may have different layouts of furniture, types of furniture, and types of objects not represented in ReplicaCAD; and this lack of representation can have negative social implications for the assistants developed. While $\mathrm { H } 2 . 0$ is a fast simulator, we find that the performance of the overall simulation+training loop is bottlenecked by factors like synchronization of parallel environments and reloading of assets upon episode reset. An exciting and complementary future direction is holistically reorganizing the rendering+physics $\scriptstyle \mathrm { + R L }$ interplay as studied by [73–78]. As illustrated in Figure 3, there is idle GPU time when rendering is faster than physics, because inference waits for both $o _ { t }$ and $s _ { t + 1 }$ to be ready despite not needing $s _ { t + 1 }$ . This is done because existing RL training systems expect the reward $r _ { t }$ to be returned when the agent takes an action $a _ { t }$ , but $r _ { t }$ is typically a function of $s _ { t } , a _ { t }$ , and $s _ { t + 1 }$ . Reorganizing the rendering $^ +$ physic $\mathrm { \ s + R L }$ interplay is an exciting problem for future work.
+
+We presented the ReplicaCAD dataset, the Habitat 2.0 platform and a home assistant benchmark. $\mathrm { H } 2 . 0$ is a fully interactive, high-performance 3D simulator that enables efficient experimentation involving embodied AI agents rearranging richly interactive 3D environments. Coupled with the ReplicaCAD data these improvements allow us to investigate the performance of RL policies against classical MP approaches for the suite of challenging rearrangement tasks we defined. We hope that the Habitat 2.0 platform will catalyze work on embodied AI for interactive environments.
+
+# 8 Acknowledgements
+
+Funding in direct support of this work: The Georgia Tech portion of this work supported by state funds from Georgia Tech (AS, ZK), NSF (DB), AFRL (DB), DARPA (DB), ONR YIPs (DB), ARO PECASE (DB), Amazon (DB). The SFU portion of this work is supported by a CIFAR AI Chair (AC), a Canada Research Chair (MS), and NSERC Discovery Grants (AC,MS). This work was also supported by FAIR (AC, EU, YZ, JT, NM, MM, DC, OM, AG, FM, WG) and Intel (VK).
+
+Additional revenues related to this work: NSF (ZK), DARPA (ZK), ONR (ZK), NGA (ZK), Samsung (ZK), Airbus (ZK), consulting for Marble Inc (ZK), paid talk by Data Science Connect (ZK), sponsored research funding by FAIR (AC,MS).
+
+# References
+
+[1] Fetch robotics. Fetch. http://fetchrobotics.com/, 2020.   
+[2] Julian Straub, Thomas Whelan, Lingni Ma, Yufan Chen, Erik Wijmans, Simon Green, Jakob J Engel, Raul Mur-Artal, Carl Ren, Shobhit Verma, et al. The replica dataset: A digital replica of indoor spaces. arXiv preprint arXiv:1906.05797, 2019.   
+[3] Manolis Savva, Abhishek Kadian, Oleksandr Maksymets, Yili Zhao, Erik Wijmans, Bhavana Jain, Julian Straub, Jia Liu, Vladlen Koltun, Jitendra Malik, et al. Habitat: A Platform for Embodied AI Research. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 9339–9347, 2019.   
+[4] Franka. Franka emika specification. https://www.franka.de, 2020.   
+[5] Unitree robotics. Aliengo. https://www.unitree.com, 2020.   
+[6] Eric Kolve, Roozbeh Mottaghi, Winson Han, Eli VanderBilt, Luca Weihs, Alvaro Herrasti, Daniel Gordon, Yuke Zhu, Abhinav Gupta, and Ali Farhadi. AI2-Thor: An interactive 3D environment for visual AI. arXiv preprint arXiv:1712.05474, 2017.   
+[7] Chuang Gan, Jeremy Schwartz, Seth Alter, Martin Schrimpf, James Traer, Julian De Freitas, Jonas Kubilius, Abhishek Bhandwaldar, Nick Haber, Megumi Sano, et al. ThreeDWorld: A platform for interactive multi-modal physical simulation. arXiv preprint arXiv:2007.04954, 2020.   
+[8] Daniel Seita, Pete Florence, Jonathan Tompson, Erwin Coumans, Vikas Sindhwani, Ken Goldberg, and Andy Zeng. Learning to Rearrange Deformable Cables, Fabrics, and Bags with Goal-Conditioned Transporter Networks. In IEEE International Conference on Robotics and Automation (ICRA), 2021.   
+[9] Dhruv Batra, Angel X Chang, Sonia Chernova, Andrew J Davison, Jia Deng, Vladlen Koltun, Sergey Levine, Jitendra Malik, Igor Mordatch, Roozbeh Mottaghi, Manolis Savva, and Hao Su. Rearrangement: A challenge for embodied AI. arXiv preprint arXiv:2011.01975, 2020.   
+[10] Peter Anderson, Angel Chang, Devendra Singh Chaplot, Alexey Dosovitskiy, Saurabh Gupta, Vladlen Koltun, Jana Kosecka, Jitendra Malik, Roozbeh Mottaghi, Manolis Savva, et al. On evaluation of embodied navigation agents. arXiv preprint arXiv:1807.06757, 2018.   
+[11] Erik Wijmans, Abhishek Kadian, Ari Morcos, Stefan Lee, Irfan Essa, Devi Parikh, Manolis Savva, and Dhruv Batra. DD-PPO: Learning near-perfect pointgoal navigators from 2.5 billion frames. In International Conference on Learning Representations (ICLR), 2020.   
+[12] Erik Wijmans, Irfan Essa, and Dhruv Batra. How to train pointgoal navigation agents on a (sample and compute) budget. arXiv preprint arXiv:2012.06117, 2020.   
+[13] Joel Ye, Dhruv Batra, Erik Wijmans, and Abhishek Das. Auxiliary tasks speed up learning pointgoal navigation. arXiv preprint arXiv:2007.04561, 2020.   
+[14] Yilun Du, Chuang Gan, and Phillip Isola. Curious representation learning for embodied intelligence. arXiv preprint arXiv:2105.01060, 2021.   
+[15] Peter Karkus, Shaojun Cai, and David Hsu. Differentiable slam-net: Learning particle slam for visual navigation. In Proceedings of IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2021.   
+[16] Claudia Pérez-D’Arpino, Can Liu, Patrick Goebel, Roberto Martín-Martín, and Silvio Savarese. Robot navigation in constrained pedestrian environments using reinforcement learning. In Proceedings of IEEE International Conference on Robotics and Automation (ICRA), 2021.   
+[17] Santhosh K. Ramakrishnan, Ziad Al-Halah, and Kristen Grauman. Occupancy anticipation for efficient exploration and navigation. In ECCV, 2020.   
+[18] Somil Bansal, Varun Tolani, Saurabh Gupta, Jitendra Malik, and Claire Tomlin. Combining optimal control and learning for visual navigation in novel environments. In Conference on Robot Learning (CoRL), 2019.   
+[19] Fei Xia, Chengshu Li, Roberto Martín-Martín, Or Litany, Alexander Toshev, and Silvio Savarese. Relmogen: Leveraging motion generation in reinforcement learning for mobile manipulation. In Proceedings of IEEE International Conference on Robotics and Automation (ICRA), 2021.   
+[20] Dhruv Batra, Aaron Gokaslan, Aniruddha Kembhavi, Oleksandr Maksymets, Roozbeh Mottaghi, Manolis Savva, Alexander Toshev, and Erik Wijmans. Objectnav revisited: On evaluation of embodied agents navigating to objects. arXiv preprint arXiv:2006.13171, 2020.   
+[21] Alexander Ku, Peter Anderson, Roma Patel, Eugene Ie, and Jason Baldridge. Room-across-room: Multilingual vision-and-language navigation with dense spatiotemporal grounding. arXiv preprint arXiv:2010.07954, 2020.   
+[22] Peter Anderson, Qi Wu, Damien Teney, Jake Bruce, Mark Johnson, Niko Sünderhauf, Ian Reid, Stephen Gould, and Anton Van Den Hengel. Vision-and-language navigation: Interpreting visually-grounded navigation instructions in real environments. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 3674–3683, 2018.   
+[23] Adithyavairavan Murali, Arsalan Mousavian, Clemens Eppner, Chris Paxton, and Dieter Fox. 6-dof grasping for target-driven object manipulation in clutter. In 2020 IEEE International Conference on Robotics and Automation (ICRA), pages 6232–6238. IEEE, 2020.   
+[24] Jeannette Bohg, Antonio Morales, Tamim Asfour, and Danica Kragic. Data-driven grasp synthesis—a survey. IEEE Transactions on Robotics, 30(2):289–309, 2013.   
+[25] Kaiyu Hang, Miao Li, Johannes A Stork, Yasemin Bekiroglu, Florian T Pokorny, Aude Billard, and Danica Kragic. Hierarchical fingertip space: A unified framework for grasp planning and in-hand grasp adaptation. IEEE Transactions on robotics, 32(4):960–972, 2016.   
+[26] Robin R Murphy. Introduction to AI robotics. MIT press, 2019.   
+[27] Richard E Fikes and Nils J Nilsson. Strips: A new approach to the application of theorem proving to problem solving. Artificial intelligence, 2(3-4):189–208, 1971.   
+[28] Emanuel Todorov, Tom Erez, and Yuval Tassa. Mujoco: A physics engine for model-based control. In 2012 IEEE/RSJ International Conference on Intelligent Robots and Systems, pages 5026–5033. IEEE, 2012.   
+[29] Nvidia. Isaac Sim. https://developer.nvidia.com/isaac-sim, 2020.   
+[30] Greg Brockman, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang, and Wojciech Zaremba. Openai gym. arXiv preprint arXiv:1606.01540, 2016.   
+[31] Marc G Bellemare, Yavar Naddaf, Joel Veness, and Michael Bowling. The arcade learning environment: An evaluation platform for general agents. Journal of Artificial Intelligence Research, 47:253–279, 2013.   
+[32] Yuval Tassa, Yotam Doron, Alistair Muldal, Tom Erez, Yazhe Li, Diego de Las Casas, David Budden, Abbas Abdolmaleki, Josh Merel, Andrew Lefrancq, et al. Deepmind control suite. arXiv preprint arXiv:1801.00690, 2018.   
+[33] Kiana Ehsani, Winson Han, Alvaro Herrasti, Eli VanderBilt, Luca Weihs, Eric Kolve, Aniruddha Kembhavi, and Roozbeh Mottaghi. ManipulaTHOR: A framework for visual object manipulation. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, 2021.   
+[34] Fanbo Xiang, Yuzhe Qin, Kaichun Mo, Yikuan Xia, Hao Zhu, Fangchen Liu, Minghua Liu, Hanxiao Jiang, Yifu Yuan, He Wang, Li Yi, Angel X. Chang, Leonidas J. Guibas, and Hao Su. SAPIEN: A simulated part-based interactive environment. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2020.   
+[35] Stephen James, Zicong Ma, David Rovick Arrojo, and Andrew J Davison. Rlbench: The robot learning benchmark & learning environment. IEEE Robotics and Automation Letters, 5(2):3019–3026, 2020.   
+[36] Bokui Shen, Fei Xia, Chengshu Li, Roberto Martın-Martın, Linxi Fan, Guanzhi Wang, Shyamal Buch, Claudia D’Arpino, Sanjana Srivastava, Lyne P Tchapmi, Kent Vainio, Li Fei-Fei, and Silvio Savarese. iGibson, a simulation environment for interactive tasks in large realistic scenes. arXiv preprint, 2020.   
+[37] Erwin Coumans and Yunfei Bai. PyBullet, a Python module for physics simulation for games, robotics and machine learning. http://pybullet.org, 2016–2019.   
+[38] Jeongseok Lee, Michael X Grey, Sehoon Ha, Tobias Kunz, Sumit Jain, Yuting Ye, Siddhartha S Srinivasa, Mike Stilman, and C Karen Liu. Dart: Dynamic animation and robotics toolkit. Journal of Open Source Software, 3(22):500, 2018.   
+[39] R Smith. ODE: Open Dynamics Engine. http://www.ode.org/, 01 2009.   
+[40] Nvidia. PhysX. https://developer.nvidia.com/gameworks-physx-overview.   
+[41] Nvidia. FleX. https://developer.nvidia.com/flex, 2020.   
+[42] Hammad Mazhar, Toby Heyn, Arman Pazouki, Dan Melanz, Andrew Seidl, Aaron Bartholomew, Alessandro Tasora, and Dan Negrut. CHRONO: A parallel multi-physics library for rigid-body, flexible-body, and fluid dynamics. Mechanical Sciences, 4:49–64, 02 2013. doi: 10.5194/ms-4-49-2013. URL https://projectchrono.org/.   
+[43] Vladimír Vondruš and contributors. Magnum. https://magnum.graphics, 2020.   
+[44] Lilian Weng Maciek Chociej, Peter Welinder. Orrb: Openai remote rendering backend. In eprint arXiv, 2019. URL https://arxiv.org/abs/1906.11633.   
+[45] Matthew Matl. Pyrender. https://github.com/mmatl/pyrender, 2020.   
+[46] Unity Technologies. Unity. https://unity.com/.   
+[47] Epic Games. Unreal Engine. https://www.unrealengine.com/.   
+[48] Manolis Savva, Angel X. Chang, Alexey Dosovitskiy, Thomas Funkhouser, and Vladlen Koltun. MINOS: Multimodal indoor simulator for navigation in complex environments. arXiv:1712.03931, 2017.   
+[49] Yi Wu, Yuxin Wu, Georgia Gkioxari, and Yuandong Tian. Building generalizable agents with a realistic and rich 3d environment. arXiv preprint arXiv:1801.02209, 2018.   
+[50] Claudia Yan, Dipendra Misra, Andrew Bennnett, Aaron Walsman, Yonatan Bisk, and Yoav Artzi. Chalet: Cornell house agent learning environment. arXiv preprint arXiv:1801.07357, 2018.   
+[51] Xavier Puig, Kevin Ra, Marko Boben, Jiaman Li, Tingwu Wang, Sanja Fidler, and Antonio Torralba. VirtualHome: Simulating household activities via programs. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 8494–8502, 2018.   
+[52] Fei Xia, William B Shen, Chengshu Li, Priya Kasimbeg, Micael Edmond Tchapmi, Alexander Toshev, Roberto Martín-Martín, and Silvio Savarese. Interactive gibson benchmark: A benchmark for interactive navigation in cluttered environments. IEEE Robotics and Automation Letters, 5(2):713–720, 2020.   
+[53] HeeSun Choi, Cindy Crump, Christian Duriez, Asher Elmquist, Gregory Hager, David Han, Frank Hearl, Jessica Hodgins, Abhinandan Jain, Frederick Leve, Chen Li, Franziska Meier, Dan Negrut, Ludovic Righetti, Alberto Rodriguez, Jie Tan, and Jeff Trinkle. On the use of simulation in robotics: Opportunities, challenges, and suggestions for moving forward. Proceedings of the National Academy of Sciences, 118(1), 2021. ISSN 0027-8424. doi: 10.1073/pnas.1907856118. URL https://www.pnas.org/ content/118/1/e1907856118.   
+[54] Caelan Reed Garrett, Rohan Chitnis, Rachel Holladay, Beomjoon Kim, Tom Silver, Leslie Pack Kaelbling, and Tomás Lozano-Pérez. Integrated task and motion planning. arXiv preprint arXiv:2010.01083, 2020.   
+[55] Caelan Reed Garrett, Chris Paxton, Tomás Lozano-Pérez, Leslie Pack Kaelbling, and Dieter Fox. Online replanning in belief space for partially observable task and motion problems. In IEEE International Conference on Robotics and Automation (ICRA), 2020.   
+[56] Dipendra Misra, Andrew Bennett, Valts Blukis, Eyvind Niklasson, Max Shatkhin, and Yoav Artzi. Mapping instructions to actions in 3d environments with visual goal prediction. arXiv preprint arXiv:1809.00786, 2018.   
+[57] Mohit Shridhar, Jesse Thomason, Daniel Gordon, Yonatan Bisk, Winson Han, Roozbeh Mottaghi, Luke Zettlemoyer, and Dieter Fox. Alfred: A benchmark for interpreting grounded instructions for everyday tasks. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pages 10740–10749, 2020.   
+[58] Luca Weihs, Matt Deitke, Aniruddha Kembhavi, and Roozbeh Mottaghi. Visual room rearrangement. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, 2021.   
+[59] Berk Calli, Arjun Singh, Aaron Walsman, Siddhartha Srinivasa, Pieter Abbeel, and Aaron M Dollar. The YCB object and model set: Towards common benchmarks for manipulation research. In 2015 international conference on advanced robotics (ICAR), pages 510–517. IEEE, 2015.   
+[60] Abhishek Kadian, Joanne Truong, Aaron Gokaslan, Alexander Clegg, Erik Wijmans, Stefan Lee, Manolis Savva, Sonia Chernova, and Dhruv Batra. Sim2real predictivity: Does evaluation in simulation predict real-world performance? IEEE Robotics and Automation Letters, 5(4):6670–6677, 2020.   
+[61] Simon Thorpe, Denis Fize, and Catherine Marlot. Speed of processing in the human visual system. nature, 381(6582):520–522, 1996.   
+[62] Sandeep Singh Sandha, Luis Garcia, Bharathan Balaji, Fatima M Anwar, and Mani Srivastava. Sim2real transfer for deep reinforcement learning with stochastic state transition delays. CoRL 2020, 2020.   
+[63] Gabriel Dulac-Arnold, Nir Levine, Daniel J. Mankowitz, Jerry Li, Cosmin Paduraru, Sven Gowal, and Todd Hester. An empirical investigation of the challenges of real-world reinforcement learning. arXiv preprint, 2020.   
+[64] Jie Tan, Tingnan Zhang, Erwin Coumans, Atil Iscen, Yunfei Bai, Danijar Hafner, Steven Bohez, and Vincent Vanhoucke. Sim-to-real: Learning agile locomotion for quadruped robots. RSS 14, 2018.   
+[65] Steven M LaValle. Planning algorithms. Cambridge university press, 2006.   
+[66] Tanner Schmidt, Richard A Newcombe, and Dieter Fox. Dart: Dense articulated real-time tracking. In Robotics: Science and Systems, volume 2. Berkeley, CA, 2014.   
+[67] Richard Sahala Hartanto, Ryoichi Ishikawa, Menandro Roxas, and Takeshi Oishi. Hand-motion-guided articulation and segmentation estimation. In 2020 29th IEEE International Conference on Robot and Human Interactive Communication (RO-MAN), pages 807–813. IEEE, 2020.   
+[68] Dmitry Berenson, Siddhartha Srinivasa, and James Kuffner. Task space regions: A framework for poseconstrained manipulation planning. The International Journal of Robotics Research, 30(12):1435–1460, 2011.   
+[69] Felix Burget, Armin Hornung, and Maren Bennewitz. Whole-body motion planning for manipulation of articulated objects. In 2013 IEEE International Conference on Robotics and Automation, pages 1656–1662. IEEE, 2013.   
+[70] Zachary Kingston, Mark Moll, and Lydia E Kavraki. Sampling-based methods for motion planning with constraints. Annual review of control, robotics, and autonomous systems, 1:159–185, 2018.   
+[71] Wim Meeussen, Melonee Wise, Stuart Glaser, Sachin Chitta, Conor McGann, Patrick Mihelich, Eitan Marder-Eppstein, Marius Muja, Victor Eruhimov, Tully Foote, et al. Autonomous door opening and plugging in with a personal robot. In 2010 IEEE International Conference on Robotics and Automation, pages 729–736. IEEE, 2010.   
+[72] Advait Jain and Charles C Kemp. Pulling open doors and drawers: Coordinating an omni-directional base and a compliant arm with equilibrium point control. In 2010 IEEE International Conference on Robotics and Automation, pages 1807–1814. IEEE, 2010.   
+[73] Steven Dalton, Iuri Frosio, and Michael Garland. Accelerating reinforcement learning through gpu atari emulation. In Conference on Neural Information Processing Systems (NeurIPS), 2020.   
+[75] Lasse Espeholt, Hubert Soyer, Remi Munos, Karen Simonyan, Vlad Mnih, Tom Ward, Yotam Doron, Vlad Firoiu, Tim Harley, Iain Dunning, et al. Impala: Scalable distributed deep-rl with importance weighted actor-learner architectures. In International Conference on Machine Learning, pages 1407–1416. PMLR, 2018.   
+[76] Lasse Espeholt, Raphaël Marinier, Piotr Stanczyk, Ke Wang, and Marcin Michalski. Seed rl: Scalable and efficient deep-rl with accelerated central inference. arXiv preprint arXiv:1910.06591, 2019.   
+[77] Aleksei Petrenko, Zhehui Huang, Tushar Kumar, Gaurav Sukhatme, and Vladlen Koltun. Sample factory: Egocentric 3D control from pixels at 100000 FPS with asynchronous reinforcement learning. In International Conference on Machine Learning, pages 7652–7662. PMLR, 2020.   
+[78] Brennan Shacklett, Erik Wijmans, Aleksei Petrenko, Manolis Savva, Dhruv Batra, Vladlen Koltun, and Kayvon Fatahalian. Large batch simulation for deep reinforcement learning. In International Conference on Learning Representations (ICLR), 2021. URL https://openreview.net/forum? id=cP5IcoAkfKa.   
+[79] Binomial LLC. Basis universal. https://github.com/BinomialLLC/basis_universal, 2020.   
+[80] Ioan A Sucan, Mark Moll, and Lydia E Kavraki. The open motion planning library. IEEE Robotics & Automation Magazine, 19(4):72–82, 2012.   
+[81] John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347, 2017.   
+[82] Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.   
+[83] David Coleman, Ioan Sucan, Sachin Chitta, and Nikolaus Correll. Reducing the barrier to entry of complex robotic software: a moveit! case study. arXiv preprint arXiv:1404.3785, 2014.   
+[84] James J Kuffner and Steven M LaValle. Rrt-connect: An efficient approach to single-query path planning. In Proceedings 2000 ICRA. Millennium Conference. IEEE International Conference on Robotics and Automation. Symposia Proceedings (Cat. No. 00CH37065), volume 2, pages 995–1001. IEEE, 2000.   
+[85] Yoshiaki Kuwata, Gaston A Fiore, Justin Teo, Emilio Frazzoli, and Jonathan P How. Motion planning for urban driving using rrt. In 2008 IEEE/RSJ International Conference on Intelligent Robots and Systems, pages 1681–1686. IEEE, 2008.   
+[86] Nathan Ratliff, Matt Zucker, J Andrew Bagnell, and Siddhartha Srinivasa. Chomp: Gradient optimization techniques for efficient motion planning. In 2009 IEEE International Conference on Robotics and Automation, pages 489–494. IEEE, 2009.   
+[87] John Schulman, Yan Duan, Jonathan Ho, Alex Lee, Ibrahim Awwal, Henry Bradlow, Jia Pan, Sachin Patil, Ken Goldberg, and Pieter Abbeel. Motion planning with sequential convex optimization and convex collision checking. The International Journal of Robotics Research, 33(9):1251–1270, 2014.   
+[88] Carlos Hernandez, Mukunda Bharatheesha, Wilson Ko, Hans Gaiser, Jethro Tan, Kanter van Deurzen, Maarten de Vries, Bas Van Mil, Jeff van Egmond, Ruben Burger, et al. Team delft’s robot winner of the amazon picking challenge 2016. In Robot World Cup, pages 613–624. Springer, 2016.   
+[89] Mustafa Mukadam, Jing Dong, Xinyan Yan, Frank Dellaert, and Byron Boots. Continuous-time gaussian process motion planning via probabilistic inference. The International Journal of Robotics Research, 37 (11):1319–1340, 2018.   
+[90] Brian Ichter, James Harrison, and Marco Pavone. Learning sampling distributions for robot motion planning. In 2018 IEEE International Conference on Robotics and Automation (ICRA), pages 7087–7094. IEEE, 2018.   
+[91] Brian Hou, Sanjiban Choudhury, Gilwoo Lee, Aditya Mandalika, and Siddhartha S Srinivasa. Posterior sampling for anytime motion planning on graphs with expensive-to-evaluate edges. In 2020 IEEE International Conference on Robotics and Automation (ICRA), pages 4266–4272. IEEE, 2020.   
+[92] Fahad Islam, Chris Paxton, Clemens Eppner, Bryan Peele, Maxim Likhachev, and Dieter Fox. Alternative paths planner (app) for provably fixed-time manipulation planning in semi-structured environments. arXiv preprint arXiv:2012.14970, 2020.   
+[93] Michael Pantic, Lionel Ott, Cesar Cadena, Roland Siegwart, and Juan Nieto. Mesh manifold based riemannian motion planning for omnidirectional micro aerial vehicles. arXiv preprint arXiv:2102.10313, 2021.   
+[94] Jonathan D Gammell, Siddhartha S Srinivasa, and Timothy D Barfoot. Informed rrt\*: Optimal samplingbased path planning focused via direct sampling of an admissible ellipsoidal heuristic. In 2014 IEEE/RSJ International Conference on Intelligent Robots and Systems, pages 2997–3004. IEEE, 2014.   
+[95] Jonathan D Gammell, Siddhartha S Srinivasa, and Timothy D Barfoot. Batch informed trees (bit\*): Sampling-based optimal planning via the heuristically guided search of implicit random geometric graphs. In 2015 IEEE international conference on robotics and automation (ICRA), pages 3067–3074. IEEE, 2015.   
+[96] Daniel Kappler, Franziska Meier, Jan Issac, Jim Mainprice, Cristina Garcia Cifuentes, Manuel Wüthrich, Vincent Berenz, Stefan Schaal, Nathan Ratliff, and Jeannette Bohg. Real-time perception meets reactive motion generation. IEEE Robotics and Automation Letters, 3(3):1864–1871, 2018.   
+[97] Morgan Quigley, Ken Conley, Brian Gerkey, Josh Faust, Tully Foote, Jeremy Leibs, Rob Wheeler, and Andrew Y Ng. Ros: an open-source robot operating system. In ICRA workshop on open source software, volume 3, page 5. Kobe, Japan, 2009.   
+[98] Aleksandra Faust, Kenneth Oslund, Oscar Ramirez, Anthony Francis, Lydia Tapia, Marek Fiser, and James Davidson. Prm-rl: Long-range robotic navigation tasks by combining reinforcement learning and sampling-based planning. In 2018 IEEE International Conference on Robotics and Automation (ICRA), pages 5113–5120. IEEE, 2018.   
+[99] Mohak Bhardwaj, Byron Boots, and Mustafa Mukadam. Differentiable gaussian process motion planning. In 2020 IEEE International Conference on Robotics and Automation (ICRA), pages 10598–10604. IEEE, 2020.   
+[100] Dmitry Berenson, Siddhartha S Srinivasa, Dave Ferguson, and James J Kuffner. Manipulation planning on constraint manifolds. In 2009 IEEE international conference on robotics and automation, pages 625–632. IEEE, 2009.   
+[101] Naoki Yokoyama, Sehoon Ha, and Dhruv Batra. Success weighted by completion time: A dynamics-aware evaluation criteria for embodied navigation. arXiv preprint arXiv:2103.08022, 2021.   
+[102] Ilya Kostrikov, Denis Yarats, and Rob Fergus. Image augmentation is all you need: Regularizing deep reinforcement learning from pixels. In International Conference on Learning Representations (ICLR), 2021.   
+[103] Ramprasaath R. Selvaraju, Michael Cogswell, Abhishek Das, Ramakrishna Vedantam, Devi Parikh, and Dhruv Batra. Grad-cam: Visual explanations from deep networks via gradient-based localization. In Proceedings of the IEEE International Conference on Computer Vision (ICCV), 2017.   
+[104] Akanksha Atrey, Kaleigh Clary, and David Jensen. Exploratory not explanatory: Counterfactual analysis of saliency maps for deep reinforcement learning. In International Conference on Learning Representations (ICLR), 2020. URL https://openreview.net/forum?id=rkl3m1BFDB.   
+[105] Julius Adebayo, Justin Gilmer, Ian Goodfellow, Moritz Hardt, and Been Kim. Sanity checks for saliency maps. In Conference on Neural Information Processing Systems (NeurIPS), 2018.
+
+# Checklist
+
+1. For all authors...
+
+(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   
+(b) Did you describe the limitations of your work? [Yes] See second paragraph of Sec. 7.   
+(c) Did you discuss any potential negative societal impacts of your work? [Yes] See the first paragraph of Sec. 7.   
+(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes]
+
+2. If you are including theoretical results...
+
+(a) Did you state the full set of assumptions of all theoretical results? [N/A] b) Did you include complete proofs of all theoretical results? [N/A]
+
+3. If you ran experiments...
+
+(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes] Code and setup instructions can be found at https://github.com/facebookresearch/habitat-lab.   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] All methods and training details are described in detail in Sec. H.   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes] Results in Sec. 5 are over three random seeds and 600 episodes each. Results in Sec. F.1 and Sec. F.3 are over 10 random seeds and 500 episodes each. Finally, results in Sec. 6 are over 100 episodes.   
+(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] Compute resources for the benchmark are described in Section 4, for RL training in Appendix C.2, and for motion planning in Appendix D.
+
+4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...
+
+(a) If your work uses existing assets, did you cite the creators? [Yes] Cited [59] for use of the YCB objects.   
+(b) Did you mention the license of the assets? [Yes] ReplicaCAD is released under the Creative Commons license and $\mathrm { H } 2 . 0$ is open-sourced under the MIT license   
+(c) Did you include any new assets either in the supplemental material or as a URL? [Yes] The ReplicaCAD dataset will be made publicly available for free prior to publication under the Creative Commons license. Download instructions can be found at https://github.com/facebookresearch/habitatlab.   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] The released ReplicaCAD dataset includes furniture layouts and common kitchen items. There is no identifiable or offensive content.
+
+5. If you used crowdsourcing or conducted research with human subjects...
+
+(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   
+(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   
+(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A]

parse/train/H1lGHsA9KX/H1lGHsA9KX.md

@@ -0,0 +1,321 @@
+# A RESIZABLE MINI-BATCH GRADIENT DESCENT BASED ON A MULTI-ARMED BANDIT
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Determining the appropriate batch size for mini-batch gradient descent is always time consuming as it often relies on grid search. This paper considers a resizable mini-batch gradient descent (RMGD) algorithm based on a multi-armed bandit that achieves performance equivalent to that of best fixed batch-size. At each epoch, the RMGD samples a batch size according to a certain probability distribution proportional to a batch being successful in reducing the loss function. Sampling from this probability provides a mechanism for exploring different batch size and exploiting batch sizes with history of success. After obtaining the validation loss at each epoch with the sampled batch size, the probability distribution is updated to incorporate the effectiveness of the sampled batch size. Experimental results show that the RMGD achieves performance better than the best performing single batch size. It is surprising that the RMGD achieves better performance than grid search. Furthermore, it attains this performance in a shorter amount of time than grid search.
+
+# 1 INTRODUCTION
+
+Gradient descent (GD) is a common optimization algorithm for finding the minimum of the expected loss. It takes iterative steps proportional to the negative gradient of the loss function at each iteration. It is based on the observation that if the multi-variable loss functions $f ( w )$ is differentiable at point $\pmb { w }$ , then $f ( w )$ decreases fastest in the direction of the negative gradient of $f$ at $\textbf { \em w }$ , i.e., $- \nabla f ( \boldsymbol { w } )$ . The model parameters are updated iteratively in GD as follows:
+
+$$
+\pmb { w } _ { t + 1 } = \pmb { w } _ { t } - \eta _ { t } \pmb { g } _ { t } , \qquad \pmb { g } _ { t } = \nabla _ { \pmb { w } } f \big ( \pmb { w } _ { t } \big )
+$$
+
+where ${ \mathbf { } } w _ { t } , { \mathbf { } } g _ { t }$ , and $\eta _ { t }$ are the model parameters, gradients of $f$ with respect to $\pmb { w }$ , and learning rate at time $t$ respectively. For small enough $\eta _ { t }$ , ${ f ( \pmb { w } _ { t } ) \geq f ( \pmb { w } _ { t + 1 } ) }$ and ultimately the sequence of ${ \pmb w } _ { t }$ will move down toward a local minimum. For a convex loss function, GD is guaranteed to converge to a global minimum with an appropriate learning rate.
+
+There are various issues to consider in gradient-based optimization. First, GD can be extremely slow and impractical for large dataset: gradients of all the data have to be evaluated for each iteration. With larger data size, the convergence rate, the computational cost and memory become critical, and special care is required to minimize these factors. Second, for non-convex function which is often encountered in deep learning, GD can get stuck in a local minimum without the hope of escaping. Third, stochastic gradient descent (SGD), which is based on the gradient of a single training sample, has large gradient variance, and it requires a large number of iterations. This ultimately translates to slow convergence. Mini-batch gradient descent (MGD), which is based on the gradient over a small batch of training data, trades off between the robustness of SGD and the stability of GD. There are three advantages for using MGD over GD and SGD: 1) The batching allows both the efficiency of memory usage and implementations; 2) The model update frequency is higher than GD which allows for a more robust convergence avoiding local minimum; 3) MGD requires less iteration per epoch and provides a more stable update than SGD. For these reasons, MGD has been a popular algorithm for machine learning. However, selecting an appropriate batch size is difficult. Various studies suggest that there is a close link between performance and batch size used in MGD Breuel (2015); Keskar et al. (2016); Wilson & Martinez (2003).
+
+There are various guidelines for selecting a batch size but have not been completely practical Bengio (2012). Grid search is a popular method but it comes at the expense of search time. There are a small number of adaptive MGD algorithms to replace grid search Byrd et al. (2012); De et al. (2016); Friedlander & Schmidt (2012). These algorithms increase the batch size gradually according to their own criterion. However, these algorithms are based on convex loss function and hard to be applied to deep learning. For non-convex optimization, it is difficult to determine the optimal batch size for best performance.
+
+This paper considers a resizable mini-batch gradient descent (RMGD) algorithm based on a multi-armed bandit for achieving best performance in grid search by selecting an appropriate batch size at each epoch with a probability defined as a function of its previous success/failure. At each epoch, RMGD samples a batch size from its probability distribution, then uses the selected batch size for mini-batch gradient descent. After obtaining the validation loss at each epoch, the probability distribution is updated to incorporate the effectiveness of the sampled batch size. The benefit of RMGD is that it avoids the need for cumbersome grid search to achieve best performance and that it is simple enough to apply to any optimization algorithm using MGD. The detailed algorithm of RMGD are described in Section 4, and experimental results are presented in Section 5.
+
+# 2 RELATED WORKS
+
+There are only a few published results on the topic of batch size. It was empirically shown that SGD converged faster than GD on a large speech recognition database Wilson & Martinez (2003). It was determined that the range of learning rate resulting in low test errors was considerably getting smaller as the batch size increased on convolutional neural networks and that small batch size yielded the best test error, while large batch size could not yield comparable low error rate Breuel (2015). It was observed that larger batch size are more liable to converge to a sharp local minimum thus leading to poor generalization Keskar et al. (2016). It was found that the learning rate and the batch size controlled the trade-off between the depth and width of the minima in MGD Jastrzkebski et al. (2017).
+
+A small number of adaptive MGD algorithms have been proposed. Byrd et al. (2012) introduced a methodology for using varying sample size in MGD. A relatively small batch size is chosen at the start, then the algorithm chooses a larger batch size when the optimization step does not produce improvement in the target objective function. They assumed that using a small batch size allowed rapid progress in the early stages, while a larger batch size yielded high accuracy. However, this assumption did not corresponded with later researches that reported the degradation of performance with large batch size Breuel (2015); Keskar et al. (2016); Mishkin et al. (2017). Another similar adaptive algorithm, which increases the batch size gradually as the iteration proceeded, was done by Friedlander & Schmidt (2012). The algorithm uses relatively few samples to approximate the gradient, and gradually increase the number of samples with a constant learning rate. It was observed that increasing the batch size is more effective than decaying the learning rate for reducing the number of iterations Smith et al. (2017). However, these increasing batch size algorithms lack flexibility since it is unidirectional. Balles et al. (2017) proposed a dynamic batch size adaptation algorithm. It estimates the variance of the stochastic gradients and adapts the batch size to decrease the variance. However, this algorithm needs to find the gradient variance and its computation depends on the number of model parameters.
+
+Batch size can also be considered as a hyperparameter, and there have been some proposals based on bandit-based hyperparameter (but not batch size) optimization which maybe applicable for determining the best fixed batch size. Jamieson & Talwalkar (2016) introduced a successive halving algorithm. This algorithm uniformly allocates a budget to a set of hyperparameter configurations, evaluates the performance of all configurations, and throws out the worst half until one configuration remains. Li et al. (2017) introduced a novel bandit-based hyperparameter optimization algorithm referred as HYPERBAND. This algorithm considers the optimization problem as a resource allocation problem. The two algorithms mentioned above are not adaptive, and for searching a small hyperparameter space, the two algorithms will not be very effective. The experimental results in this paper show that adaptive MGD tends to perform better than fixed MGD.
+
+![](images/7619fd884b27a622e03c3e2bfb5a3c0751a4da065c099123a0658a0a63f79262.jpg)  
+Figure 1: An overall framework of considered resizable mini-batch gradient descent algorithm (RMGD). The RMGD samples a batch size from a probability distribution, and parameters are updated by mini-batch gradient using the selected batch size. Then the probability distribution is updated by checking the validation loss.
+
+# 3 SETUP
+
+Let $\boldsymbol { B } = \{ b _ { k } \} _ { k = 1 } ^ { K }$ be the set of possible batch size and $\pmb { \pi } = \{ \pi ^ { k } \} _ { k = 1 } ^ { K }$ be the probability distribution of batch size where $b _ { k } , \pi ^ { k }$ , and $K$ are the $k ^ { \mathrm { t h } }$ batch size, the probability of $b _ { k }$ to be selected, and number of batch sizes respectively. This paper considers algorithm for multi-armed bandit over $\boldsymbol { B }$ according to Algorithm 1. Let $\mathbf { \boldsymbol { w } } _ { \tau } \in \mathcal { W }$ be the model parameters at epoch $\tau$ , and $\tilde { \mathbf { \ b { w } } } _ { t }$ be the temporal parameters at sub iteration $t$ . Let $J : \mathcal { W }  \mathbb { R }$ be the training loss function and let $\mathbf { \delta } \mathbf { \mathbf { { g } } } = \nabla J ( \mathbf { \delta } \mathbf { \mathbf { { w } } } )$ be the gradients of training loss function with respect to the model parameters. $\eta _ { \tau }$ is the learning rate at epoch $\tau$ . Let $\ell : \mathcal { W } \to \mathbb { R }$ be the validation loss function, and $y ^ { k } \in \{ 0 , \dot { 1 } \}$ be the cost of choosing the batch size $b _ { k }$ . In here, $y ^ { k } = 0$ if the validation loss decreases by the selected batch size $b _ { k }$ (well-updating) and $y ^ { k } = 1$ otherwise (misupdating). The aim of the algorithm is to have low misupdating. For the cost function $y ^ { k }$ , graduated losses such as hinge loss and percentage of nonnegative changes in validation loss can be variations of 0-1 loss. However, there are no differences in regret bound among them in this setting and it is experimentally confirmed that there are little performance gaps among them. Therefore, this paper introduces the 0-1 loss, which is simple and basic.
+
+# 4 RESIZABLE MINI-BATCH GRADIENT DESCENT
+
+The resizable mini-batch gradient descent (RMGD) sets the batch sizes as multi arms, and at each epoch it samples one of the batch sizes from probability distribution. Then, it suffers a cost of selecting this batch size. Using the cost, probability distribution is updated.
+
+# 4.1 ALGORITHMS
+
+The overall framework of the RMGD algorithm is shown in Figure 1. The RMGD consists of two components: batch size selector and parameter optimizer. The selector samples a batch size from probability distribution and updates the distribution. The optimizer is usual mini-batch gradient.
+
+Selector samples a batch size $b _ { k _ { \tau } } \in B$ from the probability distribution $\pi _ { \tau }$ at each epoch $\tau$ where $k _ { \tau }$ is selected index. Here $b _ { k }$ is associated with probability $\pi ^ { k }$ . The selected batch size $b _ { k _ { \tau } }$ is applied to optimizer for MGD at each epoch, and the selector gets cost $y ^ { k _ { \tau } }$ from optimizer. Then, the selector
+
+# Algorithm 1 Resizable Mini-batch Gradient Descent
+
+#
+
+$\begin{array} { r } { B = \{ b _ { k } \} _ { k = 1 } ^ { K } : } \end{array}$ Set of batch sizes $\pi _ { 0 } = \{ 1 / K , \ldots , 1 / K \}$ : Prior probability distribution
+
+# Procedure:
+
+1: Initialize model parameters $\pmb { w } _ { 0 }$   
+2: for epoch $\tau = 0 , 1 , 2 , \dots$   
+3: Select batch size $b _ { k _ { \tau } } \in B$ from $\pi _ { \tau }$   
+4: Set temporal parameters $\tilde { \mathbf { { w } } } _ { 0 } = \mathbf { w } _ { \tau }$   
+5: for $t = 0 , 1 , \ldots , T - 1$ where $T = \lceil m / b _ { k _ { \tau } } \rceil$   
+6: Compute gradient $\pmb { g } _ { t } = \nabla J ( \tilde { \pmb { w } } _ { t } )$   
+7: Update $\tilde { \pmb { w } } _ { t + 1 } = \tilde { \pmb { w } } _ { t } - \eta _ { \tau } \pmb { g } _ { t }$   
+8: end for   
+9: Update ${ \pmb w } _ { \tau + 1 } = \tilde { { \pmb w } } _ { T }$   
+10: Observe validation loss $\ell ( w _ { \tau + 1 } )$   
+11: if $\ell ( \pmb { w } _ { \tau + 1 } ) < \ell ( \pmb { w } _ { \tau } )$   
+12: Get cost $y ^ { k _ { \tau } } = 0$   
+13: else   
+14: Get cost $y ^ { k _ { \tau } } = 1$   
+15: end if   
+16: for $i = 1 , 2 , \dots , K$   
+17: if $i = k _ { \tau }$   
+18: Set temporal probability π˜i = πi e−βykτ /πiτ   
+19: else   
+20: Set temporal probability $\tilde { \pi } ^ { i } = \pi _ { \tau } ^ { i }$   
+21: end if   
+22: end for   
+23: Update $\begin{array} { r } { \forall i \in [ K ] , \pi _ { \tau + 1 } ^ { i } = \tilde { \pi } ^ { i } / \sum _ { j } \tilde { \pi } ^ { j } } \end{array}$   
+24: end for
+
+updates probabilities by randomized weighted majority,
+
+$$
+\begin{array} { r l } { \mathrm { f o r } i = k _ { \tau } , } & { \tilde { \pi } ^ { i } = \pi _ { \tau } ^ { i } e ^ { - \beta y ^ { k _ { \tau } } / \pi _ { \tau } ^ { i } } } \\ { \mathrm { f o r } i \neq k _ { \tau } , } & { \tilde { \pi } ^ { i } = \pi _ { \tau } ^ { i } } \\ { \forall i , } & { \pi _ { \tau + 1 } ^ { i } = \tilde { \pi } ^ { i } / \sum _ { j } \tilde { \pi } ^ { j } } \end{array}
+$$
+
+where $\beta \in ( 0 , 1 )$ is positive hyperparameter. When $\tau = 0$ , $\pi _ { \tau } = \{ 1 / K , \ldots , 1 / K \}$
+
+Optimizer updates the model parameters $\pmb { w }$ . For each epoch, temporal parameters $\tilde { \pmb { w } } _ { 0 }$ is set to ${ \pmb w } _ { \tau }$ , and MGD iterates $T = \bar { \lceil m \ / } ^ { } / b _ { k _ { \tau } } \rceil ^ { 1 }$ times using the selected batch size $b _ { k _ { \tau } }$ where $m$ is the total number of training samples:
+
+$$
+\pmb { \tilde { w } } _ { t + 1 } = \pmb { \tilde { w } } _ { t } - \eta _ { \tau } \pmb { g } _ { t } , \quad \pmb { g } _ { t } = \nabla J \big ( \pmb { \tilde { w } } _ { t } \big ) .
+$$
+
+After $T$ iterations at epoch $\tau$ , the model parameters is updated as ${ \pmb w } _ { \tau + 1 } = \tilde { { \pmb w } } _ { T }$ . Then, the optimizer obtains validation loss $\ell$ , and outputs cost as follows:
+
+$$
+y ^ { k _ { \tau } } = \left\{ \begin{array} { l l } { 0 } & { \mathrm { i f ~ } \ell ( { \pmb w } _ { \tau + 1 } ) < \ell ( { \pmb w } _ { \tau } ) } \\ { 1 } & { \mathrm { o t h e r w i s e } } \end{array} \right. .
+$$
+
+The RMGD samples an appropriate batch size from a probability distribution at each epoch. This probability distribution encourages exploration of different batch size and then later exploits batch size with history of success, which means decreasing validation loss. Figure 2 shows an example of training progress of RMGD. The figure represents the probability distribution with respect to epoch. The white dot represents the selected batch size at each epoch. In the early stage of training, commonly, all batch sizes tend to decrease validation loss: $\pi$ is uniform. Thus, all batch size have equal probability of being sampled (exploration). In the later stages of training, the probability distribution varies based on success and failure. Thus, better performing batch size gets higher probability to be sampled (exploitation). In this case, 256 is the best performing batch size.
+
+![](images/393c5dbfc9732321dbdc7f8b99038b41d854cfdb6752562f08df274188ebc0f2.jpg)  
+Figure 2: The probability distribution vs epoch using the RMGD. (top) The early stages of the training. (bottom) The later stages of the training. The white dot represents the selected batch size at each epoch. In the early stages of the training, RMGD updates the probabilities to search various batch sizes (exploration), and in the later stages, RMGD increases the probability of successful batch size (exploitation).
+
+# 4.2 REGRET BOUND
+
+The regret bound of the RMGD follows the regret bound derived in Shalev-Shwartz et al. (2012). The goal of this algorithm is to have low regret for not selecting the best performing batch size such that
+
+$$
+\mathrm { R e g r e t } _ { \mathcal T } ( S ) = \mathbb { E } \left[ \sum _ { \tau = 1 } ^ { \mathcal T } y _ { \tau } ^ { k _ { \tau } } \right] - \operatorname* { m i n } _ { i } \sum _ { \tau = 1 } ^ { \mathcal T } y _ { \tau } ^ { i }
+$$
+
+where the expectation is over the algorithm’s randomness of batch size selection and the second term on the right-hand side is the cumulative sum of the cost by the best fixed batch size which minimizes the cumulative sum of the cost. The regret of the RMGD is bounded,
+
+$$
+\mathbb { E } \left[ \sum _ { \tau = 1 } ^ { \mathcal { T } } y _ { \tau } ^ { k _ { \tau } } \right] - \operatorname* { m i n } _ { i } \sum _ { \tau = 1 } ^ { \mathcal { T } } y _ { \tau } ^ { i } \leq \frac { \log K } { \beta } + \beta K \mathcal { T } .
+$$
+
+In particular, setting $\beta = \sqrt { \log ( K ) / ( K T ) }$ , the regret is bounded by $2 \sqrt { K \log ( K ) \mathcal { T } }$ , which is sublinear with $\tau$ . The detailed derivation of regret bound is described in the appendix A.
+
+# 5 EXPERIMENTS
+
+This section describes various experimental results on MNIST, CIFAR10, and CIFAR100 dataset. In the experiments, simple convolutional neural networks (CNN) is used for MNIST and ‘All-CNN$\mathbf { C } '$ Springenberg et al. (2014) is used for CIFAR10 and CIFAR100. The details of the dataset and experimental settings are presented in the appendix B.
+
+![](images/91b09efdfa2510840f256bdd181664f5e17c00e91e5116f32e439c3299202af1.jpg)  
+Figure 3: The probability distribution and selected batch size. The white dot is selected batch size at epoch. (top) The case that small batch size performs better. (middle) The case that large batch size performs better. (bottom) The case that best performing batch size varies.
+
+![](images/2662561415f123e35fb57357b899adbbf21a3668da4d1f8a6b1b3807e88ca193.jpg)  
+Figure 4: The results of test accuracy for the MNIST dataset. The error bar is standard error. (left) The test accuracy of 100 times repeated experiments with AdamOptimizer. (right) The test accuracy of 100 times repeated experiments with AdagradOptimizer. In both cases, most RMGD settings outperform all fixed MGD algorithms.
+
+# 5.1 MNIST DATASET
+
+The validity of the RMGD was assessed by performing image classification on the MNIST dataset using AdamOptimizer and AdagradOptimizer as optimizer. The experiments were repeated 100 times for each algorithm and each optimizer, then the results were analyzed for significance. Figure 3 shows the probability distribution and the selected batch size with respect to epoch during training for the RMGD. The white dot represents the batch size selected at each epoch. The top figure is the case that small batch size (32) performs better. After epoch 50, batch size 32 gets high probability and is selected more than others. It means that batch size 32 has less misupdating in this case. The gradually increasing batch size algorithm may not perform well in this case. The middle figure is the case that large batch size (512) performs better. After epoch 60, batch size 512 gets high probability and selected more than others. The bottom figure shows that the best performing batch size varies with epoch. During epoch from 40 to 55, batch size of 256 performs best, and best performing batch size switches to 128 during epoch from 60 to 70, then better performing batch size backs to 256 after epoch 80. In the results, any batch size can be a successful batch size in the later stages without any particular order. The RMGD is more flexible for such situation than the MGD or directional adaptive MGD such as gradually increasing batch size algorithm.
+
+Figure 4 shows the test accuracy of each algorithm. The error bar is standard error. The number in parenthesis next to MGD represents the batch size used in the MGD. ’Basic’, ’sub’, ’super’, ’hinge’, and ’ratio’ in parenthesis next to RMGD represent RMGD settings ’batch size set equal to grid search, 0-1 loss’, ’subset of basic, 0-1 loss’, ’superset of basic, 0-1 loss’, ’basic set, hinge loss’, and ’basic set, percentage of non-negative changes in validation loss’, respectively. The left figure is the test accuracy with AdamOptimizer. The right figure is the test accuracy with AdagradOptimizer. Among the MGD algorithms, relatively small batch sizes (16 - 64) lead to higher performance than large batch sizes (128 - 512) and batch size 64 achieves the best performance in grid search. These results correspond with other studies Breuel (2015); Keskar et al. (2016); Mishkin et al. (2017). Most RMGD settings outperform all fixed MGD algorithms in both case. Although the performance of RMGD is not significantly increased compared to the best MGD, the purpose of this algorithm is not to improve performance, but to ensure that the best performance is achieved without performing a grid search on the batch size. Rather, the improved performance of the RMGD is a surprising result. Therefore, the RMGD is said to be valid. There are little performance gap among RMGD settings. The ’sub’ setting outperforms the ’basic’ setting in left figure, but the opposite result is shown in right figure. Therefore, there is no clear tendency of performance change depending on the size of the batch size set.
+
+Table 1: Iterations and real time for training, and test accuracy of MNIST classification with AdamOptimizer. The ’total’ is the sum of the average values from MGD 16 to 512, which means the whole grid search is performed.   
+
+<table><tr><td rowspan=2 colspan=1>Algorithms</td><td rowspan=2 colspan=1>Iterations</td><td rowspan=2 colspan=1>Real time (sec)</td><td rowspan=1 colspan=3>Test accuracy (%)</td></tr><tr><td rowspan=1 colspan=1>Mean±SD</td><td rowspan=1 colspan=1>Max</td><td rowspan=1 colspan=1>Min</td></tr><tr><td rowspan=1 colspan=1>MGD (16)</td><td rowspan=1 colspan=1>343,800</td><td rowspan=1 colspan=1>1,221.54 ± 36.00</td><td rowspan=1 colspan=1>99.327 ± 0.064</td><td rowspan=1 colspan=1>99.480</td><td rowspan=1 colspan=1>99.140</td></tr><tr><td rowspan=1 colspan=1>MGD (32)</td><td rowspan=1 colspan=1>171,900</td><td rowspan=1 colspan=1>697.82 ± 19.70</td><td rowspan=1 colspan=1>99.322 ± 0.060</td><td rowspan=1 colspan=1>99.500</td><td rowspan=1 colspan=1>99.150</td></tr><tr><td rowspan=1 colspan=1>MGD (64)</td><td rowspan=1 colspan=1>86,000</td><td rowspan=1 colspan=1>379.14 ± 11.32</td><td rowspan=1 colspan=1>99.328 ± 0.058</td><td rowspan=1 colspan=1>99.460</td><td rowspan=1 colspan=1>99.170</td></tr><tr><td rowspan=1 colspan=1>MGD (128)</td><td rowspan=1 colspan=1>43,000</td><td rowspan=1 colspan=1>262.33 ± 2.34</td><td rowspan=1 colspan=1>99.314 ± 0.056</td><td rowspan=1 colspan=1>99.440</td><td rowspan=1 colspan=1>99.170</td></tr><tr><td rowspan=1 colspan=1>MGD (256)</td><td rowspan=1 colspan=1>21,500</td><td rowspan=1 colspan=1>208.13 ± 2.20</td><td rowspan=1 colspan=1>99.295 ± 0.059</td><td rowspan=1 colspan=1>99.470</td><td rowspan=1 colspan=1>99.170</td></tr><tr><td rowspan=1 colspan=1>MGD (512)</td><td rowspan=1 colspan=1>10,800</td><td rowspan=1 colspan=1>180.06 ± 0.37</td><td rowspan=1 colspan=1>99.254 ± 0.054</td><td rowspan=1 colspan=1>99.430</td><td rowspan=1 colspan=1>99.110</td></tr><tr><td rowspan=1 colspan=1>MGD (total)</td><td rowspan=1 colspan=1>677,000</td><td rowspan=1 colspan=1>2,949.02</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>RMGD (basic)</td><td rowspan=1 colspan=1>68,309 ± 8,900</td><td rowspan=1 colspan=1>333.73 ± 25.38</td><td rowspan=1 colspan=1>99.342 ± 0.064</td><td rowspan=1 colspan=1>99.480</td><td rowspan=1 colspan=1>99.110</td></tr><tr><td rowspan=1 colspan=1>RMGD (sub)</td><td rowspan=1 colspan=1>85,777 ± 12,112</td><td rowspan=1 colspan=1>400.73 ± 51.91</td><td rowspan=1 colspan=1>99.357± 0.057</td><td rowspan=1 colspan=1>99.510</td><td rowspan=1 colspan=1>99.060</td></tr><tr><td rowspan=1 colspan=1>RMGD (super)</td><td rowspan=1 colspan=1>67,948 ± 6,022</td><td rowspan=1 colspan=1>332.61 ± 22.26</td><td rowspan=1 colspan=1>99.345 ± 0.058</td><td rowspan=1 colspan=1>99.460</td><td rowspan=1 colspan=1>99.110</td></tr><tr><td rowspan=1 colspan=1>RMGD (hinge)</td><td rowspan=1 colspan=1>69,607 ± 8,887</td><td rowspan=1 colspan=1>337.38 ± 25.29</td><td rowspan=1 colspan=1>99.341 ± 0.062</td><td rowspan=1 colspan=1>99.480</td><td rowspan=1 colspan=1>99.130</td></tr><tr><td rowspan=1 colspan=1>RMGD (ratio)</td><td rowspan=1 colspan=1>95,530 ± 8,281</td><td rowspan=1 colspan=1>449.37 ± 26.71</td><td rowspan=1 colspan=1>99.339 ± 0.062</td><td rowspan=1 colspan=1>99.470</td><td rowspan=1 colspan=1>99.150</td></tr></table>
+
+Table 2: Iterations and real time for training, and test accuracy of MNIST classification with AdagradOptimizer.   
+
+<table><tr><td rowspan=2 colspan=1>Algorithms</td><td rowspan=2 colspan=1>Iterations</td><td rowspan=2 colspan=1>Real time (sec)</td><td rowspan=1 colspan=3>Test accuracy (%)</td></tr><tr><td rowspan=1 colspan=1>Mean± SD</td><td rowspan=1 colspan=1>Max</td><td rowspan=1 colspan=1>Min</td></tr><tr><td rowspan=1 colspan=1>MGD (16)</td><td rowspan=1 colspan=1>343,800</td><td rowspan=1 colspan=1>1,160.87 ± 22.34</td><td rowspan=1 colspan=1>99.268 ± 0.090</td><td rowspan=1 colspan=1>99.430</td><td rowspan=1 colspan=1>98.920</td></tr><tr><td rowspan=1 colspan=1>MGD (32)</td><td rowspan=1 colspan=1>171,900</td><td rowspan=1 colspan=1>640.68 ± 15.53</td><td rowspan=1 colspan=1>99.270 ± 0.070</td><td rowspan=1 colspan=1>99.410</td><td rowspan=1 colspan=1>99.050</td></tr><tr><td rowspan=1 colspan=1>MGD (64)</td><td rowspan=1 colspan=1>86,000</td><td rowspan=1 colspan=1>367.40 ± 12.63</td><td rowspan=1 colspan=1>99.277 ± 0.077</td><td rowspan=1 colspan=1>99.440</td><td rowspan=1 colspan=1>99.110</td></tr><tr><td rowspan=1 colspan=1>MGD (128)</td><td rowspan=1 colspan=1>43,000</td><td rowspan=1 colspan=1>262.48 ± 1.37</td><td rowspan=1 colspan=1>99.269 ± 0.069</td><td rowspan=1 colspan=1>99.410</td><td rowspan=1 colspan=1>99.080</td></tr><tr><td rowspan=1 colspan=1>MGD (256)</td><td rowspan=1 colspan=1>21,500</td><td rowspan=1 colspan=1>195.60 ± 2.00</td><td rowspan=1 colspan=1>99.240 ± 0.072</td><td rowspan=1 colspan=1>99.390</td><td rowspan=1 colspan=1>99.030</td></tr><tr><td rowspan=1 colspan=1>MGD (512)</td><td rowspan=1 colspan=1>10,800</td><td rowspan=1 colspan=1>170.31 ± 1.41</td><td rowspan=1 colspan=1>99.198 ± 0.085</td><td rowspan=1 colspan=1>99.390</td><td rowspan=1 colspan=1>98.810</td></tr><tr><td rowspan=1 colspan=1>MGD (total)</td><td rowspan=1 colspan=1>677,000</td><td rowspan=1 colspan=1>2,797.34</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>RMGD (basic)</td><td rowspan=1 colspan=1>68,159 ± 8,447</td><td rowspan=1 colspan=1>323.33 ± 23.57</td><td rowspan=1 colspan=1>99.286 ± 0.088</td><td rowspan=1 colspan=1>99.490</td><td rowspan=1 colspan=1>98.900</td></tr><tr><td rowspan=1 colspan=1>RMGD (sub)</td><td rowspan=1 colspan=1>81,479 ± 9,141</td><td rowspan=1 colspan=1>356.16 ± 28.06</td><td rowspan=1 colspan=1>99.272 ± 0.092</td><td rowspan=1 colspan=1>99.460</td><td rowspan=1 colspan=1>98.960</td></tr><tr><td rowspan=1 colspan=1>RMGD (super)</td><td rowspan=1 colspan=1>67,638 ± 7,733</td><td rowspan=1 colspan=1>320.38 ± 23.55</td><td rowspan=1 colspan=1>99.280 ± 0.074</td><td rowspan=1 colspan=1>99.410</td><td rowspan=1 colspan=1>99.090</td></tr><tr><td rowspan=1 colspan=1>RMGD (hinge)</td><td rowspan=1 colspan=1>68,199 ± 8,642</td><td rowspan=1 colspan=1>322.33 ± 24.03</td><td rowspan=1 colspan=1>99.282 ± 0.089</td><td rowspan=1 colspan=1>99.420</td><td rowspan=1 colspan=1>98.900</td></tr><tr><td rowspan=1 colspan=1>RMGD (ratio)</td><td rowspan=1 colspan=1>93,523 ± 9,871</td><td rowspan=1 colspan=1>452.69 ± 34.71</td><td rowspan=1 colspan=1>99.283 ± 0.078</td><td rowspan=1 colspan=1>99.480</td><td rowspan=1 colspan=1>99.020</td></tr></table>
+
+Table 1 and 2 present iterations and real time for training, mean, maximum, and minimum of test accuracies for each algorithm with AdamOptimizer and AdagradOptimizer respectively. The MGD (total) is the summation of the iterations and real time of whole MGDs for grid search. The RMGD (basic) outperforms best performing MGD and is, also, faster than best performing MGD. Furthermore, it is 8 times faster than grid search in both cases. In the results, the RMGD is effective regardless of the optimizer.
+
+# 5.2 CIFAR10 AND CIFAR100 DATASET
+
+The CIFAR10 and CIFAR100 dataset were, also, used to assess effectiveness of the RMGD. The experiments were repeated 25 times and 10 times, respectively. In these experiments, all images are whitened and contrast normalized before being input to the network. Figure 5 shows the test accuracy for each algorithm. The left figure represents the test accuracy on CIFAR10. In contrast to the MNIST results, relatively large batch sizes (128 - 256) lead to higher performance than small batch sizes (16 - 64) and batch size 256 achieves the best performance in grid search. The right figure represents the test accuracy on CIFAR100 and batch size 128 achieves the best performance in grid search. The results on MNIST, CIFAR10 and CIFAR100 indicate that it is difficult to know which batch size is optimal before performing a grid search. Meanwhile, all RMGD settings have again exceeded the best performance of fixed MGD. There are no significant performance gaps among RMGD settings, so there is no need to worry about choosing appropriate batch size set or selecting cost function.
+
+![](images/83cf85f8be95450921fe3c721fa1f71e9a0c5cdebfb9d9889bba5e873effcaca.jpg)  
+Figure 5: The results of test accuracy for the CIFAR10 and CIFAR100 dataset. The error bar is standard error. (left) The test accuracy of 25 times repeated experiments on CIFAR10. (right) The test accuracy of 10 times repeated experiments on CIFAR100. In both cases, all RMGD settings outperform all fixed MGD algorithms.
+
+Table 3: Iterations and real time for training, and test accuracy on CIFAR10.   
+
+<table><tr><td rowspan=2 colspan=1>Algorithms</td><td rowspan=2 colspan=1>Iterations</td><td rowspan=2 colspan=1>Real time (sec)</td><td rowspan=1 colspan=3>Test accuracy (%)</td></tr><tr><td rowspan=1 colspan=1>Mean ± SD</td><td rowspan=1 colspan=1>Max</td><td rowspan=1 colspan=1>Min</td></tr><tr><td rowspan=1 colspan=1>MGD (16)</td><td rowspan=1 colspan=1>1,072,050</td><td rowspan=1 colspan=1>10,085.26 ± 216.48</td><td rowspan=1 colspan=1>87.778 ± 0.207</td><td rowspan=1 colspan=1>88.290</td><td rowspan=1 colspan=1>87.480</td></tr><tr><td rowspan=1 colspan=1>MGD (32)</td><td rowspan=1 colspan=1>536,200</td><td rowspan=1 colspan=1>7,643.93 ± 459.95</td><td rowspan=1 colspan=1>87.851 ± 0.160</td><td rowspan=1 colspan=1>88.250</td><td rowspan=1 colspan=1>87.630</td></tr><tr><td rowspan=1 colspan=1>MGD (64)</td><td rowspan=1 colspan=1>268,100</td><td rowspan=1 colspan=1>6,160.16 ± 68.54</td><td rowspan=1 colspan=1>87.853 ± 0.202</td><td rowspan=1 colspan=1>88.330</td><td rowspan=1 colspan=1>87.450</td></tr><tr><td rowspan=1 colspan=1>MGD (128)</td><td rowspan=1 colspan=1>134,050</td><td rowspan=1 colspan=1>5,675.15 ± 181.80</td><td rowspan=1 colspan=1>87.873 ± 0.234</td><td rowspan=1 colspan=1>88.210</td><td rowspan=1 colspan=1>87.090</td></tr><tr><td rowspan=1 colspan=1>MGD (256)</td><td rowspan=1 colspan=1>67,200</td><td rowspan=1 colspan=1>5,466.79 ± 402.20</td><td rowspan=1 colspan=1>87.897 ± 0.293</td><td rowspan=1 colspan=1>88.260</td><td rowspan=1 colspan=1>87.170</td></tr><tr><td rowspan=1 colspan=1>MGD (total)</td><td rowspan=1 colspan=1>2,077,600</td><td rowspan=1 colspan=1>35,031.29</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>RMGD (basic)</td><td rowspan=1 colspan=1>463,629 ± 48,692</td><td rowspan=1 colspan=1>7,592.43 ± 403.65</td><td rowspan=1 colspan=1>88.004 ± 0.167</td><td rowspan=1 colspan=1>88.380</td><td rowspan=1 colspan=1>87.780</td></tr><tr><td rowspan=1 colspan=1>RMGD (sub)</td><td rowspan=1 colspan=1>507,186 ± 93,961</td><td rowspan=1 colspan=1>7,614.16 ± 514.20</td><td rowspan=1 colspan=1>87.992 ± 0.147</td><td rowspan=1 colspan=1>88.270</td><td rowspan=1 colspan=1>87.730</td></tr><tr><td rowspan=1 colspan=1>RMGD (super)</td><td rowspan=1 colspan=1>397,685 ± 33,535</td><td rowspan=1 colspan=1>7,426.11 ± 228.28</td><td rowspan=1 colspan=1>88.027 ± 0.179</td><td rowspan=1 colspan=1>88.340</td><td rowspan=1 colspan=1>87.760</td></tr><tr><td rowspan=1 colspan=1>RMGD (hinge)</td><td rowspan=1 colspan=1>459,664± 56,086</td><td rowspan=1 colspan=1>7,584.01 ± 439.62</td><td rowspan=1 colspan=1>88.003 ± 0.167</td><td rowspan=1 colspan=1>88.380</td><td rowspan=1 colspan=1>87.810</td></tr><tr><td rowspan=1 colspan=1>RMGD (ratio)</td><td rowspan=1 colspan=1>426,123 ± 15,213</td><td rowspan=1 colspan=1>7,561.72 ± 220.56</td><td rowspan=1 colspan=1>88.002 ± 0.129</td><td rowspan=1 colspan=1>88.330</td><td rowspan=1 colspan=1>87.770</td></tr></table>
+
+Table 4: Iterations and real time for training, and test accuracy on CIFAR100.   
+
+<table><tr><td rowspan=2 colspan=1>Algorithms</td><td rowspan=2 colspan=1>Iterations</td><td rowspan=2 colspan=1>Real time (sec)</td><td rowspan=1 colspan=3>Test accuracy (%)</td></tr><tr><td rowspan=1 colspan=1>Mean ± SD</td><td rowspan=1 colspan=1>Max</td><td rowspan=1 colspan=1>Min</td></tr><tr><td rowspan=1 colspan=1>MGD (16)</td><td rowspan=1 colspan=1>1,072,050</td><td rowspan=1 colspan=1>12,097.47 ± 57.47</td><td rowspan=1 colspan=1>60.247 ± 0.690</td><td rowspan=1 colspan=1>61.940</td><td rowspan=1 colspan=1>59.620</td></tr><tr><td rowspan=1 colspan=1>MGD (32)</td><td rowspan=1 colspan=1>536,200</td><td rowspan=1 colspan=1>8,058.14 ± 39.87</td><td rowspan=1 colspan=1>60.475 ± 0.721</td><td rowspan=1 colspan=1>61.750</td><td rowspan=1 colspan=1>59.290</td></tr><tr><td rowspan=1 colspan=1>MGD (64)</td><td rowspan=1 colspan=1>268,100</td><td rowspan=1 colspan=1>6,400.21 ± 12.78</td><td rowspan=1 colspan=1>60.628 ± 0.795</td><td rowspan=1 colspan=1>61.950</td><td rowspan=1 colspan=1>59.170</td></tr><tr><td rowspan=1 colspan=1>MGD (128)</td><td rowspan=1 colspan=1>134,050</td><td rowspan=1 colspan=1>5,598.85 ± 38.18</td><td rowspan=1 colspan=1>60.954 ± 0.834</td><td rowspan=1 colspan=1>62.120</td><td rowspan=1 colspan=1>59.530</td></tr><tr><td rowspan=1 colspan=1>MGD (256)</td><td rowspan=1 colspan=1>67,200</td><td rowspan=1 colspan=1>5,245.88 ± 40.67</td><td rowspan=1 colspan=1>60.504 ± 0.553</td><td rowspan=1 colspan=1>61.560</td><td rowspan=1 colspan=1>59.830</td></tr><tr><td rowspan=1 colspan=1>MGD (total)</td><td rowspan=1 colspan=1>2,077,600</td><td rowspan=1 colspan=1>37,400.55</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>RMGD (basic)</td><td rowspan=1 colspan=1>425,416± 44,392</td><td rowspan=1 colspan=1>7,503.09 ± 281.79</td><td rowspan=1 colspan=1>61.203 ± 0.502</td><td rowspan=1 colspan=1>62.050</td><td rowspan=1 colspan=1>60.310</td></tr><tr><td rowspan=1 colspan=1>RMGD (sub)</td><td rowspan=1 colspan=1>532,624 ± 69,195</td><td rowspan=1 colspan=1>7,841.88 ± 530.29</td><td rowspan=1 colspan=1>61.080 ± 0.720</td><td rowspan=1 colspan=1>61.910</td><td rowspan=1 colspan=1>59.900</td></tr><tr><td rowspan=1 colspan=1>RMGD (super)</td><td rowspan=1 colspan=1>397,717 ± 20,091</td><td rowspan=1 colspan=1>7,408.00 ± 163.74</td><td rowspan=1 colspan=1>61.166 ± 0.560</td><td rowspan=1 colspan=1>61.970</td><td rowspan=1 colspan=1>60.320</td></tr><tr><td rowspan=1 colspan=1>RMGD (hinge)</td><td rowspan=1 colspan=1>419,100 ± 53,491</td><td rowspan=1 colspan=1>7,476.71 ± 324.29</td><td rowspan=1 colspan=1>61.219 ± 0.714</td><td rowspan=1 colspan=1>62.060</td><td rowspan=1 colspan=1>59.580</td></tr><tr><td rowspan=1 colspan=1>RMGD (ratio)</td><td rowspan=1 colspan=1>412,532 ±15,660</td><td rowspan=1 colspan=1>7,456.50 ± 100.79</td><td rowspan=1 colspan=1>61.340 ± 0.411</td><td rowspan=1 colspan=1>61.880</td><td rowspan=1 colspan=1>60.550</td></tr></table>
+
+Table 3 and 4 present the detailed results on CIFAR10 and CIFAR100 dataset. The RMGD (basic) is a little slower than single best performing MGD (256 for CIFAR10 and 128 for CIFAR100), however, it was much faster than grid search -about 4.6 times on CIFAR10 and 5.0 times on CIFAR100 faster. Therefore, this results, also, show the effectiveness of the RMGD.
+
+It is difficult to compare the RMGD with other adaptive batch size algorithm, e.g. coupling adaptive batch sizes (CABS) Balles et al. (2017), directly since the underlying goals are different. While the goal of the RMGD is to reduce the validation loss in terms of generalization performance, the CABS determines the batch size to balance between the gradient variance and computation. However, it is obvious that the RMGD is simpler and easier to implement than any other adaptive algorithm cited in this paper, and comparing the test accuracy between the RMGD and the CABS on the CIFAR10 and CIFAR100 using the same experimental settings with ’All-CNN-C’ shows that the performance of the RMGD is higher than that of the CABS (CIFAR10: $8 7 . 8 6 2 \pm 0 . 1 4 2$ , CIFAR100: 60.782 $\pm \ : 0 . 4 2 1 $ ). And again, the purpose of this algorithm is not to outperform other algorithms, but to guarantee that the best performance is reached without grid search.
+
+# CONCLUSION
+
+Selecting batch size affects the model quality and training efficiency, and determining the appropriate batch size is time consuming and requires considerable resources as it often relies on grid search. The focus of this paper is to design a simple robust algorithm that is theoretically sound and applicable in many situations.
+
+This paper considers a resizable mini-batch gradient descent (RMGD) algorithm based on a multiarmed bandit that achieves equivalent performance to that of best fixed batch-size. At each epoch, the RMGD samples a batch size according to certain probability distribution of a batch being successful in reducing the loss function. Sampling from this probability provides a mechanism for exploring different batch size and exploiting batch sizes with history of success. After obtaining the validation loss at each epoch with the sampled batch size, the probability distribution is updated to incorporate the effectiveness of the sampled batch size.
+
+The goal of this algorithm is not to achieve state-of-the-art accuracy but rather to select appropriate batch size which leads low misupdating and performs better. The RMGD essentially assists the learning process to explore the possible domain of the batch size and exploit successful batch size. The benefit of RMGD is that it avoids the need for cumbersome grid search to achieve best performance and that it is simple enough to apply to various field of machine learning including deep learning using MGD. Experimental results show that the RMGD achieves the best grid search performance on various dataset, networks, and optimizers. Furthermore, it, obviously, attains this performance in a shorter amount of time than the grid search. Also, there is no need to worry about which batch size set or cost function to choose when setting RMGD. In conclusion, the RMGD is effective and flexible mini-batch gradient descent algorithm.
+
+# REFERENCES
+
+Lukas Balles, Javier Romero, and Philipp Hennig. Coupling adaptive batch sizes with learning rates. In Proceedings of the Thirty-Third Conference on Uncertainty in Artificial Intelligence, UAI 2017, Sydney, Australia, August 11-15, 2017, 2017. URL http://auai.org/uai2017/ proceedings/papers/141.pdf.
+
+Yoshua Bengio. Practical recommendations for gradient-based training of deep architectures. In Neural networks: Tricks of the trade, pp. 437–478. Springer, 2012.
+
+Thomas M Breuel. The effects of hyperparameters on sgd training of neural networks. arXiv preprint arXiv:1508.02788, 2015.
+
+Richard H Byrd, Gillian M Chin, Jorge Nocedal, and Yuchen Wu. Sample size selection in optimization methods for machine learning. Mathematical programming, 134(1):127–155, 2012.
+
+Soham De, Abhay Yadav, David Jacobs, and Tom Goldstein. Big batch sgd: Automated inference using adaptive batch sizes. arXiv preprint arXiv:1610.05792, 2016.
+
+Michael P Friedlander and Mark Schmidt. Hybrid deterministic-stochastic methods for data fitting. SIAM Journal on Scientific Computing, 34(3):A1380–A1405, 2012.   
+Elad Hazan and Satyen Kale. Extracting certainty from uncertainty: Regret bounded by variation in costs. Machine learning, 80(2-3):165–188, 2010.   
+Kevin Jamieson and Ameet Talwalkar. Non-stochastic best arm identification and hyperparameter optimization. In Artificial Intelligence and Statistics, pp. 240–248, 2016.   
+Stanislaw Jastrzkebski, Zachary Kenton, Devansh Arpit, Nicolas Ballas, Asja Fischer, Yoshua Bengio, and Amos Storkey. Three factors influencing minima in sgd. arXiv preprint arXiv:1711.04623, 2017.   
+Nitish Shirish Keskar, Dheevatsa Mudigere, Jorge Nocedal, Mikhail Smelyanskiy, and Ping Tak Peter Tang. On large-batch training for deep learning: Generalization gap and sharp minima. arXiv preprint arXiv:1609.04836, 2016.   
+Lisha Li, Kevin Jamieson, Giulia DeSalvo, Afshin Rostamizadeh, and Ameet Talwalkar. Hyperband: A novel bandit-based approach to hyperparameter optimization. The Journal of Machine Learning Research, 18(1):6765–6816, 2017.   
+Dmytro Mishkin, Nikolay Sergievskiy, and Jiri Matas. Systematic evaluation of convolution neural network advances on the imagenet. Computer Vision and Image Understanding, 161:11–19, 2017.   
+Shai Shalev-Shwartz et al. Online learning and online convex optimization. Foundations and Trends $\textsuperscript { \textregistered }$ in Machine Learning, 4(2):107–194, 2012.   
+Samuel L Smith, Pieter-Jan Kindermans, and Quoc V Le. Don’t decay the learning rate, increase the batch size. arXiv preprint arXiv:1711.00489, 2017.   
+Jost Tobias Springenberg, Alexey Dosovitskiy, Thomas Brox, and Martin Riedmiller. Striving for simplicity: The all convolutional net. arXiv preprint arXiv:1412.6806, 2014.   
+D Randall Wilson and Tony R Martinez. The general inefficiency of batch training for gradient descent learning. Neural Networks, 16(10):1429–1451, 2003.
+
+# APPENDIX
+
+# A REGRET BOUND
+
+In the RMGD algorithm, there are $K$ batch sizes as multi arms with the probability distribution $\pi \in S$ , and at each epoch the algorithm should select one of the batch sizes $b _ { k _ { \tau } }$ . Then it receives a cost of selecting this arm, $y _ { \tau } ^ { k _ { \tau } } \in \{ 0 , 1 \}$ by testing the validation loss $\ell$ . The vector ${ \pmb y } _ { \tau } \in \{ 0 , 1 \} ^ { K }$ represents the selecting cost for each batch size. The goal of this algorithm is to have low regret for not selecting the best performing batch size.
+
+$$
+\mathrm { R e g r e t } _ { \mathcal { T } } ( S ) = \mathbb { E } \left[ \sum _ { \tau = 1 } ^ { \mathcal { T } } y _ { \tau } ^ { k _ { \tau } } \right] - \operatorname* { m i n } _ { i } \sum _ { \tau = 1 } ^ { \mathcal { T } } y _ { \tau } ^ { i }
+$$
+
+where the expectation is over the algorithm’s randomness of batch size selection.
+
+Let $S$ be the probability simplex, the selecting loss functions be $f _ { \tau } ( \pmb { \pi } ) = \langle \pmb { \pi } , \pmb { y } _ { \tau } \rangle ^ { 2 }$ and $R : S  \mathbb { R }$ be a regularization function that is often chosen to be strongly convex with respect to some norm $\| \cdot \|$ . The algorithm select a batch size with probability $\mathbb { P } [ b _ { k _ { \tau } } ] = \pi _ { \tau } ^ { k _ { \tau } }$ and therefore $f _ { \tau } ( \pmb { \pi } _ { \tau } )$ is the expected cost of the selected batch size at epoch $\tau$ . The gradient of the selecting loss function is ${ \pmb y } _ { \tau }$ . However, only one element $y _ { \tau } ^ { k _ { \tau } }$ is known at each epoch. To estimate gradient, random vector $z _ { \tau }$ is defined as follows:
+
+$$
+z _ { \tau } ^ { i } = \left\{ \begin{array} { c l } { { y _ { \tau } ^ { i } / \pi _ { \tau } ^ { i } } } & { { \mathrm { i f ~ } i = k _ { \tau } } } \\ { { 0 } } & { { \mathrm { o t h e r w i s e } } } \end{array} \right.
+$$
+
+and expectation of $z _ { \tau }$ satisfies,
+
+$$
+\mathbb { E } [ z _ { \tau } | z _ { \tau - 1 } , \dots , z _ { 0 } ] = \sum _ { i = 1 } ^ { K } \mathbb { P } [ b _ { k _ { \tau } } ] z _ { \tau } ^ { i } = \pi _ { \tau } ^ { k _ { \tau } } \frac { y _ { \tau } ^ { k _ { \tau } } } { \pi _ { \tau } ^ { k _ { \tau } } } = y _ { \tau } ^ { k _ { \tau } } .
+$$
+
+The most natural learning rule is to set the probability distribution which has minimal cost on all past epochs. It is referred to as Follow-the-Regularized-Leader (FTRL) in online learning:
+
+$$
+\forall \tau , \quad \pi _ { \tau + 1 } = \underset { \pi \in S } { \arg \operatorname* { m i n } } \left\{ \beta \sum _ { t = 1 } ^ { \tau } f _ { t } ( \pi ) + R ( \pi ) \right\} ,
+$$
+
+where $\beta$ is positive hyperparameter. The FTRL has a problem that it requires solving an optimization problem at each epoch. To solve this problem, Online Mirror Descent (OMD) is applied. The OMD computes the current probability distribution iteratively based on a gradient update rule and the previous probability distribution and lies in the update being carried out in a ’dual’ space, defined by regularizer. This follows from considering $\nabla R$ as a mapping from $\mathbb { R } ^ { K }$ onto itself. The OMD relies on Bregman divergence. The Bregman divergence between $\pi$ and $\tilde { \pi }$ with respect to the regularizer $R$ is given as:
+
+$$
+B _ { R } ( { \pmb \pi } \| { \tilde { \pmb \pi } } ) = R ( { \pmb \pi } ) - R ( { \tilde { \pmb \pi } } ) - \nabla R ( { \tilde { \pmb \pi } } ) \cdot ( { \pmb \pi } - { \tilde { \pmb \pi } } ) ,
+$$
+
+and a Bregman projection of $\tilde { \pi }$ onto simplex $S$ :
+
+$$
+\operatorname { a r g m i n } _ { \pi \in S } B _ { R } ( \pi \| { \tilde { \pi } } ) .
+$$
+
+Then the probability distribution is updated by the OMD as follows:
+
+$$
+\begin{array} { r c l } { \nabla R ( \tilde { \pmb { \pi } } _ { \tau + 1 } ) } & { = } & { \nabla R ( \tilde { \pmb { \pi } } _ { \tau } ) - \beta \pmb { z } _ { \tau } } \\ { \pmb { \pi } _ { \tau + 1 } } & { = } & { \underset { \pmb { \pi } \in S } { \arg \operatorname* { m i n } } B _ { R } ( \pmb { \pi } \| \tilde { \pmb { \pi } } _ { \tau + 1 } ) . } \end{array}
+$$
+
+In general, if $R$ is strongly convex, then $\nabla R$ becomes a bijective mapping, thus $\tilde { \pi } _ { \tau + 1 }$ can be recovered by the inverse gradient mapping $( \nabla R ) ^ { - 1 }$ . Given that $R$ is strongly convex, the OMD and FTRL produce equivalent predictions:
+
+$$
+\underset { \pi \in S } { \arg \operatorname* { m i n } } B _ { R } ( \pi \| \tilde { \pi } _ { \tau + 1 } ) = \underset { \pi \in S } { \arg \operatorname* { m i n } } \left\{ \beta \sum _ { t = 1 } ^ { \tau } f _ { t } ( \pi ) + R ( \pi ) \right\}
+$$
+
+by the Lemma 1 in Hazan & Kale (2010). It makes sense to use the negative entropic regularization for $R$ in RMGD setting:
+
+$$
+R ( { \pmb \pi } ) = \sum _ { i = 1 } ^ { K } \pi ^ { i } \log ( \pi ^ { i } ) .
+$$
+
+Then, $\nabla R ( { \pmb \pi } ) _ { i } = \log ( \pi ^ { i } ) + 1$ . From the OMD, $\tilde { \pi } _ { \tau + 1 }$ is updated as follows:
+
+$$
+\begin{array} { r c l } { \nabla R ( \tilde { \pi } _ { \tau + 1 } ) } & { = } & { \nabla R ( \tilde { \pi } _ { \tau } ) - \beta z _ { \tau } } \\ { \log ( \tilde { \pi } _ { \tau + 1 } ^ { i } ) + 1 } & { = } & { \log ( \tilde { \pi } _ { \tau } ^ { i } ) + 1 - \beta z _ { \tau } ^ { i } } \\ { \tilde { \pi } _ { \tau + 1 } ^ { i } } & { = } & { \tilde { \pi } _ { \tau } ^ { i } e ^ { - \beta z _ { \tau } ^ { i } } . } \end{array}
+$$
+
+The Bregman projection with respect to the negative entropy function becomes scaling by the $\ell _ { 1 }$ - norm. Therefore,
+
+$$
+\pi _ { \tau + 1 } ^ { i } = \frac { \tilde { \pi } _ { \tau + 1 } ^ { i } } { \sum _ { j } \tilde { \pi } _ { \tau + 1 } ^ { j } } .
+$$
+
+The probability distribution $\pi _ { \tau }$ is updated by the rule of the normalized exponentiated gradient (normalized-EG) algorithm described in Algorithm 1. Also, the selecting loss function is linear and it is satisfied that $\forall \tau , i$ we have $\beta z _ { \tau } ^ { i } \geq 0$ . Then,
+
+$$
+\sum _ { \tau = 1 } ^ { T } \langle \pi _ { \tau } - \pi ^ { * } , z _ { \tau } \rangle \leq \frac { \log ( K ) } { \beta } + \beta \sum _ { \tau = 1 } ^ { T } \sum _ { i = 1 } ^ { K } \pi _ { \tau } ^ { i } ( z _ { \tau } ^ { i } ) ^ { 2 }
+$$
+
+by the Theorem 2.22 in Shalev-Shwartz et al. (2012), where $\pi ^ { * } \in S$ is a fixed vector which minimizes the cumulative selecting loss,
+
+$$
+\pi ^ { * } = \arg \operatorname* { m i n } _ { \pi \in S } \sum _ { \tau = 1 } ^ { \tau } f _ { \tau } ( \pi ) .
+$$
+
+Since $f _ { \tau }$ is convex and $z _ { \tau }$ is estimated gradients for all $\tau$
+
+$$
+\mathbb { E } \left[ \sum _ { \tau = 1 } ^ { \mathcal { T } } ( f _ { \tau } ( \pi _ { \tau } ) - f _ { \tau } ( \pi ^ { * } ) ) \right] \leq \frac { \log ( K ) } { \beta } + \beta \sum _ { \tau = 1 } ^ { \mathcal { T } } \mathbb { E } \left[ \sum _ { i = 1 } ^ { K } \pi _ { \tau } ^ { i } ( z _ { \tau } ^ { i } ) ^ { 2 } \right]
+$$
+
+by the Theorem 4.1 in Shalev-Shwartz et al. (2012). The last term is bounded as follows:
+
+$$
+\begin{array} { r c l } { \mathbb { E } \left[ \displaystyle \sum _ { i = 1 } ^ { K } \pi _ { \tau } ^ { i } ( z _ { \tau } ^ { i } ) ^ { 2 } \right] } & { = } & { \displaystyle \sum _ { j = 1 } ^ { K } \mathbb { P } [ k _ { \tau } = j ] \sum _ { i = 1 } ^ { K } \pi _ { \tau } ^ { i } ( z _ { \tau } ^ { i } ) ^ { 2 } } \\ & { = } & { \displaystyle \sum _ { j = 1 } ^ { K } ( \pi _ { \tau } ^ { j } ) ^ { 2 } ( y _ { \tau } ^ { j } / \pi _ { \tau } ^ { j } ) ^ { 2 } } \\ & { = } & { \displaystyle \sum _ { j = 1 } ^ { K } ( y _ { \tau } ^ { j } ) ^ { 2 } \leq K . } \end{array}
+$$
+
+Therefore, the regret of the RMGD is bounded,
+
+$$
+\mathbb { E } \left[ \sum _ { \tau = 1 } ^ { \mathcal { T } } y _ { \tau } ^ { k _ { \tau } } \right] - \operatorname* { m i n } _ { i } \sum _ { \tau = 1 } ^ { \mathcal { T } } y _ { \tau } ^ { i } \leq \frac { \log K } { \beta } + \beta K \mathcal { T } .
+$$
+
+In particular, setting $\beta = \sqrt { \log ( K ) / ( K T ) }$ , the regret is bounded by $2 \sqrt { K \log ( K ) \mathcal { T } }$ , which is sublinear with $\tau$ .
+
+# B EXPERIMENTAL SETTINGS
+
+# DATASET
+
+MNIST is a dataset of handwritten digits that is commonly used for image classification. Each sample is a black and white image and $2 8 \times 2 8$ in size. The MNIST is split into three parts: 55,000 samples for training, 5,000 samples for validation, and 10,000 samples for test.
+
+CIFAR10 consists of $6 0 { , } 0 0 0 \ 3 2 \times 3 2$ color images in 10 classes (airplane, automobile, bird, cat, deer, dog, frog, horse, ship, and truck), with 6,000 images per class. The CIFAR10 is split into three parts: 45,000 samples for training, 5,000 samples for validation, and 10,000 samples for test.
+
+CIFAR100 consists of $6 0 { , } 0 0 0 \ 3 2 \times 3 2$ color images in 100 classes. The CIFAR100 is split into three parts: 45,000 samples for training, 5,000 samples for validation, and 10,000 samples for test.
+
+# SETTINGS
+
+The simple CNN consists of two convolution layers with $5 \times 5$ filter and $1 \times 1$ stride, two max pooling layers with $2 \times 2$ kernel and $2 \times 2$ stride, single fully-connected layer, and softmax classifier. Description of the ’All-CNN-C’ is provided in Table 5. For MNIST, AdamOptimizer with $\eta = 1 0 ^ { - 4 }$ and AdagradOptimizer with $\eta = 0 . 1$ are used as optimizer. The basic batch size set $B = \{ 1 6 , 3 2 , 6 4 , 1 2 8 , 2 5 6 , 5 1 2 \}$ , subset of basic $B ^ { - } ~ = ~ \{ 1 6 , 6 4 , 2 5 6 \}$ , and superset of basic $B ^ { + } ~ = ~ \{ 1 6 , 2 4 , 3 2 , 4 8 , 6 4 , 9 6 , 1 2 8 , 1 9 2 , 2 5 6 , 3 8 ^ { \circ }$ 4, 512}. The model is trained for a total of 100 epochs. For CIFAR10 and CIFAR100, MomentumOptimizer with fixed momentum of 0.9 is used as optimizer. The learning rate $\eta ^ { k }$ is scaled up proportionately to the batch size $( \eta ^ { k } = 0 . 0 5 * b _ { k } / 2 5 6 )$ and decayed by a schedule $S = [ 2 0 0 , 2 5 0 , 3 0 0 ]$ in which $\dot { \boldsymbol { \eta } } ^ { k }$ is multiplied by a fixed multiplier of 0.1 after 200, 250, and 300 epochs respectively. The model is trained for a total of 350 epochs. Dropout is applied to the input image as well as after each convolution layer with stride 2. The dropout probabilities are $20 \%$ for dropping out inputs and $50 \%$ otherwise. The model is regularized with weight decay $\lambda ~ = ~ 0 . 0 0 1$ . The basic batch size set $B = \{ 1 6 , 3 2 , 6 2 , 1 2 8 , 2 5 6 \}$ , subset of basic $B ^ { - } = \{ 1 6 , 6 4 , 2 5 6 \}$ , and superset of basic $B ^ { + } = \{ 1 6 , 2 4 , 3 2 , 4 8 , 6 4 , 9 6 , 1 2 8 , 1 9 2 , 2$ $2 5 6 \}$ . For all experiments, rectified linear unit (ReLU) is used as activation function. For RMGD, $\beta$ is set to $\sqrt { \log ( 6 ) / ( 6 * 1 0 0 ) } \approx 0 . 0 5 5$ for MNIST and $\sqrt { \log ( 5 ) / ( 5 * 3 5 0 ) } \approx 0 . 0 3 0$ for CIFAR10 and CIFAR100. The basic batch size selecting cost is 0-1 loss, hinge loss is $\operatorname* { m a x } \{ 0 , \ell _ { \tau } - \ell _ { \tau - 1 } \}$ , and ratio loss is $\operatorname* { m a x } \{ 0 , ( \ell _ { \tau } - \ell _ { \tau - 1 } ) / \ell _ { \tau - 1 } \}$ .
+
+Table 5: Architecture of the All-CNN-C for CIFAR10 and CIFAR100   
+
+<table><tr><td>Layer</td><td>Layerdescription</td></tr><tr><td>input conv1</td><td>Input 32 × 32 RGB image 3 × 3 conv. 96 ReLU, stride 1, dropout 0.2</td></tr><tr><td>conv2</td><td>3 × 3 conv. 96 ReLU, stride 1</td></tr><tr><td>conv3</td><td>3 × 3 conv.96 ReLU, stride 2</td></tr><tr><td>conv4</td><td>3 × 3 conv.192 ReLU, stride 1, dropout 0.5</td></tr><tr><td>conv5</td><td>3 × 3 conv.192 ReLU, stride 1</td></tr><tr><td>conv6</td><td>3 × 3 conv. 192 ReLU, stride 2</td></tr><tr><td>conv7</td><td>3 × 3 conv.192 ReLU, stride 1, dropout 0.5</td></tr><tr><td>conv8</td><td>1 × 1 conv.192 ReLU, stride 1</td></tr><tr><td>conv9</td><td></td></tr><tr><td>pool</td><td>1 × 1 conv. 10 or 100 ReLU, stride 1</td></tr><tr><td></td><td>averaging over 6 × 6 spatial dimensions</td></tr><tr><td>softmax</td><td>10-way or 100-way softmax</td></tr></table>

parse/train/H1lGHsA9KX/H1lGHsA9KX_content_list.json

@@ -0,0 +1,1410 @@
+[
+    {
+        "type": "text",
+        "text": "A RESIZABLE MINI-BATCH GRADIENT DESCENT BASED ON A MULTI-ARMED BANDIT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            821,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            171,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Determining the appropriate batch size for mini-batch gradient descent is always time consuming as it often relies on grid search. This paper considers a resizable mini-batch gradient descent (RMGD) algorithm based on a multi-armed bandit that achieves performance equivalent to that of best fixed batch-size. At each epoch, the RMGD samples a batch size according to a certain probability distribution proportional to a batch being successful in reducing the loss function. Sampling from this probability provides a mechanism for exploring different batch size and exploiting batch sizes with history of success. After obtaining the validation loss at each epoch with the sampled batch size, the probability distribution is updated to incorporate the effectiveness of the sampled batch size. Experimental results show that the RMGD achieves performance better than the best performing single batch size. It is surprising that the RMGD achieves better performance than grid search. Furthermore, it attains this performance in a shorter amount of time than grid search. ",
+        "bbox": [
+            233,
+            268,
+            764,
+            463
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            493,
+            336,
+            508
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Gradient descent (GD) is a common optimization algorithm for finding the minimum of the expected loss. It takes iterative steps proportional to the negative gradient of the loss function at each iteration. It is based on the observation that if the multi-variable loss functions $f ( w )$ is differentiable at point $\\pmb { w }$ , then $f ( w )$ decreases fastest in the direction of the negative gradient of $f$ at $\\textbf { \\em w }$ , i.e., $- \\nabla f ( \\boldsymbol { w } )$ . The model parameters are updated iteratively in GD as follows: ",
+        "bbox": [
+            173,
+            525,
+            825,
+            597
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "equation",
+        "img_path": "images/dd02804bfc8787a52199638f94ea31078156e20a83a1372a0676dff36d2c5bea.jpg",
+        "text": "$$\n\\pmb { w } _ { t + 1 } = \\pmb { w } _ { t } - \\eta _ { t } \\pmb { g } _ { t } , \\qquad \\pmb { g } _ { t } = \\nabla _ { \\pmb { w } } f \\big ( \\pmb { w } _ { t } \\big )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            362,
+            604,
+            635,
+            622
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "where ${ \\mathbf { } } w _ { t } , { \\mathbf { } } g _ { t }$ , and $\\eta _ { t }$ are the model parameters, gradients of $f$ with respect to $\\pmb { w }$ , and learning rate at time $t$ respectively. For small enough $\\eta _ { t }$ , ${ f ( \\pmb { w } _ { t } ) \\geq f ( \\pmb { w } _ { t + 1 } ) }$ and ultimately the sequence of ${ \\pmb w } _ { t }$ will move down toward a local minimum. For a convex loss function, GD is guaranteed to converge to a global minimum with an appropriate learning rate. ",
+        "bbox": [
+            174,
+            638,
+            825,
+            695
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "There are various issues to consider in gradient-based optimization. First, GD can be extremely slow and impractical for large dataset: gradients of all the data have to be evaluated for each iteration. With larger data size, the convergence rate, the computational cost and memory become critical, and special care is required to minimize these factors. Second, for non-convex function which is often encountered in deep learning, GD can get stuck in a local minimum without the hope of escaping. Third, stochastic gradient descent (SGD), which is based on the gradient of a single training sample, has large gradient variance, and it requires a large number of iterations. This ultimately translates to slow convergence. Mini-batch gradient descent (MGD), which is based on the gradient over a small batch of training data, trades off between the robustness of SGD and the stability of GD. There are three advantages for using MGD over GD and SGD: 1) The batching allows both the efficiency of memory usage and implementations; 2) The model update frequency is higher than GD which allows for a more robust convergence avoiding local minimum; 3) MGD requires less iteration per epoch and provides a more stable update than SGD. For these reasons, MGD has been a popular algorithm for machine learning. However, selecting an appropriate batch size is difficult. Various studies suggest that there is a close link between performance and batch size used in MGD Breuel (2015); Keskar et al. (2016); Wilson & Martinez (2003). ",
+        "bbox": [
+            173,
+            702,
+            825,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "There are various guidelines for selecting a batch size but have not been completely practical Bengio (2012). Grid search is a popular method but it comes at the expense of search time. There are a small number of adaptive MGD algorithms to replace grid search Byrd et al. (2012); De et al. (2016); Friedlander & Schmidt (2012). These algorithms increase the batch size gradually according to their own criterion. However, these algorithms are based on convex loss function and hard to be applied to deep learning. For non-convex optimization, it is difficult to determine the optimal batch size for best performance. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            200
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "This paper considers a resizable mini-batch gradient descent (RMGD) algorithm based on a multi-armed bandit for achieving best performance in grid search by selecting an appropriate batch size at each epoch with a probability defined as a function of its previous success/failure. At each epoch, RMGD samples a batch size from its probability distribution, then uses the selected batch size for mini-batch gradient descent. After obtaining the validation loss at each epoch, the probability distribution is updated to incorporate the effectiveness of the sampled batch size. The benefit of RMGD is that it avoids the need for cumbersome grid search to achieve best performance and that it is simple enough to apply to any optimization algorithm using MGD. The detailed algorithm of RMGD are described in Section 4, and experimental results are presented in Section 5. ",
+        "bbox": [
+            174,
+            208,
+            825,
+            333
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            373,
+            352,
+            390
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "There are only a few published results on the topic of batch size. It was empirically shown that SGD converged faster than GD on a large speech recognition database Wilson & Martinez (2003). It was determined that the range of learning rate resulting in low test errors was considerably getting smaller as the batch size increased on convolutional neural networks and that small batch size yielded the best test error, while large batch size could not yield comparable low error rate Breuel (2015). It was observed that larger batch size are more liable to converge to a sharp local minimum thus leading to poor generalization Keskar et al. (2016). It was found that the learning rate and the batch size controlled the trade-off between the depth and width of the minima in MGD Jastrzkebski et al. (2017). ",
+        "bbox": [
+            174,
+            410,
+            825,
+            535
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A small number of adaptive MGD algorithms have been proposed. Byrd et al. (2012) introduced a methodology for using varying sample size in MGD. A relatively small batch size is chosen at the start, then the algorithm chooses a larger batch size when the optimization step does not produce improvement in the target objective function. They assumed that using a small batch size allowed rapid progress in the early stages, while a larger batch size yielded high accuracy. However, this assumption did not corresponded with later researches that reported the degradation of performance with large batch size Breuel (2015); Keskar et al. (2016); Mishkin et al. (2017). Another similar adaptive algorithm, which increases the batch size gradually as the iteration proceeded, was done by Friedlander & Schmidt (2012). The algorithm uses relatively few samples to approximate the gradient, and gradually increase the number of samples with a constant learning rate. It was observed that increasing the batch size is more effective than decaying the learning rate for reducing the number of iterations Smith et al. (2017). However, these increasing batch size algorithms lack flexibility since it is unidirectional. Balles et al. (2017) proposed a dynamic batch size adaptation algorithm. It estimates the variance of the stochastic gradients and adapts the batch size to decrease the variance. However, this algorithm needs to find the gradient variance and its computation depends on the number of model parameters. ",
+        "bbox": [
+            174,
+            541,
+            825,
+            763
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Batch size can also be considered as a hyperparameter, and there have been some proposals based on bandit-based hyperparameter (but not batch size) optimization which maybe applicable for determining the best fixed batch size. Jamieson & Talwalkar (2016) introduced a successive halving algorithm. This algorithm uniformly allocates a budget to a set of hyperparameter configurations, evaluates the performance of all configurations, and throws out the worst half until one configuration remains. Li et al. (2017) introduced a novel bandit-based hyperparameter optimization algorithm referred as HYPERBAND. This algorithm considers the optimization problem as a resource allocation problem. The two algorithms mentioned above are not adaptive, and for searching a small hyperparameter space, the two algorithms will not be very effective. The experimental results in this paper show that adaptive MGD tends to perform better than fixed MGD. ",
+        "bbox": [
+            174,
+            771,
+            825,
+            910
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/7619fd884b27a622e03c3e2bfb5a3c0751a4da065c099123a0658a0a63f79262.jpg",
+        "image_caption": [
+            "Figure 1: An overall framework of considered resizable mini-batch gradient descent algorithm (RMGD). The RMGD samples a batch size from a probability distribution, and parameters are updated by mini-batch gradient using the selected batch size. Then the probability distribution is updated by checking the validation loss. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            209,
+            101,
+            789,
+            273
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 SETUP ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            377,
+            261,
+            393
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Let $\\boldsymbol { B } = \\{ b _ { k } \\} _ { k = 1 } ^ { K }$ be the set of possible batch size and $\\pmb { \\pi } = \\{ \\pi ^ { k } \\} _ { k = 1 } ^ { K }$ be the probability distribution of batch size where $b _ { k } , \\pi ^ { k }$ , and $K$ are the $k ^ { \\mathrm { t h } }$ batch size, the probability of $b _ { k }$ to be selected, and number of batch sizes respectively. This paper considers algorithm for multi-armed bandit over $\\boldsymbol { B }$ according to Algorithm 1. Let $\\mathbf { \\boldsymbol { w } } _ { \\tau } \\in \\mathcal { W }$ be the model parameters at epoch $\\tau$ , and $\\tilde { \\mathbf { \\ b { w } } } _ { t }$ be the temporal parameters at sub iteration $t$ . Let $J : \\mathcal { W }  \\mathbb { R }$ be the training loss function and let $\\mathbf { \\delta } \\mathbf { \\mathbf { { g } } } = \\nabla J ( \\mathbf { \\delta } \\mathbf { \\mathbf { { w } } } )$ be the gradients of training loss function with respect to the model parameters. $\\eta _ { \\tau }$ is the learning rate at epoch $\\tau$ . Let $\\ell : \\mathcal { W } \\to \\mathbb { R }$ be the validation loss function, and $y ^ { k } \\in \\{ 0 , \\dot { 1 } \\}$ be the cost of choosing the batch size $b _ { k }$ . In here, $y ^ { k } = 0$ if the validation loss decreases by the selected batch size $b _ { k }$ (well-updating) and $y ^ { k } = 1$ otherwise (misupdating). The aim of the algorithm is to have low misupdating. For the cost function $y ^ { k }$ , graduated losses such as hinge loss and percentage of nonnegative changes in validation loss can be variations of 0-1 loss. However, there are no differences in regret bound among them in this setting and it is experimentally confirmed that there are little performance gaps among them. Therefore, this paper introduces the 0-1 loss, which is simple and basic. ",
+        "bbox": [
+            173,
+            417,
+            825,
+            604
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4 RESIZABLE MINI-BATCH GRADIENT DESCENT ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            655,
+            593,
+            671
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The resizable mini-batch gradient descent (RMGD) sets the batch sizes as multi arms, and at each epoch it samples one of the batch sizes from probability distribution. Then, it suffers a cost of selecting this batch size. Using the cost, probability distribution is updated. ",
+        "bbox": [
+            174,
+            695,
+            825,
+            738
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4.1 ALGORITHMS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            786,
+            310,
+            800
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The overall framework of the RMGD algorithm is shown in Figure 1. The RMGD consists of two components: batch size selector and parameter optimizer. The selector samples a batch size from probability distribution and updates the distribution. The optimizer is usual mini-batch gradient. ",
+        "bbox": [
+            174,
+            818,
+            825,
+            861
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Selector samples a batch size $b _ { k _ { \\tau } } \\in B$ from the probability distribution $\\pi _ { \\tau }$ at each epoch $\\tau$ where $k _ { \\tau }$ is selected index. Here $b _ { k }$ is associated with probability $\\pi ^ { k }$ . The selected batch size $b _ { k _ { \\tau } }$ is applied to optimizer for MGD at each epoch, and the selector gets cost $y ^ { k _ { \\tau } }$ from optimizer. Then, the selector ",
+        "bbox": [
+            176,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Resizable Mini-batch Gradient Descent ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            522,
+            117
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "text_level": 1,
+        "bbox": [
+            178,
+            121,
+            220,
+            133
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "$\\begin{array} { r } { B = \\{ b _ { k } \\} _ { k = 1 } ^ { K } : } \\end{array}$ Set of batch sizes $\\pi _ { 0 } = \\{ 1 / K , \\ldots , 1 / K \\}$ : Prior probability distribution ",
+        "bbox": [
+            178,
+            133,
+            517,
+            161
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Procedure: ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            172,
+            253,
+            185
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "1: Initialize model parameters $\\pmb { w } _ { 0 }$   \n2: for epoch $\\tau = 0 , 1 , 2 , \\dots$   \n3: Select batch size $b _ { k _ { \\tau } } \\in B$ from $\\pi _ { \\tau }$   \n4: Set temporal parameters $\\tilde { \\mathbf { { w } } } _ { 0 } = \\mathbf { w } _ { \\tau }$   \n5: for $t = 0 , 1 , \\ldots , T - 1$ where $T = \\lceil m / b _ { k _ { \\tau } } \\rceil$   \n6: Compute gradient $\\pmb { g } _ { t } = \\nabla J ( \\tilde { \\pmb { w } } _ { t } )$   \n7: Update $\\tilde { \\pmb { w } } _ { t + 1 } = \\tilde { \\pmb { w } } _ { t } - \\eta _ { \\tau } \\pmb { g } _ { t }$   \n8: end for   \n9: Update ${ \\pmb w } _ { \\tau + 1 } = \\tilde { { \\pmb w } } _ { T }$   \n10: Observe validation loss $\\ell ( w _ { \\tau + 1 } )$   \n11: if $\\ell ( \\pmb { w } _ { \\tau + 1 } ) < \\ell ( \\pmb { w } _ { \\tau } )$   \n12: Get cost $y ^ { k _ { \\tau } } = 0$   \n13: else   \n14: Get cost $y ^ { k _ { \\tau } } = 1$   \n15: end if   \n16: for $i = 1 , 2 , \\dots , K$   \n17: if $i = k _ { \\tau }$   \n18: Set temporal probability π˜i = πi e−βykτ /πiτ   \n19: else   \n20: Set temporal probability $\\tilde { \\pi } ^ { i } = \\pi _ { \\tau } ^ { i }$   \n21: end if   \n22: end for   \n23: Update $\\begin{array} { r } { \\forall i \\in [ K ] , \\pi _ { \\tau + 1 } ^ { i } = \\tilde { \\pi } ^ { i } / \\sum _ { j } \\tilde { \\pi } ^ { j } } \\end{array}$   \n24: end for ",
+        "bbox": [
+            179,
+            189,
+            524,
+            507
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "updates probabilities by randomized weighted majority, ",
+        "bbox": [
+            173,
+            534,
+            539,
+            549
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bab6b8f82def9f8cc7e54ed7c561dfec97e4df705a074489c025386896c29087.jpg",
+        "text": "$$\n\\begin{array} { r l } { \\mathrm { f o r } i = k _ { \\tau } , } & { \\tilde { \\pi } ^ { i } = \\pi _ { \\tau } ^ { i } e ^ { - \\beta y ^ { k _ { \\tau } } / \\pi _ { \\tau } ^ { i } } } \\\\ { \\mathrm { f o r } i \\neq k _ { \\tau } , } & { \\tilde { \\pi } ^ { i } = \\pi _ { \\tau } ^ { i } } \\\\ { \\forall i , } & { \\pi _ { \\tau + 1 } ^ { i } = \\tilde { \\pi } ^ { i } / \\sum _ { j } \\tilde { \\pi } ^ { j } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            387,
+            554,
+            607,
+            635
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\beta \\in ( 0 , 1 )$ is positive hyperparameter. When $\\tau = 0$ , $\\pi _ { \\tau } = \\{ 1 / K , \\ldots , 1 / K \\}$ ",
+        "bbox": [
+            171,
+            638,
+            718,
+            656
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Optimizer updates the model parameters $\\pmb { w }$ . For each epoch, temporal parameters $\\tilde { \\pmb { w } } _ { 0 }$ is set to ${ \\pmb w } _ { \\tau }$ , and MGD iterates $T = \\bar { \\lceil m \\ / } ^ { } / b _ { k _ { \\tau } } \\rceil ^ { 1 }$ times using the selected batch size $b _ { k _ { \\tau } }$ where $m$ is the total number of training samples: ",
+        "bbox": [
+            173,
+            672,
+            825,
+            715
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d6baee42d8c69e30a7bc1377cf02e7f576dea606cfdcf927a3c3c12eb7efe433.jpg",
+        "text": "$$\n\\pmb { \\tilde { w } } _ { t + 1 } = \\pmb { \\tilde { w } } _ { t } - \\eta _ { \\tau } \\pmb { g } _ { t } , \\quad \\pmb { g } _ { t } = \\nabla J \\big ( \\pmb { \\tilde { w } } _ { t } \\big ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            372,
+            722,
+            625,
+            739
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "After $T$ iterations at epoch $\\tau$ , the model parameters is updated as ${ \\pmb w } _ { \\tau + 1 } = \\tilde { { \\pmb w } } _ { T }$ . Then, the optimizer obtains validation loss $\\ell$ , and outputs cost as follows: ",
+        "bbox": [
+            173,
+            746,
+            821,
+            775
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/94c723ba0057a4c6435c256282a221b19c4c1892781643b98b98dd9d210662dd.jpg",
+        "text": "$$\ny ^ { k _ { \\tau } } = \\left\\{ \\begin{array} { l l } { 0 } & { \\mathrm { i f ~ } \\ell ( { \\pmb w } _ { \\tau + 1 } ) < \\ell ( { \\pmb w } _ { \\tau } ) } \\\\ { 1 } & { \\mathrm { o t h e r w i s e } } \\end{array} \\right. .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            375,
+            781,
+            622,
+            816
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The RMGD samples an appropriate batch size from a probability distribution at each epoch. This probability distribution encourages exploration of different batch size and then later exploits batch size with history of success, which means decreasing validation loss. Figure 2 shows an example of training progress of RMGD. The figure represents the probability distribution with respect to epoch. The white dot represents the selected batch size at each epoch. In the early stage of training, commonly, all batch sizes tend to decrease validation loss: $\\pi$ is uniform. Thus, all batch size have equal probability of being sampled (exploration). In the later stages of training, the probability distribution varies based on success and failure. Thus, better performing batch size gets higher probability to be sampled (exploitation). In this case, 256 is the best performing batch size. ",
+        "bbox": [
+            173,
+            829,
+            825,
+            900
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/393c5dbfc9732321dbdc7f8b99038b41d854cfdb6752562f08df274188ebc0f2.jpg",
+        "image_caption": [
+            "Figure 2: The probability distribution vs epoch using the RMGD. (top) The early stages of the training. (bottom) The later stages of the training. The white dot represents the selected batch size at each epoch. In the early stages of the training, RMGD updates the probabilities to search various batch sizes (exploration), and in the later stages, RMGD increases the probability of successful batch size (exploitation). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            303,
+            103,
+            692,
+            324
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            433,
+            825,
+            491
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 REGRET BOUND ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            523,
+            330,
+            539
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The regret bound of the RMGD follows the regret bound derived in Shalev-Shwartz et al. (2012). The goal of this algorithm is to have low regret for not selecting the best performing batch size such that ",
+        "bbox": [
+            173,
+            550,
+            826,
+            593
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3d330720e1a58deba9cae3105e09753f467359d1aafbcdbae2fe6e9641d0de7f.jpg",
+        "text": "$$\n\\mathrm { R e g r e t } _ { \\mathcal T } ( S ) = \\mathbb { E } \\left[ \\sum _ { \\tau = 1 } ^ { \\mathcal T } y _ { \\tau } ^ { k _ { \\tau } } \\right] - \\operatorname* { m i n } _ { i } \\sum _ { \\tau = 1 } ^ { \\mathcal T } y _ { \\tau } ^ { i }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            357,
+            606,
+            640,
+            650
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where the expectation is over the algorithm’s randomness of batch size selection and the second term on the right-hand side is the cumulative sum of the cost by the best fixed batch size which minimizes the cumulative sum of the cost. The regret of the RMGD is bounded, ",
+        "bbox": [
+            174,
+            655,
+            825,
+            698
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b42688dc32c929fb5085a25bc1e5b545cd85f079308b2642287b510c82efa319.jpg",
+        "text": "$$\n\\mathbb { E } \\left[ \\sum _ { \\tau = 1 } ^ { \\mathcal { T } } y _ { \\tau } ^ { k _ { \\tau } } \\right] - \\operatorname* { m i n } _ { i } \\sum _ { \\tau = 1 } ^ { \\mathcal { T } } y _ { \\tau } ^ { i } \\leq \\frac { \\log K } { \\beta } + \\beta K \\mathcal { T } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            344,
+            707,
+            651,
+            751
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In particular, setting $\\beta = \\sqrt { \\log ( K ) / ( K T ) }$ , the regret is bounded by $2 \\sqrt { K \\log ( K ) \\mathcal { T } }$ , which is sublinear with $\\tau$ . The detailed derivation of regret bound is described in the appendix A. ",
+        "bbox": [
+            173,
+            767,
+            826,
+            799
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            834,
+            326,
+            851
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This section describes various experimental results on MNIST, CIFAR10, and CIFAR100 dataset. In the experiments, simple convolutional neural networks (CNN) is used for MNIST and ‘All-CNN$\\mathbf { C } '$ Springenberg et al. (2014) is used for CIFAR10 and CIFAR100. The details of the dataset and experimental settings are presented in the appendix B. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/91b09efdfa2510840f256bdd181664f5e17c00e91e5116f32e439c3299202af1.jpg",
+        "image_caption": [
+            "Figure 3: The probability distribution and selected batch size. The white dot is selected batch size at epoch. (top) The case that small batch size performs better. (middle) The case that large batch size performs better. (bottom) The case that best performing batch size varies. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            207,
+            102,
+            792,
+            266
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/2662561415f123e35fb57357b899adbbf21a3668da4d1f8a6b1b3807e88ca193.jpg",
+        "image_caption": [
+            "Figure 4: The results of test accuracy for the MNIST dataset. The error bar is standard error. (left) The test accuracy of 100 times repeated experiments with AdamOptimizer. (right) The test accuracy of 100 times repeated experiments with AdagradOptimizer. In both cases, most RMGD settings outperform all fixed MGD algorithms. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            209,
+            337,
+            790,
+            473
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.1 MNIST DATASET ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            569,
+            334,
+            583
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The validity of the RMGD was assessed by performing image classification on the MNIST dataset using AdamOptimizer and AdagradOptimizer as optimizer. The experiments were repeated 100 times for each algorithm and each optimizer, then the results were analyzed for significance. Figure 3 shows the probability distribution and the selected batch size with respect to epoch during training for the RMGD. The white dot represents the batch size selected at each epoch. The top figure is the case that small batch size (32) performs better. After epoch 50, batch size 32 gets high probability and is selected more than others. It means that batch size 32 has less misupdating in this case. The gradually increasing batch size algorithm may not perform well in this case. The middle figure is the case that large batch size (512) performs better. After epoch 60, batch size 512 gets high probability and selected more than others. The bottom figure shows that the best performing batch size varies with epoch. During epoch from 40 to 55, batch size of 256 performs best, and best performing batch size switches to 128 during epoch from 60 to 70, then better performing batch size backs to 256 after epoch 80. In the results, any batch size can be a successful batch size in the later stages without any particular order. The RMGD is more flexible for such situation than the MGD or directional adaptive MGD such as gradually increasing batch size algorithm. ",
+        "bbox": [
+            174,
+            597,
+            825,
+            805
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Figure 4 shows the test accuracy of each algorithm. The error bar is standard error. The number in parenthesis next to MGD represents the batch size used in the MGD. ’Basic’, ’sub’, ’super’, ’hinge’, and ’ratio’ in parenthesis next to RMGD represent RMGD settings ’batch size set equal to grid search, 0-1 loss’, ’subset of basic, 0-1 loss’, ’superset of basic, 0-1 loss’, ’basic set, hinge loss’, and ’basic set, percentage of non-negative changes in validation loss’, respectively. The left figure is the test accuracy with AdamOptimizer. The right figure is the test accuracy with AdagradOptimizer. Among the MGD algorithms, relatively small batch sizes (16 - 64) lead to higher performance than large batch sizes (128 - 512) and batch size 64 achieves the best performance in grid search. These results correspond with other studies Breuel (2015); Keskar et al. (2016); Mishkin et al. (2017). Most RMGD settings outperform all fixed MGD algorithms in both case. Although the performance of RMGD is not significantly increased compared to the best MGD, the purpose of this algorithm is not to improve performance, but to ensure that the best performance is achieved without performing a grid search on the batch size. Rather, the improved performance of the RMGD is a surprising result. Therefore, the RMGD is said to be valid. There are little performance gap among RMGD settings. The ’sub’ setting outperforms the ’basic’ setting in left figure, but the opposite result is shown in right figure. Therefore, there is no clear tendency of performance change depending on the size of the batch size set. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/9f62d8084184372dc53eb2be3e3e81738ad05f7c51a52f01e37311db27cde31d.jpg",
+        "table_caption": [
+            "Table 1: Iterations and real time for training, and test accuracy of MNIST classification with AdamOptimizer. The ’total’ is the sum of the average values from MGD 16 to 512, which means the whole grid search is performed. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=2 colspan=1>Algorithms</td><td rowspan=2 colspan=1>Iterations</td><td rowspan=2 colspan=1>Real time (sec)</td><td rowspan=1 colspan=3>Test accuracy (%)</td></tr><tr><td rowspan=1 colspan=1>Mean±SD</td><td rowspan=1 colspan=1>Max</td><td rowspan=1 colspan=1>Min</td></tr><tr><td rowspan=1 colspan=1>MGD (16)</td><td rowspan=1 colspan=1>343,800</td><td rowspan=1 colspan=1>1,221.54 ± 36.00</td><td rowspan=1 colspan=1>99.327 ± 0.064</td><td rowspan=1 colspan=1>99.480</td><td rowspan=1 colspan=1>99.140</td></tr><tr><td rowspan=1 colspan=1>MGD (32)</td><td rowspan=1 colspan=1>171,900</td><td rowspan=1 colspan=1>697.82 ± 19.70</td><td rowspan=1 colspan=1>99.322 ± 0.060</td><td rowspan=1 colspan=1>99.500</td><td rowspan=1 colspan=1>99.150</td></tr><tr><td rowspan=1 colspan=1>MGD (64)</td><td rowspan=1 colspan=1>86,000</td><td rowspan=1 colspan=1>379.14 ± 11.32</td><td rowspan=1 colspan=1>99.328 ± 0.058</td><td rowspan=1 colspan=1>99.460</td><td rowspan=1 colspan=1>99.170</td></tr><tr><td rowspan=1 colspan=1>MGD (128)</td><td rowspan=1 colspan=1>43,000</td><td rowspan=1 colspan=1>262.33 ± 2.34</td><td rowspan=1 colspan=1>99.314 ± 0.056</td><td rowspan=1 colspan=1>99.440</td><td rowspan=1 colspan=1>99.170</td></tr><tr><td rowspan=1 colspan=1>MGD (256)</td><td rowspan=1 colspan=1>21,500</td><td rowspan=1 colspan=1>208.13 ± 2.20</td><td rowspan=1 colspan=1>99.295 ± 0.059</td><td rowspan=1 colspan=1>99.470</td><td rowspan=1 colspan=1>99.170</td></tr><tr><td rowspan=1 colspan=1>MGD (512)</td><td rowspan=1 colspan=1>10,800</td><td rowspan=1 colspan=1>180.06 ± 0.37</td><td rowspan=1 colspan=1>99.254 ± 0.054</td><td rowspan=1 colspan=1>99.430</td><td rowspan=1 colspan=1>99.110</td></tr><tr><td rowspan=1 colspan=1>MGD (total)</td><td rowspan=1 colspan=1>677,000</td><td rowspan=1 colspan=1>2,949.02</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>RMGD (basic)</td><td rowspan=1 colspan=1>68,309 ± 8,900</td><td rowspan=1 colspan=1>333.73 ± 25.38</td><td rowspan=1 colspan=1>99.342 ± 0.064</td><td rowspan=1 colspan=1>99.480</td><td rowspan=1 colspan=1>99.110</td></tr><tr><td rowspan=1 colspan=1>RMGD (sub)</td><td rowspan=1 colspan=1>85,777 ± 12,112</td><td rowspan=1 colspan=1>400.73 ± 51.91</td><td rowspan=1 colspan=1>99.357± 0.057</td><td rowspan=1 colspan=1>99.510</td><td rowspan=1 colspan=1>99.060</td></tr><tr><td rowspan=1 colspan=1>RMGD (super)</td><td rowspan=1 colspan=1>67,948 ± 6,022</td><td rowspan=1 colspan=1>332.61 ± 22.26</td><td rowspan=1 colspan=1>99.345 ± 0.058</td><td rowspan=1 colspan=1>99.460</td><td rowspan=1 colspan=1>99.110</td></tr><tr><td rowspan=1 colspan=1>RMGD (hinge)</td><td rowspan=1 colspan=1>69,607 ± 8,887</td><td rowspan=1 colspan=1>337.38 ± 25.29</td><td rowspan=1 colspan=1>99.341 ± 0.062</td><td rowspan=1 colspan=1>99.480</td><td rowspan=1 colspan=1>99.130</td></tr><tr><td rowspan=1 colspan=1>RMGD (ratio)</td><td rowspan=1 colspan=1>95,530 ± 8,281</td><td rowspan=1 colspan=1>449.37 ± 26.71</td><td rowspan=1 colspan=1>99.339 ± 0.062</td><td rowspan=1 colspan=1>99.470</td><td rowspan=1 colspan=1>99.150</td></tr></table>",
+        "bbox": [
+            176,
+            155,
+            821,
+            357
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/030406485ad5d80605c3259a4bef58e9e64a75d53e664864b2a4317d47234bac.jpg",
+        "table_caption": [
+            "Table 2: Iterations and real time for training, and test accuracy of MNIST classification with AdagradOptimizer. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=2 colspan=1>Algorithms</td><td rowspan=2 colspan=1>Iterations</td><td rowspan=2 colspan=1>Real time (sec)</td><td rowspan=1 colspan=3>Test accuracy (%)</td></tr><tr><td rowspan=1 colspan=1>Mean± SD</td><td rowspan=1 colspan=1>Max</td><td rowspan=1 colspan=1>Min</td></tr><tr><td rowspan=1 colspan=1>MGD (16)</td><td rowspan=1 colspan=1>343,800</td><td rowspan=1 colspan=1>1,160.87 ± 22.34</td><td rowspan=1 colspan=1>99.268 ± 0.090</td><td rowspan=1 colspan=1>99.430</td><td rowspan=1 colspan=1>98.920</td></tr><tr><td rowspan=1 colspan=1>MGD (32)</td><td rowspan=1 colspan=1>171,900</td><td rowspan=1 colspan=1>640.68 ± 15.53</td><td rowspan=1 colspan=1>99.270 ± 0.070</td><td rowspan=1 colspan=1>99.410</td><td rowspan=1 colspan=1>99.050</td></tr><tr><td rowspan=1 colspan=1>MGD (64)</td><td rowspan=1 colspan=1>86,000</td><td rowspan=1 colspan=1>367.40 ± 12.63</td><td rowspan=1 colspan=1>99.277 ± 0.077</td><td rowspan=1 colspan=1>99.440</td><td rowspan=1 colspan=1>99.110</td></tr><tr><td rowspan=1 colspan=1>MGD (128)</td><td rowspan=1 colspan=1>43,000</td><td rowspan=1 colspan=1>262.48 ± 1.37</td><td rowspan=1 colspan=1>99.269 ± 0.069</td><td rowspan=1 colspan=1>99.410</td><td rowspan=1 colspan=1>99.080</td></tr><tr><td rowspan=1 colspan=1>MGD (256)</td><td rowspan=1 colspan=1>21,500</td><td rowspan=1 colspan=1>195.60 ± 2.00</td><td rowspan=1 colspan=1>99.240 ± 0.072</td><td rowspan=1 colspan=1>99.390</td><td rowspan=1 colspan=1>99.030</td></tr><tr><td rowspan=1 colspan=1>MGD (512)</td><td rowspan=1 colspan=1>10,800</td><td rowspan=1 colspan=1>170.31 ± 1.41</td><td rowspan=1 colspan=1>99.198 ± 0.085</td><td rowspan=1 colspan=1>99.390</td><td rowspan=1 colspan=1>98.810</td></tr><tr><td rowspan=1 colspan=1>MGD (total)</td><td rowspan=1 colspan=1>677,000</td><td rowspan=1 colspan=1>2,797.34</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>RMGD (basic)</td><td rowspan=1 colspan=1>68,159 ± 8,447</td><td rowspan=1 colspan=1>323.33 ± 23.57</td><td rowspan=1 colspan=1>99.286 ± 0.088</td><td rowspan=1 colspan=1>99.490</td><td rowspan=1 colspan=1>98.900</td></tr><tr><td rowspan=1 colspan=1>RMGD (sub)</td><td rowspan=1 colspan=1>81,479 ± 9,141</td><td rowspan=1 colspan=1>356.16 ± 28.06</td><td rowspan=1 colspan=1>99.272 ± 0.092</td><td rowspan=1 colspan=1>99.460</td><td rowspan=1 colspan=1>98.960</td></tr><tr><td rowspan=1 colspan=1>RMGD (super)</td><td rowspan=1 colspan=1>67,638 ± 7,733</td><td rowspan=1 colspan=1>320.38 ± 23.55</td><td rowspan=1 colspan=1>99.280 ± 0.074</td><td rowspan=1 colspan=1>99.410</td><td rowspan=1 colspan=1>99.090</td></tr><tr><td rowspan=1 colspan=1>RMGD (hinge)</td><td rowspan=1 colspan=1>68,199 ± 8,642</td><td rowspan=1 colspan=1>322.33 ± 24.03</td><td rowspan=1 colspan=1>99.282 ± 0.089</td><td rowspan=1 colspan=1>99.420</td><td rowspan=1 colspan=1>98.900</td></tr><tr><td rowspan=1 colspan=1>RMGD (ratio)</td><td rowspan=1 colspan=1>93,523 ± 9,871</td><td rowspan=1 colspan=1>452.69 ± 34.71</td><td rowspan=1 colspan=1>99.283 ± 0.078</td><td rowspan=1 colspan=1>99.480</td><td rowspan=1 colspan=1>99.020</td></tr></table>",
+        "bbox": [
+            179,
+            409,
+            818,
+            612
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            636,
+            825,
+            762
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 1 and 2 present iterations and real time for training, mean, maximum, and minimum of test accuracies for each algorithm with AdamOptimizer and AdagradOptimizer respectively. The MGD (total) is the summation of the iterations and real time of whole MGDs for grid search. The RMGD (basic) outperforms best performing MGD and is, also, faster than best performing MGD. Furthermore, it is 8 times faster than grid search in both cases. In the results, the RMGD is effective regardless of the optimizer. ",
+        "bbox": [
+            174,
+            768,
+            825,
+            853
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 CIFAR10 AND CIFAR100 DATASET ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            869,
+            465,
+            883
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The CIFAR10 and CIFAR100 dataset were, also, used to assess effectiveness of the RMGD. The experiments were repeated 25 times and 10 times, respectively. In these experiments, all images are whitened and contrast normalized before being input to the network. Figure 5 shows the test accuracy for each algorithm. The left figure represents the test accuracy on CIFAR10. In contrast to the MNIST results, relatively large batch sizes (128 - 256) lead to higher performance than small batch sizes (16 - 64) and batch size 256 achieves the best performance in grid search. The right figure represents the test accuracy on CIFAR100 and batch size 128 achieves the best performance in grid search. The results on MNIST, CIFAR10 and CIFAR100 indicate that it is difficult to know which batch size is optimal before performing a grid search. Meanwhile, all RMGD settings have again exceeded the best performance of fixed MGD. There are no significant performance gaps among RMGD settings, so there is no need to worry about choosing appropriate batch size set or selecting cost function. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/83cf85f8be95450921fe3c721fa1f71e9a0c5cdebfb9d9889bba5e873effcaca.jpg",
+        "image_caption": [
+            "Figure 5: The results of test accuracy for the CIFAR10 and CIFAR100 dataset. The error bar is standard error. (left) The test accuracy of 25 times repeated experiments on CIFAR10. (right) The test accuracy of 10 times repeated experiments on CIFAR100. In both cases, all RMGD settings outperform all fixed MGD algorithms. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            209,
+            99,
+            787,
+            242
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/a9aaf3cd25a73dcfe4af8dc335afb7b45d6457c823ada7447eceb053c28fdef0.jpg",
+        "table_caption": [
+            "Table 3: Iterations and real time for training, and test accuracy on CIFAR10. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=2 colspan=1>Algorithms</td><td rowspan=2 colspan=1>Iterations</td><td rowspan=2 colspan=1>Real time (sec)</td><td rowspan=1 colspan=3>Test accuracy (%)</td></tr><tr><td rowspan=1 colspan=1>Mean ± SD</td><td rowspan=1 colspan=1>Max</td><td rowspan=1 colspan=1>Min</td></tr><tr><td rowspan=1 colspan=1>MGD (16)</td><td rowspan=1 colspan=1>1,072,050</td><td rowspan=1 colspan=1>10,085.26 ± 216.48</td><td rowspan=1 colspan=1>87.778 ± 0.207</td><td rowspan=1 colspan=1>88.290</td><td rowspan=1 colspan=1>87.480</td></tr><tr><td rowspan=1 colspan=1>MGD (32)</td><td rowspan=1 colspan=1>536,200</td><td rowspan=1 colspan=1>7,643.93 ± 459.95</td><td rowspan=1 colspan=1>87.851 ± 0.160</td><td rowspan=1 colspan=1>88.250</td><td rowspan=1 colspan=1>87.630</td></tr><tr><td rowspan=1 colspan=1>MGD (64)</td><td rowspan=1 colspan=1>268,100</td><td rowspan=1 colspan=1>6,160.16 ± 68.54</td><td rowspan=1 colspan=1>87.853 ± 0.202</td><td rowspan=1 colspan=1>88.330</td><td rowspan=1 colspan=1>87.450</td></tr><tr><td rowspan=1 colspan=1>MGD (128)</td><td rowspan=1 colspan=1>134,050</td><td rowspan=1 colspan=1>5,675.15 ± 181.80</td><td rowspan=1 colspan=1>87.873 ± 0.234</td><td rowspan=1 colspan=1>88.210</td><td rowspan=1 colspan=1>87.090</td></tr><tr><td rowspan=1 colspan=1>MGD (256)</td><td rowspan=1 colspan=1>67,200</td><td rowspan=1 colspan=1>5,466.79 ± 402.20</td><td rowspan=1 colspan=1>87.897 ± 0.293</td><td rowspan=1 colspan=1>88.260</td><td rowspan=1 colspan=1>87.170</td></tr><tr><td rowspan=1 colspan=1>MGD (total)</td><td rowspan=1 colspan=1>2,077,600</td><td rowspan=1 colspan=1>35,031.29</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>RMGD (basic)</td><td rowspan=1 colspan=1>463,629 ± 48,692</td><td rowspan=1 colspan=1>7,592.43 ± 403.65</td><td rowspan=1 colspan=1>88.004 ± 0.167</td><td rowspan=1 colspan=1>88.380</td><td rowspan=1 colspan=1>87.780</td></tr><tr><td rowspan=1 colspan=1>RMGD (sub)</td><td rowspan=1 colspan=1>507,186 ± 93,961</td><td rowspan=1 colspan=1>7,614.16 ± 514.20</td><td rowspan=1 colspan=1>87.992 ± 0.147</td><td rowspan=1 colspan=1>88.270</td><td rowspan=1 colspan=1>87.730</td></tr><tr><td rowspan=1 colspan=1>RMGD (super)</td><td rowspan=1 colspan=1>397,685 ± 33,535</td><td rowspan=1 colspan=1>7,426.11 ± 228.28</td><td rowspan=1 colspan=1>88.027 ± 0.179</td><td rowspan=1 colspan=1>88.340</td><td rowspan=1 colspan=1>87.760</td></tr><tr><td rowspan=1 colspan=1>RMGD (hinge)</td><td rowspan=1 colspan=1>459,664± 56,086</td><td rowspan=1 colspan=1>7,584.01 ± 439.62</td><td rowspan=1 colspan=1>88.003 ± 0.167</td><td rowspan=1 colspan=1>88.380</td><td rowspan=1 colspan=1>87.810</td></tr><tr><td rowspan=1 colspan=1>RMGD (ratio)</td><td rowspan=1 colspan=1>426,123 ± 15,213</td><td rowspan=1 colspan=1>7,561.72 ± 220.56</td><td rowspan=1 colspan=1>88.002 ± 0.129</td><td rowspan=1 colspan=1>88.330</td><td rowspan=1 colspan=1>87.770</td></tr></table>",
+        "bbox": [
+            173,
+            345,
+            836,
+            534
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/ac0f9ee16fa12cf9a58c9527a1180a42b11ec2f3f62337ba48bcb8fb3ad8ab82.jpg",
+        "table_caption": [
+            "Table 4: Iterations and real time for training, and test accuracy on CIFAR100. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=2 colspan=1>Algorithms</td><td rowspan=2 colspan=1>Iterations</td><td rowspan=2 colspan=1>Real time (sec)</td><td rowspan=1 colspan=3>Test accuracy (%)</td></tr><tr><td rowspan=1 colspan=1>Mean ± SD</td><td rowspan=1 colspan=1>Max</td><td rowspan=1 colspan=1>Min</td></tr><tr><td rowspan=1 colspan=1>MGD (16)</td><td rowspan=1 colspan=1>1,072,050</td><td rowspan=1 colspan=1>12,097.47 ± 57.47</td><td rowspan=1 colspan=1>60.247 ± 0.690</td><td rowspan=1 colspan=1>61.940</td><td rowspan=1 colspan=1>59.620</td></tr><tr><td rowspan=1 colspan=1>MGD (32)</td><td rowspan=1 colspan=1>536,200</td><td rowspan=1 colspan=1>8,058.14 ± 39.87</td><td rowspan=1 colspan=1>60.475 ± 0.721</td><td rowspan=1 colspan=1>61.750</td><td rowspan=1 colspan=1>59.290</td></tr><tr><td rowspan=1 colspan=1>MGD (64)</td><td rowspan=1 colspan=1>268,100</td><td rowspan=1 colspan=1>6,400.21 ± 12.78</td><td rowspan=1 colspan=1>60.628 ± 0.795</td><td rowspan=1 colspan=1>61.950</td><td rowspan=1 colspan=1>59.170</td></tr><tr><td rowspan=1 colspan=1>MGD (128)</td><td rowspan=1 colspan=1>134,050</td><td rowspan=1 colspan=1>5,598.85 ± 38.18</td><td rowspan=1 colspan=1>60.954 ± 0.834</td><td rowspan=1 colspan=1>62.120</td><td rowspan=1 colspan=1>59.530</td></tr><tr><td rowspan=1 colspan=1>MGD (256)</td><td rowspan=1 colspan=1>67,200</td><td rowspan=1 colspan=1>5,245.88 ± 40.67</td><td rowspan=1 colspan=1>60.504 ± 0.553</td><td rowspan=1 colspan=1>61.560</td><td rowspan=1 colspan=1>59.830</td></tr><tr><td rowspan=1 colspan=1>MGD (total)</td><td rowspan=1 colspan=1>2,077,600</td><td rowspan=1 colspan=1>37,400.55</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>RMGD (basic)</td><td rowspan=1 colspan=1>425,416± 44,392</td><td rowspan=1 colspan=1>7,503.09 ± 281.79</td><td rowspan=1 colspan=1>61.203 ± 0.502</td><td rowspan=1 colspan=1>62.050</td><td rowspan=1 colspan=1>60.310</td></tr><tr><td rowspan=1 colspan=1>RMGD (sub)</td><td rowspan=1 colspan=1>532,624 ± 69,195</td><td rowspan=1 colspan=1>7,841.88 ± 530.29</td><td rowspan=1 colspan=1>61.080 ± 0.720</td><td rowspan=1 colspan=1>61.910</td><td rowspan=1 colspan=1>59.900</td></tr><tr><td rowspan=1 colspan=1>RMGD (super)</td><td rowspan=1 colspan=1>397,717 ± 20,091</td><td rowspan=1 colspan=1>7,408.00 ± 163.74</td><td rowspan=1 colspan=1>61.166 ± 0.560</td><td rowspan=1 colspan=1>61.970</td><td rowspan=1 colspan=1>60.320</td></tr><tr><td rowspan=1 colspan=1>RMGD (hinge)</td><td rowspan=1 colspan=1>419,100 ± 53,491</td><td rowspan=1 colspan=1>7,476.71 ± 324.29</td><td rowspan=1 colspan=1>61.219 ± 0.714</td><td rowspan=1 colspan=1>62.060</td><td rowspan=1 colspan=1>59.580</td></tr><tr><td rowspan=1 colspan=1>RMGD (ratio)</td><td rowspan=1 colspan=1>412,532 ±15,660</td><td rowspan=1 colspan=1>7,456.50 ± 100.79</td><td rowspan=1 colspan=1>61.340 ± 0.411</td><td rowspan=1 colspan=1>61.880</td><td rowspan=1 colspan=1>60.550</td></tr></table>",
+        "bbox": [
+            173,
+            571,
+            828,
+            758
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            784,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 3 and 4 present the detailed results on CIFAR10 and CIFAR100 dataset. The RMGD (basic) is a little slower than single best performing MGD (256 for CIFAR10 and 128 for CIFAR100), however, it was much faster than grid search -about 4.6 times on CIFAR10 and 5.0 times on CIFAR100 faster. Therefore, this results, also, show the effectiveness of the RMGD. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            159
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "It is difficult to compare the RMGD with other adaptive batch size algorithm, e.g. coupling adaptive batch sizes (CABS) Balles et al. (2017), directly since the underlying goals are different. While the goal of the RMGD is to reduce the validation loss in terms of generalization performance, the CABS determines the batch size to balance between the gradient variance and computation. However, it is obvious that the RMGD is simpler and easier to implement than any other adaptive algorithm cited in this paper, and comparing the test accuracy between the RMGD and the CABS on the CIFAR10 and CIFAR100 using the same experimental settings with ’All-CNN-C’ shows that the performance of the RMGD is higher than that of the CABS (CIFAR10: $8 7 . 8 6 2 \\pm 0 . 1 4 2$ , CIFAR100: 60.782 $\\pm \\ : 0 . 4 2 1 $ ). And again, the purpose of this algorithm is not to outperform other algorithms, but to guarantee that the best performance is reached without grid search. ",
+        "bbox": [
+            174,
+            166,
+            825,
+            305
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            328,
+            289,
+            343
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Selecting batch size affects the model quality and training efficiency, and determining the appropriate batch size is time consuming and requires considerable resources as it often relies on grid search. The focus of this paper is to design a simple robust algorithm that is theoretically sound and applicable in many situations. ",
+        "bbox": [
+            176,
+            358,
+            823,
+            414
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "This paper considers a resizable mini-batch gradient descent (RMGD) algorithm based on a multiarmed bandit that achieves equivalent performance to that of best fixed batch-size. At each epoch, the RMGD samples a batch size according to certain probability distribution of a batch being successful in reducing the loss function. Sampling from this probability provides a mechanism for exploring different batch size and exploiting batch sizes with history of success. After obtaining the validation loss at each epoch with the sampled batch size, the probability distribution is updated to incorporate the effectiveness of the sampled batch size. ",
+        "bbox": [
+            174,
+            421,
+            825,
+            518
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The goal of this algorithm is not to achieve state-of-the-art accuracy but rather to select appropriate batch size which leads low misupdating and performs better. The RMGD essentially assists the learning process to explore the possible domain of the batch size and exploit successful batch size. The benefit of RMGD is that it avoids the need for cumbersome grid search to achieve best performance and that it is simple enough to apply to various field of machine learning including deep learning using MGD. Experimental results show that the RMGD achieves the best grid search performance on various dataset, networks, and optimizers. Furthermore, it, obviously, attains this performance in a shorter amount of time than the grid search. Also, there is no need to worry about which batch size set or cost function to choose when setting RMGD. In conclusion, the RMGD is effective and flexible mini-batch gradient descent algorithm. ",
+        "bbox": [
+            174,
+            526,
+            825,
+            665
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            688,
+            285,
+            702
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Lukas Balles, Javier Romero, and Philipp Hennig. Coupling adaptive batch sizes with learning rates. In Proceedings of the Thirty-Third Conference on Uncertainty in Artificial Intelligence, UAI 2017, Sydney, Australia, August 11-15, 2017, 2017. URL http://auai.org/uai2017/ proceedings/papers/141.pdf. ",
+        "bbox": [
+            174,
+            710,
+            826,
+            767
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yoshua Bengio. Practical recommendations for gradient-based training of deep architectures. In Neural networks: Tricks of the trade, pp. 437–478. Springer, 2012. ",
+        "bbox": [
+            169,
+            777,
+            823,
+            806
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Thomas M Breuel. The effects of hyperparameters on sgd training of neural networks. arXiv preprint arXiv:1508.02788, 2015. ",
+        "bbox": [
+            171,
+            816,
+            823,
+            844
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Richard H Byrd, Gillian M Chin, Jorge Nocedal, and Yuchen Wu. Sample size selection in optimization methods for machine learning. Mathematical programming, 134(1):127–155, 2012. ",
+        "bbox": [
+            171,
+            856,
+            823,
+            885
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Soham De, Abhay Yadav, David Jacobs, and Tom Goldstein. Big batch sgd: Automated inference using adaptive batch sizes. arXiv preprint arXiv:1610.05792, 2016. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Michael P Friedlander and Mark Schmidt. Hybrid deterministic-stochastic methods for data fitting. SIAM Journal on Scientific Computing, 34(3):A1380–A1405, 2012.   \nElad Hazan and Satyen Kale. Extracting certainty from uncertainty: Regret bounded by variation in costs. Machine learning, 80(2-3):165–188, 2010.   \nKevin Jamieson and Ameet Talwalkar. Non-stochastic best arm identification and hyperparameter optimization. In Artificial Intelligence and Statistics, pp. 240–248, 2016.   \nStanislaw Jastrzkebski, Zachary Kenton, Devansh Arpit, Nicolas Ballas, Asja Fischer, Yoshua Bengio, and Amos Storkey. Three factors influencing minima in sgd. arXiv preprint arXiv:1711.04623, 2017.   \nNitish Shirish Keskar, Dheevatsa Mudigere, Jorge Nocedal, Mikhail Smelyanskiy, and Ping Tak Peter Tang. On large-batch training for deep learning: Generalization gap and sharp minima. arXiv preprint arXiv:1609.04836, 2016.   \nLisha Li, Kevin Jamieson, Giulia DeSalvo, Afshin Rostamizadeh, and Ameet Talwalkar. Hyperband: A novel bandit-based approach to hyperparameter optimization. The Journal of Machine Learning Research, 18(1):6765–6816, 2017.   \nDmytro Mishkin, Nikolay Sergievskiy, and Jiri Matas. Systematic evaluation of convolution neural network advances on the imagenet. Computer Vision and Image Understanding, 161:11–19, 2017.   \nShai Shalev-Shwartz et al. Online learning and online convex optimization. Foundations and Trends $\\textsuperscript { \\textregistered }$ in Machine Learning, 4(2):107–194, 2012.   \nSamuel L Smith, Pieter-Jan Kindermans, and Quoc V Le. Don’t decay the learning rate, increase the batch size. arXiv preprint arXiv:1711.00489, 2017.   \nJost Tobias Springenberg, Alexey Dosovitskiy, Thomas Brox, and Martin Riedmiller. Striving for simplicity: The all convolutional net. arXiv preprint arXiv:1412.6806, 2014.   \nD Randall Wilson and Tony R Martinez. The general inefficiency of batch training for gradient descent learning. Neural Networks, 16(10):1429–1451, 2003. ",
+        "bbox": [
+            171,
+            92,
+            826,
+            554
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            264,
+            117
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A REGRET BOUND ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            135,
+            352,
+            152
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "In the RMGD algorithm, there are $K$ batch sizes as multi arms with the probability distribution $\\pi \\in S$ , and at each epoch the algorithm should select one of the batch sizes $b _ { k _ { \\tau } }$ . Then it receives a cost of selecting this arm, $y _ { \\tau } ^ { k _ { \\tau } } \\in \\{ 0 , 1 \\}$ by testing the validation loss $\\ell$ . The vector ${ \\pmb y } _ { \\tau } \\in \\{ 0 , 1 \\} ^ { K }$ represents the selecting cost for each batch size. The goal of this algorithm is to have low regret for not selecting the best performing batch size. ",
+        "bbox": [
+            173,
+            166,
+            826,
+            237
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/431adbfa21fa0c05ce6fb8d9cfb30662156df1ffb8866614d82206734d88ccb3.jpg",
+        "text": "$$\n\\mathrm { R e g r e t } _ { \\mathcal { T } } ( S ) = \\mathbb { E } \\left[ \\sum _ { \\tau = 1 } ^ { \\mathcal { T } } y _ { \\tau } ^ { k _ { \\tau } } \\right] - \\operatorname* { m i n } _ { i } \\sum _ { \\tau = 1 } ^ { \\mathcal { T } } y _ { \\tau } ^ { i }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            356,
+            242,
+            640,
+            286
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "where the expectation is over the algorithm’s randomness of batch size selection. ",
+        "bbox": [
+            173,
+            290,
+            700,
+            305
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Let $S$ be the probability simplex, the selecting loss functions be $f _ { \\tau } ( \\pmb { \\pi } ) = \\langle \\pmb { \\pi } , \\pmb { y } _ { \\tau } \\rangle ^ { 2 }$ and $R : S  \\mathbb { R }$ be a regularization function that is often chosen to be strongly convex with respect to some norm $\\| \\cdot \\|$ . The algorithm select a batch size with probability $\\mathbb { P } [ b _ { k _ { \\tau } } ] = \\pi _ { \\tau } ^ { k _ { \\tau } }$ and therefore $f _ { \\tau } ( \\pmb { \\pi } _ { \\tau } )$ is the expected cost of the selected batch size at epoch $\\tau$ . The gradient of the selecting loss function is ${ \\pmb y } _ { \\tau }$ . However, only one element $y _ { \\tau } ^ { k _ { \\tau } }$ is known at each epoch. To estimate gradient, random vector $z _ { \\tau }$ is defined as follows: ",
+        "bbox": [
+            173,
+            310,
+            826,
+            393
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d373983ffd1d42335a595cd84d255ea209ee25d6f50f3b8b148da222feb47a19.jpg",
+        "text": "$$\nz _ { \\tau } ^ { i } = \\left\\{ \\begin{array} { c l } { { y _ { \\tau } ^ { i } / \\pi _ { \\tau } ^ { i } } } & { { \\mathrm { i f ~ } i = k _ { \\tau } } } \\\\ { { 0 } } & { { \\mathrm { o t h e r w i s e } } } \\end{array} \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            400,
+            390,
+            586,
+            425
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "and expectation of $z _ { \\tau }$ satisfies, ",
+        "bbox": [
+            174,
+            426,
+            379,
+            440
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7c14a83ca78ab46cc6dd7a340615e3ecf455bb5778f70ab41882e7938ca85a62.jpg",
+        "text": "$$\n\\mathbb { E } [ z _ { \\tau } | z _ { \\tau - 1 } , \\dots , z _ { 0 } ] = \\sum _ { i = 1 } ^ { K } \\mathbb { P } [ b _ { k _ { \\tau } } ] z _ { \\tau } ^ { i } = \\pi _ { \\tau } ^ { k _ { \\tau } } \\frac { y _ { \\tau } ^ { k _ { \\tau } } } { \\pi _ { \\tau } ^ { k _ { \\tau } } } = y _ { \\tau } ^ { k _ { \\tau } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            316,
+            446,
+            679,
+            489
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "The most natural learning rule is to set the probability distribution which has minimal cost on all past epochs. It is referred to as Follow-the-Regularized-Leader (FTRL) in online learning: ",
+        "bbox": [
+            174,
+            494,
+            823,
+            523
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f6d899d50a7b06a34150d350f1539b27e5c67d0f338416026fb558f28b26da5c.jpg",
+        "text": "$$\n\\forall \\tau , \\quad \\pi _ { \\tau + 1 } = \\underset { \\pi \\in S } { \\arg \\operatorname* { m i n } } \\left\\{ \\beta \\sum _ { t = 1 } ^ { \\tau } f _ { t } ( \\pi ) + R ( \\pi ) \\right\\} ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            334,
+            527,
+            658,
+            571
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "where $\\beta$ is positive hyperparameter. The FTRL has a problem that it requires solving an optimization problem at each epoch. To solve this problem, Online Mirror Descent (OMD) is applied. The OMD computes the current probability distribution iteratively based on a gradient update rule and the previous probability distribution and lies in the update being carried out in a ’dual’ space, defined by regularizer. This follows from considering $\\nabla R$ as a mapping from $\\mathbb { R } ^ { K }$ onto itself. The OMD relies on Bregman divergence. The Bregman divergence between $\\pi$ and $\\tilde { \\pi }$ with respect to the regularizer $R$ is given as: ",
+        "bbox": [
+            173,
+            575,
+            825,
+            671
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/68b064abd9eb40b0079dd8133bc776792329f4cf9a583966e527ba06d5d04570.jpg",
+        "text": "$$\nB _ { R } ( { \\pmb \\pi } \\| { \\tilde { \\pmb \\pi } } ) = R ( { \\pmb \\pi } ) - R ( { \\tilde { \\pmb \\pi } } ) - \\nabla R ( { \\tilde { \\pmb \\pi } } ) \\cdot ( { \\pmb \\pi } - { \\tilde { \\pmb \\pi } } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            334,
+            671,
+            661,
+            689
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "and a Bregman projection of $\\tilde { \\pi }$ onto simplex $S$ : ",
+        "bbox": [
+            173,
+            690,
+            486,
+            705
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ad00c0dcfb7f98b1c86e380070f16c6c3a7e0e3dd335af619b43ff0fb00aa442.jpg",
+        "text": "$$\n\\operatorname { a r g m i n } _ { \\pi \\in S } B _ { R } ( \\pi \\| { \\tilde { \\pi } } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            434,
+            710,
+            562,
+            737
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Then the probability distribution is updated by the OMD as follows: ",
+        "bbox": [
+            173,
+            742,
+            620,
+            757
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e0ff4dc61c8a249a230ebf084efd14dd5e24dd01244f519c9a9f495390c21fab.jpg",
+        "text": "$$\n\\begin{array} { r c l } { \\nabla R ( \\tilde { \\pmb { \\pi } } _ { \\tau + 1 } ) } & { = } & { \\nabla R ( \\tilde { \\pmb { \\pi } } _ { \\tau } ) - \\beta \\pmb { z } _ { \\tau } } \\\\ { \\pmb { \\pi } _ { \\tau + 1 } } & { = } & { \\underset { \\pmb { \\pi } \\in S } { \\arg \\operatorname* { m i n } } B _ { R } ( \\pmb { \\pi } \\| \\tilde { \\pmb { \\pi } } _ { \\tau + 1 } ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            361,
+            761,
+            635,
+            806
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "In general, if $R$ is strongly convex, then $\\nabla R$ becomes a bijective mapping, thus $\\tilde { \\pi } _ { \\tau + 1 }$ can be recovered by the inverse gradient mapping $( \\nabla R ) ^ { - 1 }$ . Given that $R$ is strongly convex, the OMD and FTRL produce equivalent predictions: ",
+        "bbox": [
+            174,
+            810,
+            825,
+            854
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5d08eeea658be5763c82537c22583cb6dc46b77673fdbfbb0009671a4ddc1a19.jpg",
+        "text": "$$\n\\underset { \\pi \\in S } { \\arg \\operatorname* { m i n } } B _ { R } ( \\pi \\| \\tilde { \\pi } _ { \\tau + 1 } ) = \\underset { \\pi \\in S } { \\arg \\operatorname* { m i n } } \\left\\{ \\beta \\sum _ { t = 1 } ^ { \\tau } f _ { t } ( \\pi ) + R ( \\pi ) \\right\\}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            303,
+            858,
+            692,
+            901
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "by the Lemma 1 in Hazan & Kale (2010). It makes sense to use the negative entropic regularization for $R$ in RMGD setting: ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2b6d1263d70be2f880d6ae0f9de7605411613d2dbce8d4b82576c54b46032630.jpg",
+        "text": "$$\nR ( { \\pmb \\pi } ) = \\sum _ { i = 1 } ^ { K } \\pi ^ { i } \\log ( \\pi ^ { i } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            418,
+            132,
+            578,
+            176
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Then, $\\nabla R ( { \\pmb \\pi } ) _ { i } = \\log ( \\pi ^ { i } ) + 1$ . From the OMD, $\\tilde { \\pi } _ { \\tau + 1 }$ is updated as follows: ",
+        "bbox": [
+            173,
+            183,
+            673,
+            199
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6836b40b634ec7fb0b856ce5b1f2868f8fc12fc9fe472e99d5e5a8d5515de0ae.jpg",
+        "text": "$$\n\\begin{array} { r c l } { \\nabla R ( \\tilde { \\pi } _ { \\tau + 1 } ) } & { = } & { \\nabla R ( \\tilde { \\pi } _ { \\tau } ) - \\beta z _ { \\tau } } \\\\ { \\log ( \\tilde { \\pi } _ { \\tau + 1 } ^ { i } ) + 1 } & { = } & { \\log ( \\tilde { \\pi } _ { \\tau } ^ { i } ) + 1 - \\beta z _ { \\tau } ^ { i } } \\\\ { \\tilde { \\pi } _ { \\tau + 1 } ^ { i } } & { = } & { \\tilde { \\pi } _ { \\tau } ^ { i } e ^ { - \\beta z _ { \\tau } ^ { i } } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            362,
+            205,
+            633,
+            268
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The Bregman projection with respect to the negative entropy function becomes scaling by the $\\ell _ { 1 }$ - norm. Therefore, ",
+        "bbox": [
+            173,
+            273,
+            823,
+            303
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/41d63033c0f1b3420f469809e65a825613ff7c8e7f13c9a8f4044254fac32141.jpg",
+        "text": "$$\n\\pi _ { \\tau + 1 } ^ { i } = \\frac { \\tilde { \\pi } _ { \\tau + 1 } ^ { i } } { \\sum _ { j } \\tilde { \\pi } _ { \\tau + 1 } ^ { j } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            434,
+            301,
+            563,
+            343
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The probability distribution $\\pi _ { \\tau }$ is updated by the rule of the normalized exponentiated gradient (normalized-EG) algorithm described in Algorithm 1. Also, the selecting loss function is linear and it is satisfied that $\\forall \\tau , i$ we have $\\beta z _ { \\tau } ^ { i } \\geq 0$ . Then, ",
+        "bbox": [
+            173,
+            347,
+            826,
+            390
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fc024e35ad28d9410461a81cea3b6150c66f8a2407cc5e5fffe31758063be28e.jpg",
+        "text": "$$\n\\sum _ { \\tau = 1 } ^ { T } \\langle \\pi _ { \\tau } - \\pi ^ { * } , z _ { \\tau } \\rangle \\leq \\frac { \\log ( K ) } { \\beta } + \\beta \\sum _ { \\tau = 1 } ^ { T } \\sum _ { i = 1 } ^ { K } \\pi _ { \\tau } ^ { i } ( z _ { \\tau } ^ { i } ) ^ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            330,
+            398,
+            668,
+            443
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "by the Theorem 2.22 in Shalev-Shwartz et al. (2012), where $\\pi ^ { * } \\in S$ is a fixed vector which minimizes the cumulative selecting loss, ",
+        "bbox": [
+            173,
+            449,
+            825,
+            479
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1bfefbb88e8fd1a42148a12649a4a1e04b91b6180cc31cf6ff2fe3d261639249.jpg",
+        "text": "$$\n\\pi ^ { * } = \\arg \\operatorname* { m i n } _ { \\pi \\in S } \\sum _ { \\tau = 1 } ^ { \\tau } f _ { \\tau } ( \\pi ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            413,
+            487,
+            584,
+            531
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Since $f _ { \\tau }$ is convex and $z _ { \\tau }$ is estimated gradients for all $\\tau$ ",
+        "bbox": [
+            173,
+            537,
+            552,
+            554
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/44c7377107f3c206f1cec5ff8e1c97b105c1b802ec504996f12f47f2f4bceb26.jpg",
+        "text": "$$\n\\mathbb { E } \\left[ \\sum _ { \\tau = 1 } ^ { \\mathcal { T } } ( f _ { \\tau } ( \\pi _ { \\tau } ) - f _ { \\tau } ( \\pi ^ { * } ) ) \\right] \\leq \\frac { \\log ( K ) } { \\beta } + \\beta \\sum _ { \\tau = 1 } ^ { \\mathcal { T } } \\mathbb { E } \\left[ \\sum _ { i = 1 } ^ { K } \\pi _ { \\tau } ^ { i } ( z _ { \\tau } ^ { i } ) ^ { 2 } \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            281,
+            561,
+            717,
+            606
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "by the Theorem 4.1 in Shalev-Shwartz et al. (2012). The last term is bounded as follows: ",
+        "bbox": [
+            169,
+            619,
+            754,
+            636
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/861f12fe554f97c6f0d40f29836513646063c4bdbc248b1c3114ff16bb8e016d.jpg",
+        "text": "$$\n\\begin{array} { r c l } { \\mathbb { E } \\left[ \\displaystyle \\sum _ { i = 1 } ^ { K } \\pi _ { \\tau } ^ { i } ( z _ { \\tau } ^ { i } ) ^ { 2 } \\right] } & { = } & { \\displaystyle \\sum _ { j = 1 } ^ { K } \\mathbb { P } [ k _ { \\tau } = j ] \\sum _ { i = 1 } ^ { K } \\pi _ { \\tau } ^ { i } ( z _ { \\tau } ^ { i } ) ^ { 2 } } \\\\ & { = } & { \\displaystyle \\sum _ { j = 1 } ^ { K } ( \\pi _ { \\tau } ^ { j } ) ^ { 2 } ( y _ { \\tau } ^ { j } / \\pi _ { \\tau } ^ { j } ) ^ { 2 } } \\\\ & { = } & { \\displaystyle \\sum _ { j = 1 } ^ { K } ( y _ { \\tau } ^ { j } ) ^ { 2 } \\leq K . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            330,
+            643,
+            665,
+            784
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Therefore, the regret of the RMGD is bounded, ",
+        "bbox": [
+            173,
+            796,
+            485,
+            811
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a90bb3ea62c139d1048753c10e5b382054db8b5780fd0c85c731cf51d469e132.jpg",
+        "text": "$$\n\\mathbb { E } \\left[ \\sum _ { \\tau = 1 } ^ { \\mathcal { T } } y _ { \\tau } ^ { k _ { \\tau } } \\right] - \\operatorname* { m i n } _ { i } \\sum _ { \\tau = 1 } ^ { \\mathcal { T } } y _ { \\tau } ^ { i } \\leq \\frac { \\log K } { \\beta } + \\beta K \\mathcal { T } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            344,
+            819,
+            651,
+            863
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "In particular, setting $\\beta = \\sqrt { \\log ( K ) / ( K T ) }$ , the regret is bounded by $2 \\sqrt { K \\log ( K ) \\mathcal { T } }$ , which is sublinear with $\\tau$ . ",
+        "bbox": [
+            173,
+            880,
+            825,
+            910
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B EXPERIMENTAL SETTINGS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            434,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "DATASET ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            133,
+            240,
+            147
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "MNIST is a dataset of handwritten digits that is commonly used for image classification. Each sample is a black and white image and $2 8 \\times 2 8$ in size. The MNIST is split into three parts: 55,000 samples for training, 5,000 samples for validation, and 10,000 samples for test. ",
+        "bbox": [
+            174,
+            160,
+            825,
+            202
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "CIFAR10 consists of $6 0 { , } 0 0 0 \\ 3 2 \\times 3 2$ color images in 10 classes (airplane, automobile, bird, cat, deer, dog, frog, horse, ship, and truck), with 6,000 images per class. The CIFAR10 is split into three parts: 45,000 samples for training, 5,000 samples for validation, and 10,000 samples for test. ",
+        "bbox": [
+            174,
+            222,
+            825,
+            263
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "CIFAR100 consists of $6 0 { , } 0 0 0 \\ 3 2 \\times 3 2$ color images in 100 classes. The CIFAR100 is split into three parts: 45,000 samples for training, 5,000 samples for validation, and 10,000 samples for test. ",
+        "bbox": [
+            174,
+            285,
+            825,
+            314
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "SETTINGS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            344,
+            245,
+            358
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The simple CNN consists of two convolution layers with $5 \\times 5$ filter and $1 \\times 1$ stride, two max pooling layers with $2 \\times 2$ kernel and $2 \\times 2$ stride, single fully-connected layer, and softmax classifier. Description of the ’All-CNN-C’ is provided in Table 5. For MNIST, AdamOptimizer with $\\eta = 1 0 ^ { - 4 }$ and AdagradOptimizer with $\\eta = 0 . 1$ are used as optimizer. The basic batch size set $B = \\{ 1 6 , 3 2 , 6 4 , 1 2 8 , 2 5 6 , 5 1 2 \\}$ , subset of basic $B ^ { - } ~ = ~ \\{ 1 6 , 6 4 , 2 5 6 \\}$ , and superset of basic $B ^ { + } ~ = ~ \\{ 1 6 , 2 4 , 3 2 , 4 8 , 6 4 , 9 6 , 1 2 8 , 1 9 2 , 2 5 6 , 3 8 ^ { \\circ }$ 4, 512}. The model is trained for a total of 100 epochs. For CIFAR10 and CIFAR100, MomentumOptimizer with fixed momentum of 0.9 is used as optimizer. The learning rate $\\eta ^ { k }$ is scaled up proportionately to the batch size $( \\eta ^ { k } = 0 . 0 5 * b _ { k } / 2 5 6 )$ and decayed by a schedule $S = [ 2 0 0 , 2 5 0 , 3 0 0 ]$ in which $\\dot { \\boldsymbol { \\eta } } ^ { k }$ is multiplied by a fixed multiplier of 0.1 after 200, 250, and 300 epochs respectively. The model is trained for a total of 350 epochs. Dropout is applied to the input image as well as after each convolution layer with stride 2. The dropout probabilities are $20 \\%$ for dropping out inputs and $50 \\%$ otherwise. The model is regularized with weight decay $\\lambda ~ = ~ 0 . 0 0 1$ . The basic batch size set $B = \\{ 1 6 , 3 2 , 6 2 , 1 2 8 , 2 5 6 \\}$ , subset of basic $B ^ { - } = \\{ 1 6 , 6 4 , 2 5 6 \\}$ , and superset of basic $B ^ { + } = \\{ 1 6 , 2 4 , 3 2 , 4 8 , 6 4 , 9 6 , 1 2 8 , 1 9 2 , 2$ $2 5 6 \\}$ . For all experiments, rectified linear unit (ReLU) is used as activation function. For RMGD, $\\beta$ is set to $\\sqrt { \\log ( 6 ) / ( 6 * 1 0 0 ) } \\approx 0 . 0 5 5$ for MNIST and $\\sqrt { \\log ( 5 ) / ( 5 * 3 5 0 ) } \\approx 0 . 0 3 0$ for CIFAR10 and CIFAR100. The basic batch size selecting cost is 0-1 loss, hinge loss is $\\operatorname* { m a x } \\{ 0 , \\ell _ { \\tau } - \\ell _ { \\tau - 1 } \\}$ , and ratio loss is $\\operatorname* { m a x } \\{ 0 , ( \\ell _ { \\tau } - \\ell _ { \\tau - 1 } ) / \\ell _ { \\tau - 1 } \\}$ . ",
+        "bbox": [
+            173,
+            369,
+            825,
+            625
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/6a2e8eadec23d42d6f393311e05ac50c2df82555786499b89848294030db0f3c.jpg",
+        "table_caption": [
+            "Table 5: Architecture of the All-CNN-C for CIFAR10 and CIFAR100 "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Layer</td><td>Layerdescription</td></tr><tr><td>input conv1</td><td>Input 32 × 32 RGB image 3 × 3 conv. 96 ReLU, stride 1, dropout 0.2</td></tr><tr><td>conv2</td><td>3 × 3 conv. 96 ReLU, stride 1</td></tr><tr><td>conv3</td><td>3 × 3 conv.96 ReLU, stride 2</td></tr><tr><td>conv4</td><td>3 × 3 conv.192 ReLU, stride 1, dropout 0.5</td></tr><tr><td>conv5</td><td>3 × 3 conv.192 ReLU, stride 1</td></tr><tr><td>conv6</td><td>3 × 3 conv. 192 ReLU, stride 2</td></tr><tr><td>conv7</td><td>3 × 3 conv.192 ReLU, stride 1, dropout 0.5</td></tr><tr><td>conv8</td><td>1 × 1 conv.192 ReLU, stride 1</td></tr><tr><td>conv9</td><td></td></tr><tr><td>pool</td><td>1 × 1 conv. 10 or 100 ReLU, stride 1</td></tr><tr><td></td><td>averaging over 6 × 6 spatial dimensions</td></tr><tr><td>softmax</td><td>10-way or 100-way softmax</td></tr></table>",
+        "bbox": [
+            266,
+            670,
+            732,
+            852
+        ],
+        "page_idx": 12
+    }
+]

parse/train/Ov_sMNau-PF/Ov_sMNau-PF.md

@@ -0,0 +1,331 @@
+# SEMANTIC RE-TUNING WITH CONTRASTIVE TENSION
+
+Fredrik Carlsson∗ Evangelia Gogoulou Erik Ylipa¨ a¨ Amaru Cuba Gyllensten Magnus Sahlgren RISE - NLU Group {firstname.lastname}@ri.se
+
+# ABSTRACT
+
+Extracting semantically useful natural language sentence representations from pre-trained deep neural networks such as Transformers remains a challenge. We first demonstrate that pre-training objectives impose a significant task bias onto the final layers of models, with a layer-wise survey of the Semantic Textual Similarity (STS) correlations for multiple common Transformer language models. We then propose a new self-supervised method called Contrastive Tension (CT) to counter such biases. CT frames the training objective as a noise-contrastive task between the final layer representations of two independent models, in turn making the final layer representations suitable for feature extraction. Results from multiple common unsupervised and supervised STS tasks indicate that CT outperforms previous State Of The Art (SOTA), and when combining CT with supervised data we improve upon previous SOTA results with large margins.
+
+# 1 INTRODUCTION
+
+Representation learning concerns the pursuit of automatically learning representations of data that are useful for future extraction of information (Bengio et al., 2013). Recent work has predominantly been focused on training and extracting such representations from various deep neural architectures. However, as these deep models are mostly trained via error minimization of an objective function applied to the final layers (Rumelhart et al., 1988), features residing in layers close to the objective function will be task-specific Yosinski et al. (2014). Therefore, to reduce the representation’s bias towards the objective function it is common to discard one or several of the final layers, or alternatively consider features of other intermediate layers, as with AutoEncoders (Rumelhart et al., 1986).
+
+One domain where this issue is particularly striking is learning semantic sentence embeddings with deep Transformer networks (Vaswani et al., 2017) pre-trained towards some language modeling task. Although utilizing pre-trained Transformer models such as BERT, XLnet, ELECTRA and GPT-2(Devlin et al., 2019; Yang et al., 2019; Clark et al., 2020; Brown et al., 2020) has become the dominant approach within the field of Natural Language Processing (NLP), with current State Of The Art (SOTA) results in basically all NLP tasks belonging to fine-tuned versions of such models, it has been shown that simply extracting features from the layers of such models does not produce competitive sentence embeddings (Reimers & Gurevych, 2019; Liu et al., 2019a). Our interpretation of this phenomenon, which we will demonstrate in this paper, is that the currently used language modeling objectives enforce a task-bias at the final layers of the Transformer, and that this bias is not beneficial for the learning of semantic sentence representations.
+
+Reimers & Gurevych (2019) propose to solve this by pooling a fixed size sentence embedding from the final Transformer layer and fine-tune towards a Natural Language Inference (NLI) task, an approach that when applied to Transformers is known as Sentence-BERT (or S-BERT in short). While Hill et al. (2016a) empirically show that fine-tuning language models towards NLI data yields good results on Semantic Textual Similarity (STS), there exists no convincing argument for why NLI is preferred over other tasks. Hence, it is unclear whether the impressive improvements of S-BERT are to be mainly attributed to the NLI task itself, or if this merely trains the model to output sentence embeddings, in turn exposing the semantics learned during pre-training. Since NLI requires labeled data, it would be highly valuable if an alternative method that requires no such labels was possible.
+
+We therefore propose a fully self-supervised training objective that aims to remove the bias posed by the pre-training objective and to encourage the model to output semantically useful sentence representations. Our method trains two separate language models on the task of maximizing the dot product between the two models’ representations for identical sentences, and minimizing the dot product between the models’ representations for different sentences. When applied to pre-trained BERT models, our method achieves SOTA results for multiple unsupervised STS tasks, and when applied to the S-BERT model it outperforms previous SOTA by a clear margin. To further bolster the robustness of our method, we demonstrate that CT drastically improves STS scores for various models, across multiple languages.
+
+Additionally, we contribute with a layer-wise STS survey for the most common Transformer-based language models, in which we find great variability in performance between different architectures and pre-training objectives. Finally, by introducing an alteration to the supervised regression task of S-BERT, we are able to improve upon the supervised STS embedding results for all tested models. In summary, the main contributions of our paper are as follows:
+
+1. A novel self-supervised approach for learning sentence embeddings from pre-trained language models.   
+2. Analytical results of the layer-wise STS performance for commonly used language models.   
+3. An improvement to the supervised regression task of S-BERT that yields a higher performance for all tested models.
+
+Code and models is available at Github.com/FreddeFrallan/Contrastive-Tension
+
+# 2 RELATED WORK
+
+Where earlier work for learning sentence embeddings focused on the composition of pre-trained word embeddings (Le & Mikolov (2014); Wieting et al. (2015); Arora et al. (2016)), recent work has instead favored extracting features from deep neural networks. The training methods of such networks can be divided into supervised and self-supervised. A systematic comparison of preTransformer sentence embedding methods is available in the works of Hill et al. (2016b).
+
+Self-supervised methods typically rely on the assumption that sentences sharing similar adjacent sentences, have similar meaning. Utilizing this assumption, Kiros et al. (2015) introduced SkipThoughts that trains an encoder-decoder to reconstruct surrounding sentences from an encoded passage. Logeswaran & Lee (2018) proposed QuickThoughts that instead frames the training objective as a sentence context classification task. Recently, and still under peer-review, Giorgi et al. (2020) proposed DeCLUTR that uses a setup similar to QuickThoughts, but allow positive sentences to be overlapping or subsuming (one being a subsequence of the other), which further improves results.
+
+Supervised methods utilize labeled datasets to introduce a semantic learning signal. As the amount of explicitly labeled STS data is very limited, supervised methods often rely on various proxy tasks where more labeled data is available. Conneau et al. (2017) introduced InferSent that learns sentence embeddings via a siamese BiLSTM trained on NLI data. The Universal Sentence Encoder (USE) of Cer et al. (2018) is a Transformer encoder trained with both unlabeled data and labeled NLI data. S-BERT by Reimers & Gurevych (2019) adopts the training objective of InferSent but instead applies pre-trained BERT models. Finally, Wang & Kuo (2020) recently proposed S-BERT-WK, an extension to S-BERT that further increases the performance by subspace analysis of the model’s layer-wise word features.
+
+Recently, Grill et al. (2020) introduced the self-supervised BYOL framework that attain useful image representations, comparable with previous supervised methods. Although their method also utilizes two untied dual networks, the main training objective and the underlying motivation for this differ greatly. Where BYOL train using solely positive samples generated via data augmentation, our method mainly aims to dissipate negative examples and relies on two networks in order to stabilize the training process. To the best of our knowledge, our work is the first that suggests learning sentence representations by removing the bias imposed from the pre-training objective.
+
+# 3 LAYER-WISE STUDY OF TRANSFORMER MODELS
+
+Previous work analyzing the downstream applicability of layer-wise features in Transformer model reports similar trends of performance increasing until the middle layers before decreasing towards the final layers. Merchant et al. (2020) found the best suited features for linguistic tasks such as entity typing and relation classification reside in the intermediate layers of BERT, and Chen et al. (2020) found the most useful representations for image classification in the intermediate layers of Image-GPT.
+
+We contribute with a layer-wise study of the semantic quality of the sentence representations found in a selected number of common Transformer architectures. Following the approach of S-BERT, we generate sentence embeddings by mean pooling over the word-piece features of a given layer. These sentence embeddings are directly evaluated towards the STS-b test (Cer et al., 2017), without any additional training, from which we report the Spearman correlation between the cosine similarity of the embeddings and the manually collected similarity scores. The test partition of the dataset contains 1,379 sentence pairs, with decimal human similarity scores ranging from 0.0 (two sentences having completely different meanings) to 5.0 (two sentences have identical meaning).
+
+Figure 1 shows the results for BERT, Electra, XLNet and GPT-2, with results for additional models in appendix B.4. Although the different models display different layer-wise patterns, a common theme is that it is not obvious where to extract features for semantic sentence embeddings; the worst-performing representations are often found in the layers close to the objective function, with the exception of RoBerta base (Liu et al., 2019b). Considering the discrepancy between BERT and Electra which share an almost identical architecture but differ drastically in their pre-training objectives, it is clear that the semantic quality of a model’s sentence representations is heavily impacted by the choice of pre-training objective.
+
+![](images/fdd9abdb25e7034558395050763203194d2dd56b8884cc7180402885453dbcbd.jpg)  
+Figure 1: Layer-wise unsupervised STS performance on the STS-b test set. $\mathrm { X }$ -axis denotes the layers of the depicted model and the Y-axis denotes the Spearman correlation $( \mathrm { x } 1 0 0 )$ . Color is a redundant indicator of the Spearman correlation and the value 50 is included for visual comparison.
+
+# 4 METHOD
+
+To counter the negative trend found in Section 3, where the lacking STS performance of the sentence representations in the final layers became apparent, we define a training objective meant to encourage the model to retain a semantically distinguishable sentence representation until the final layer. We name this method Contrastive Tension (CT), where two independent models, with identically initialized weights, are set to maximise the dot product between their sentence representations for identical sentences, and minimize the dot product for their sentence representations of differing sentences. Hence, the CT objective is defined as:
+
+$$
+\begin{array} { r } { z = f _ { 1 } ( s _ { 1 } ) ^ { T } \cdot f _ { 2 } ( s _ { 2 } ) } \\ { \mathscr { L } ( z , s _ { 1 } , s _ { 2 } ) = \left\{ \begin{array} { l l } { - l o g \sigma ( z ) } & { \mathrm { i f } s _ { 1 } = s _ { 2 } } \\ { - l o g \sigma ( 1 - z ) } & { \mathrm { i f } s _ { 1 } \neq s _ { 2 } } \end{array} \right. } \end{array}
+$$
+
+Where $f _ { 1 }$ and $f _ { 2 }$ are two independently parameterized models that given a sentence $s$ produces a fixed size vector representation and where $\sigma$ refers to the Logistic function.
+
+Following the works of Reimers & Gurevych (2019), we generate fixed size sentence representations by mean pooling over the features in the final layer of pre-trained transformer models. Training data is randomly generated from a given corpus, where for each randomly selected sentence $s$ , $K$ negative sentences are sampled to generate $K + 1$ training samples by pairing $s$ with the negative sentences and copying $s$ into an identical sentence pair. This yields one positive training sample and $K$ negative training samples. We include the $K + 1$ training samples in the same batch and always use $f _ { 2 }$ to embed the $K$ negative sentences (See Appendix A.1 for a visual example). Our approach for generating negative samples is based on the assumption that two randomly selected sentences are very likely to be semantically dissimilar.
+
+As the models are initialized with identical weights, the CT objective creates a tension between having the two models retain similar representations for identical sentences, at the same time as the two models are encouraged to distinguish their representations for differing sentences. Our intuition is that this creates a training dynamic where the two models acts as smooth anchors to each other, where the tension to remain synchronized mitigates the downsides of simply distancing the embeddings of differing sentences. This makes CT a nondestructive method for distinguishing the sentence embeddings of non semantically similar sentences.
+
+# 5 EXPERIMENTS
+
+Unless stated otherwise, the following set of hyperparameters is applied when using CT throughout all experiments: Training data is randomly sampled from English Wikipedia (See Appendix C.2), where we collect $K = 7$ negative sentence pairs for each positive sentence pair. The batch size is set to 16, which results in every batch having 2 positive sentence pairs and 14 negative sentence pairs. We apply an RMSProp optimizer (Hinton, 2012) with a fixed learning rate schedule that decreases from $\bar { 1 { e } } ^ { \bar { - } 5 }$ to $2 e ^ { - 6 }$ (Appendix A.3). To showcase the robustness and unsupervised applicability of CT, we strictly perform 50,000 update steps before evaluating, and for all unsupervised tasks we report results for the worst-performing of the two models used in the CT setup. The experiment section follows the model naming convention elaborated upon in A.2, which describes the order and what training objectives that has been applied to a model.
+
+There exists a clear discrepancy between previously reported STS scores for various methods and models. To improve upon this state of confusion we perform all evaluation with the SentEval package (Conneau & Kiela, 2018), to which we provide code and models for full reproducability of all tested methods. A Discussion regarding our experience with trying to reproduce previous work is available in Appendix A.4. A comprehensive list of all used model checkpoints is available in Appendix C.1
+
+Table 1: Pearson and Spearman correlation (x100) on various unsupervised semantic textual similarity tasks.   
+
+<table><tr><td></td><td>STS12</td><td>STS13</td><td>STS14</td><td>STS15</td><td>STS16</td><td>Avg.</td></tr><tr><td>InferSent-GloVe</td><td>56.39/57.27</td><td>56.02/55.22</td><td>65.53/63.41</td><td>67.79/69.02</td><td>64.10/65.09</td><td>62.00/62.00</td></tr><tr><td>USE v4</td><td>67.37 / 65,56</td><td>67.11/67.95 58.24/59.83</td><td>74.32 /71.48 63.00/60.42</td><td>80.03/80.82 67.33/67.81</td><td>77.79/78.74 67.22/69.01</td><td>73.32/72.91 61.96/62.64</td></tr><tr><td>BERT-Distil BERT-Base</td><td>54.03/56.15 46.88 / 50.07</td><td>52.77 /52.91</td><td>57.15 / 54.91</td><td>63.47 / 63.37</td><td>64.51 / 64.96</td><td>56.96 /57.24</td></tr><tr><td>BERT-Large</td><td>42.59 /49.01</td><td>47.35/50.88</td><td>49.31/49.69</td><td>55.56/56.79</td><td>60.43 /61.41</td><td>51.05 / 53.56</td></tr><tr><td>S-BERT-Distil</td><td>64.07/63.06</td><td>66.42/68.31</td><td>72.29/72.23</td><td></td><td></td><td></td></tr><tr><td>S-BERT-Base</td><td>66.61/63.80</td><td>67.54 / 69.34</td><td>73.22/72.94</td><td>74.44/75.09</td><td>71.17/73.86 70.16/73.27</td><td>69.68/70.51</td></tr><tr><td>S-BERT-Large</td><td>66.90 /66.85</td><td>69.42 /71.46</td><td>74.20 /74.31</td><td>74.34 /75.16</td><td></td><td>70.37 / 70.90</td></tr><tr><td>S-BERT-Base-WK</td><td></td><td></td><td></td><td>77.26/78.26</td><td>72.82 /75.12</td><td>72.12 / 73.20</td></tr><tr><td>S-BERT-Large-WK</td><td>70.23/68.26</td><td>68.13/68.82 47.95 /78.94</td><td>75.46/74.26</td><td>76.94 /77.54</td><td>74.51/76.97</td><td>73.05/73.17</td></tr><tr><td>OurContributions</td><td>56.51 / 55.82</td><td></td><td>56.46 / 55.61</td><td>63.41/ 64.14</td><td>57.84/59.42</td><td>56.43 / 56.79</td></tr><tr><td>BERT-Distil-CT</td><td>67.27/66.92</td><td>71.31/72.41</td><td></td><td></td><td></td><td></td></tr><tr><td>BERT-Base-CT</td><td></td><td></td><td>75.68/72.72</td><td>77.73/78.26</td><td>77.17/78.60</td><td>73.83/73.78</td></tr><tr><td>BERT-Large-CT</td><td>67.19 /66.86 69.63 / 69.50</td><td>70.77 /70.91 75.79 /75.97</td><td>75.64 /72.37</td><td>77.86 /78.55</td><td>76.65 /77.78</td><td>73.62 /73.29</td></tr><tr><td>S-BERT-Distil-CT</td><td>69.39/68.38</td><td>74.83/75.15</td><td>77.15 /74.22 78.04/75.94</td><td>78.28 /78.83</td><td>77.70 / 78.92</td><td>75.71/75.49</td></tr><tr><td>S-BERT-Base-CT</td><td>68.58 /68.80</td><td>73.61/74.58</td><td>78.15 /76.62</td><td>78.98/80.06 78.60 /79.72</td><td>74.91/77.57 75.01/77.14</td><td>75.23/75.42</td></tr><tr><td>S-BERT-Large-CT</td><td>71.70 / 69.80</td><td>73.95 / 75.45</td><td>78.10 / 76.47</td><td>80.39 / 81.34</td><td>75.93 /78.11</td><td>74.79 /75.37</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td>76.01 / 76.23</td></tr></table>
+
+![](images/b82856e17d72832c640684db251743af638a89a569ab3f7e5439773ab0d94b40.jpg)  
+Figure 2: Layer-Wise STS performance on the STS-b test set throughout training with CT. $\mathrm { X }$ -axis depicts the layers of the model, Y-Axis depicts the Spearman correlation $( \mathrm { x } 1 0 0 )$ and the $\mathsf { Z }$ -Axis depicts the progression of time. Color is a redundant indicator of the Spearman correlation.
+
+# 5.1 UNSUPERVISED STS
+
+Table 1 shows the results for CT when evaluated on the unsupervised English STS tasks of Agirre et al. (2012; 2013; 2014; 2015; 2016). The non-fine-tuned BERT models perform the worst out of all considered models, with a decrease in performance as the size of the BERT models increase. CT clearly improves the results for all BERT based models and outperforms previous methods. When CT is applied to the supervised S-BERT models, it sets a new SOTA with a large margin (3.03 Spearman Points). Applying CT to BERT-Distil and S-BERT-Distil produces models that outperform S-BERT-Large while having $8 1 \%$ fewer parameters.
+
+To further investigate the training dynamic of CT, we record the layer-wise STS performance for BERT and XLNet throughout the CT training process, by unsupervised evaluation on the STS-b test set. Figure 2 depicts the observed progression trends, and although the STS performance of the models’ final layers differs greatly before fine-tuning, with XLNet showing drastically worse performance, both models clearly benefit from the CT training task. For both models, CT mainly affects the STS performance for the latter layers, as is to be expected from the low learning rate.
+
+# 5.2 SUPERVISED STS
+
+Reimers & Gurevych (2019) proposed an supervised STS regression task which directly targets the cosine similarity between sentence embeddings, creating regression labels by linearly mapping the human similarity scores to the range $[ 0 , 1 ]$ . However, as evaluation of STS related tasks uses the Pearson and Spearman correlation the range to which the cosine similarity labels are linearly mapped to is arbitrary. Hence, we propose to first investigate the spread within the models embedding space to find a model specific linear mapping of the regression labels that imposes less change to the current embedding space.
+
+We investigate the STS spread of a model’s embedding space by dividing the STS-b training data by their labels into 20 buckets, and measuring the mean cosine similarity between the sentence pairs within each respective bucket. As the STS-b data is labeled in the range [0, 5], each bucket covers a range of $5 / \bar { 2 } 0 = 0 . 2 5$ . Thus the lowest bucket contains all training samples with labels between $[ 0 , 0 . 2 5 ]$ and the next bucket covers the range (0.25, 0.5]. The STS spread results for BERT and S-BERT before and after CT is available in Figure 3. We find that BERT produces sentence embeddings with high cosine similarity for all sentence pairs. Both CT and S-BERT improve the STS performance by decreasing the mean similarity for non-similar sentence pairs, but S-BERT does this with less precision.
+
+After attaining prior knowledge about the model’s sentence embedding space, we fine-tune towards the STS-b training data using the S-BERT regression setup, but with model specific regression labels. The cosine similarity labels are linearly mapped to the range $[ M , 1 ]$ , where $M$ is the mean cosine similarity of the lowest bucket. For each model and label scheme we perform 10 training runs for 8 epochs. Table 2 shows the test results of the model that performed best on the validation set.
+
+We see a clear increase in performance for all models when utilizing the model specific regression labels. However, we find no significant increase in the supervised results when applying either CT, SBERT, or a combination of the two prior to the supervised fine-tuning. As discussed in Appendix A.4 we failed to reproduce the results of Reimers & Gurevych (2019), which reports a mean Spearman correlation of S-BERT-Base: 85.35 and S-BERT-Large: 86.10, after training for 2 epochs.
+
+Table 2: Pearson and Spearman correlation $( \mathbf { x } 1 0 0 )$ on the STS-b test set.   
+
+<table><tr><td colspan="2">Nottrained forSTS</td><td colspan="3">TrainedwithSTS-bdata</td></tr><tr><td colspan="2"></td><td>Regression Labels</td><td>[0,1]</td><td>[M, 1]</td></tr><tr><td>BERT-Base</td><td>47.91/47.29</td><td>BERT-Distil</td><td>84.07 /84.23</td><td>85.02/85.54</td></tr><tr><td>InferSent-GloVe</td><td>65.30 / 63.21</td><td>BERT-Base</td><td>85.28 /84.99</td><td>85.11 / 85.64</td></tr><tr><td>USE v4</td><td>78.73 /77.09</td><td>BERT-Large</td><td>85.54 /85.37</td><td>85.90 /86.35</td></tr><tr><td>S-BERT-Distil</td><td>73.88/76.19</td><td>S-BERT-Distil</td><td>84.22/84.26</td><td>85.40/85.64</td></tr><tr><td>S-BERT-Base</td><td>74.15 /76.98</td><td>S-BERT-Base</td><td>85.17 /84.90</td><td>85.59 / 85.81</td></tr><tr><td>S-BERT-Large</td><td>76.16 /79.19</td><td>S-BERT-Large</td><td>85.14 /85.07</td><td>85.25 /86.28</td></tr><tr><td colspan="3">Ourcontributions</td><td></td><td></td></tr><tr><td>BERT-Distil-CT</td><td>79.00/78.56</td><td>BERT-Distil-CT</td><td>84.14/ 84.19</td><td>85.32/85.82</td></tr><tr><td>BERT-Base-CT</td><td>77.87 /76.32</td><td>BERT-Base-CT</td><td>85.13 /84.92</td><td>85.76 /85.89</td></tr><tr><td>BERT-Large-CT</td><td>79.97 /78.99</td><td>BERT-Large-CT</td><td>85.20 /84.97</td><td>86.37 / 85.89</td></tr><tr><td>S-BERT-Base-CT</td><td>76.25/ 80.11</td><td>S-BERT-Distil-CT</td><td>80.09/84.27</td><td>85.61/85.80</td></tr><tr><td>S-BERT-Base-CT</td><td>78.83 /81.24</td><td>S-BERT-Base-CT</td><td>85.26/85.20</td><td>85.72 /85.95</td></tr><tr><td>S-BERT-Large-CT</td><td>80.99 /82.14</td><td>S-BERT-Large-CT</td><td>85.36 /85.16</td><td>86.09 /86.43</td></tr></table>
+
+![](images/bab96ef3f026cc306053c6873b7a3b0a0d2b1509b7c5014a6366f1f854561ee8.jpg)  
+Figure 3: Predicted similarities for sentence pairs in the STS-b training set. Sentence pairs are chunked into 20 buckets by their labels, each bucket covering a label range of 0.25. Opaque line denotes the mean and the transparent area denotes the standard deviation.
+
+# 5.3 MULTILINGUAL STS
+
+Table 3: Pearson / Spearman correlation $( \mathrm { x } 1 0 0 )$ on the STS test sets of various languages.   
+
+<table><tr><td></td><td>Arabic</td><td>English</td><td>Russian</td><td>Spanish</td><td>Swedish</td></tr><tr><td>Native BERT Multilingual BERT</td><td>37.92 /45.21 48.93 / 50.56</td><td>47.91/47.29 56.98 / 55.97</td><td>64.34/ 65.75 67.70 / 68.59</td><td>67.41/ 69.19 63.35 / 66.96</td><td>41.90/44.91 47.02 /47.49</td></tr><tr><td>XLMR Our Contributions</td><td>46.64 / 44.76</td><td>40.54 / 40.35</td><td>60.93 / 61.28</td><td>57.30 / 59.31</td><td>42.16 /42.03</td></tr><tr><td>NativeBERT-CT</td><td>67.91/ 67.57</td><td>77.87 /76.32</td><td>79.38 / 79.62</td><td>76.02/76.07</td><td>61.69 / 61.68</td></tr><tr><td>Multilingual BERT-CT</td><td>60.12 / 60.15</td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td>64.39 / 62.28</td><td>70.14 / 70.54</td><td>77.67 / 77.96</td><td>58.63 / 57.45</td></tr><tr><td>XLMR-CT</td><td>62.30 / 62.14</td><td>69.85 / 68.22</td><td>67.96 / 68.42</td><td>76.00 /77.30</td><td>59.29 / 58.19</td></tr></table>
+
+We investigate the performance of CT when applied to various languages and evaluated towards STS data for Arabic, Spanish (Cer et al., 2017), Russian1, and Swedish (Isbister & Sahlgren, 2020). All CT training is performed solely with data for the respective language towards which we evaluate it, using text from a Wikipedia dump of that language (See Appendix C.2). We perform experiments with three different types of pre-trained models, all of which have encountered the targeted evaluation language during pre-training: Native BERT models pre-trained with text data specifically for the targeted language, a multilingual BERT pre-trained for 104 languages and an XLM-R model pre-trained on 100 languages (Conneau et al., 2020)
+
+Results in table 3 show that CT clearly improves the performance of all models. Prior to training with CT, we find that the multilingual BERT performs best, with the exception of Spanish where the native BERT performs the best. XLM-R performs the worst on all languages before CT. After training with CT the native BERT models outperform both the multilingual models, again with the exception of Spanish, where a slight edge is seen for the Multilingual BERT. The big performance increase seen on all models, on all languages, without requiring any labeled data, clearly demonstrate the robustness and unsupervised applicability of CT.
+
+# 5.4 CORPUS VARIETY
+
+To investigate how CT is impacted by different types of text data we vary the corpus from which training data is sampled. The corpora we consider are as follows: a dump of all English Wikipedia pages, a large book corpus comprised of 11, 038 books (Zhu et al., 2015), resulting in text data with a different tone and style compared to the text found on Wikipedia. Finally, we generate random word sequences by first uniformly sampling a sentence length in the range [20, 75] and then filling that sequence with uniformly sampled tokens from the model’s vocabulary.
+
+For each corpus, we train 5 models with CT, and report the mean unsupervised Pearson and Spearman correlation on the STS-b test set. The results found in table 4 show that CT applied with different types corpus styles yields different STS results. All models attain their highest score with the Wikipedia data, with a noticeable performance drop with the book corpus and large performance drop using random data. Although the random corpus performs worst, it interestingly improves the performance of the smaller models while drastically worsening the performance of the large model. While the number of models used in this experiment is too small for conclusive evidence, the performance drop between corpus types seems correlated with model size.
+
+Table 4: Unsupervised Pearson / Spearman correlation $( \mathbf { x } 1 0 0 )$ on the STS-b test set when performing CT with various corpora.   
+
+<table><tr><td></td><td>Before CT Pear /Spear</td><td>Wikipedia Pear /Spear</td><td>Books Pear /Spear</td><td>Random Pear /Spear</td></tr><tr><td>Bert-Distil Bert-Base Bert-Large</td><td>57.17 / 56.77 47.91 /47.29</td><td>78.21/ 77.55 75.30 / 73.75</td><td>77.54 / 76.12 73.30 / 70.95</td><td>62.45 / 62.85 52.95 / 52.42 16.65 / 23.67</td></tr></table>
+
+# 6 DISCUSSION
+
+The quality of a sentence representation depends on the generating model’s ability to represent contextual interactions between the individual parts (in most cases, wordpieces) of the sentence. We refer to this as compositionality, for the lack of a better term. We propose that the task-bias of current Transformer language models can be seen as a form of compositionality-amnesia, where the models progressively express less compositional information throughout the layers, in favor of features specific to the pre-training objective. Sentence embedding methods attempt to correct for this bias by applying a learning criterion that enforces compositionality in the final layers.
+
+In the case of CT, the learning objective is simply to maximize the dot product for identical sentences, and minimizing it for dissimilar ones. In the case of other techniques, the learning objective takes the form of modeling adjacent sentences (Skip-thoughts, Quick-thoughts, and DeCLUTR), or classifying entailment based on two given sentences (S-BERT), both of which have semantic interpretations. We argue that the CT objective is more suitable for the purpose of enforcing compositionality, since it only targets the composition function; there is no semantics involved in distinguishing identical from dissimilar sentences (all the necessary semantics is already learned by the language modeling objective).2 The finding that CT works to some extent even with randomly generated sentences further strengthens this interpretation.
+
+It is our intuition that CT is non-constructive, or in a sense uninformative: It does not add new information to the model, but rather forces the model to realign such that the compositional representation discriminates between different sentences. Hence, we find little reason to believe that the realignment enforced by CT to be beneficial for fine-tuning tasks where ample training data is available e.g. tasks for which a pre-trained BERT model can be fine-tuned with good performance. This is in accordance with the results available in Appendix 10, where the CT models are evaluated towards multiple supervised model tasks.
+
+As can be seen in Figure 3, CT decreases the cosine-similarity for non-semantically similar sentences, while the cosine-similarity for highly semantically similar sentences mainly remain the same. We believe the reason for this desired behaviour to be that all representations are generated through a common parameterized compositionality function (the Transformer model). We thus find it unlikely that similar results could be attained by applying CT directly to individual representations so that the manipulation of individual embeddings is performed independently (as algorithms like Word2Vec does).
+
+Our work demonstrates the potential to produce high-quality semantic sentence representations given a pre-trained Transformer Language model, without requiring any labeled data. In accordance with the multilingual results in Section 3, we would hence like to emphasize that this makes CT well suited for low resource languages, as neither pre-training or fine-tuning requires labeled data. Additionally, we think that interesting future work might consider exploring the possibilities of applying CT (or similar re-tuning objectives) during the pre-training of Transformer language model, and/or applying it to different intermediate layers
+
+Finally, it is noteworthy that our results are not to be considered final, as many of the chosen hyperparameters for the CT experiments are yet to be thoroughly investigated. It is therefore possible that CT and similar methods can yield even better results, with either utilizing different language models or tuning of certain hyperparameters. Especially considering that during the unsupervised tasks, due to the emulation of having zero labeled data, we strictly performed a fixed number of iterations and assumed the worst-case scenario by reporting results for the worst performing model of the two CT models. A higher performance is therefore expected if the training is monitored with a validation set or if one were to combine the output of both CT models.
+
+# 7 CONCLUSION
+
+This paper contributed with a layer-wise survey of the unsupervised STS performance of pre-trained Transformer language models. Results from this survey indicates that the final layer of most models produce the worst performing representations. To overcome this we proposed the self-supervised method Contrastive Tension (CT) that trains the model to output semantically distinguishable sentence representations, without requiring any labeled data. In an unsupervised setting CT achieves strong STS results when applied with various models, with varying corpora and across multiple languages. Setting a new SOTA score for multiple well established unsupervised English STS tasks.
+
+Additionally, this paper introduced an alteration to the supervised STS regression task proposed by Reimers & Gurevych (2019), which improves the supervised STS scores for all tested models. Using this altered regression task, regular BERT models achieve equally good as when first finetuned towards NLI, CT or both. Suggesting that the current Transformer pre-training objectives themselves capture useful sentence level semantic knowledge.
+
+# 8 ACKNOWLEDGEMENTS
+
+This work was partially funded by Vinnova under contract 2019-02996, and the Swedish Foundation for Strategic Research (SSF) under contract RIT15-0046. Finally, the authors wish to thank Joey Ohman, Melker Mossberg and Linus Bein Fahlander, for the spicy Taco evenings which helped us ¨ through the rough times of COVID-19.
+
+# REFERENCES
+
+Eneko Agirre, Daniel Cer, Mona Diab, and Aitor Gonzalez-Agirre. SemEval-2012 task 6: A pilot on semantic textual similarity. In \*SEM 2012: The First Joint Conference on Lexical and Computational Semantics – Volume 1: Proceedings of the main conference and the shared task, and Volume 2: Proceedings of the Sixth International Workshop on Semantic Evaluation (SemEval 2012), pp. 385–393, Montreal, Canada, 7-8 June 2012. Association for Computational Linguistics. URL ´ https://www.aclweb.org/anthology/S12-1051.
+
+Eneko Agirre, Daniel Cer, Mona Diab, Aitor Gonzalez-Agirre, and Weiwei Guo. \*SEM 2013 shared task: Semantic textual similarity. In Second Joint Conference on Lexical and Computational Semantics $( { } ^ { * } S E M )$ , Volume 1: Proceedings of the Main Conference and the Shared Task: Semantic Textual Similarity, pp. 32–43, Atlanta, Georgia, USA, June 2013. Association for Computational Linguistics. URL https://www.aclweb.org/anthology/S13-1004.
+
+Eneko Agirre, Carmen Banea, Claire Cardie, Daniel Cer, Mona Diab, Aitor Gonzalez-Agirre, Weiwei Guo, Rada Mihalcea, German Rigau, and Janyce Wiebe. SemEval-2014 task 10: Multilingual semantic textual similarity. In Proceedings of the 8th International Workshop on Semantic Evaluation (SemEval 2014), pp. 81–91, Dublin, Ireland, August 2014. Association for Computational Linguistics. doi: 10.3115/v1/S14-2010. URL https://www.aclweb.org/anthology/ S14-2010.
+
+Eneko Agirre, Carmen Banea, Claire Cardie, Daniel Cer, Mona Diab, Aitor Gonzalez-Agirre, Weiwei Guo, Inigo Lopez-Gazpio, Montse Maritxalar, Rada Mihalcea, German Rigau, Larraitz Uria, ˜ and Janyce Wiebe. SemEval-2015 task 2: Semantic textual similarity, English, Spanish and pilot on interpretability. In Proceedings of the 9th International Workshop on Semantic Evaluation (SemEval 2015), pp. 252–263, Denver, Colorado, June 2015. Association for Computational Linguistics. doi: 10.18653/v1/S15-2045. URL https://www.aclweb.org/anthology/S15-2045.
+
+Eneko Agirre, Carmen Banea, Daniel Cer, Mona Diab, Aitor Gonzalez-Agirre, Rada Mihalcea, German Rigau, and Janyce Wiebe. SemEval-2016 task 1: Semantic textual similarity, monolingual and cross-lingual evaluation. In Proceedings of the 10th International Workshop on Semantic Evaluation (SemEval-2016), pp. 497–511, San Diego, California, June 2016. Association for Computational Linguistics. doi: 10.18653/v1/S16-1081. URL https://www.aclweb.org/ anthology/S16-1081.
+
+Sanjeev Arora, Yingyu Liang, and Tengyu Ma. A simple but tough-to-beat baseline for sentence embeddings. 2016.
+
+Giusepppe Attardi. Wikiextractor. https://github.com/attardi/wikiextractor, 2015.
+
+Yoshua Bengio, Aaron Courville, and Pascal Vincent. Representation learning: A review and new perspectives. IEEE Trans. Pattern Anal. Mach. Intell., 35(8):1798–1828, August 2013. ISSN 0162-8828. doi: 10.1109/TPAMI.2013.50. URL https://doi.org/10.1109/TPAMI.2013. 50.
+
+Tom B. Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, Sandhini Agarwal, Ariel Herbert-Voss, Gretchen Krueger, Tom Henighan, Rewon Child, Aditya Ramesh, Daniel M. Ziegler, Jeffrey Wu, Clemens Winter, Christopher Hesse, Mark Chen, Eric Sigler, Mateusz Litwin, Scott Gray, Benjamin Chess, Jack Clark, Christopher Berner, Sam McCandlish, Alec Radford, Ilya Sutskever, and Dario Amodei. Language models are few-shot learners, 2020.
+
+Daniel Cer, Mona Diab, Eneko Agirre, Inigo Lopez-Gazpio, and Lucia Specia. Semeval-2017 task 1: Semantic textual similarity-multilingual and cross-lingual focused evaluation. arXiv preprint arXiv:1708.00055, 2017.
+
+Daniel Cer, Yinfei Yang, Sheng-yi Kong, Nan Hua, Nicole Limtiaco, Rhomni St. John, Noah Constant, Mario Guajardo-Cespedes, Steve Yuan, Chris Tar, Brian Strope, and Ray Kurzweil. Universal sentence encoder for English. In Proceedings of the 2018 Conference on Empirical Methods in Natural Language Processing: System Demonstrations, pp. 169–174, Brussels, Belgium, November 2018. Association for Computational Linguistics. doi: 10.18653/v1/D18-2029. URL https://www.aclweb.org/anthology/D18-2029.
+
+Mark Chen, Alec Radford, Rewon Child, Jeffrey Wu, Heewoo Jun, David Luan, and Ilya Sutskever. Generative pretraining from pixels. In Proceedings of Machine Learning and Systems 2020, pp. 10466–10478. 2020.
+
+Kevin Clark, Minh-Thang Luong, Quoc V. Le, and Christopher D. Manning. ELECTRA: Pretraining text encoders as discriminators rather than generators. In ICLR, 2020. URL https: //openreview.net/pdf?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ r1xMH1BtvB.
+
+Alexis Conneau and Douwe Kiela. SentEval: An evaluation toolkit for universal sentence representations. In Proceedings of the Eleventh International Conference on Language Resources and Evaluation (LREC 2018), Miyazaki, Japan, May 2018. European Language Resources Association (ELRA). URL https://www.aclweb.org/anthology/L18-1269.
+
+Alexis Conneau, Douwe Kiela, Holger Schwenk, Lo¨ıc Barrault, and Antoine Bordes. Supervised learning of universal sentence representations from natural language inference data. In Proceedings of the 2017 Conference on Empirical Methods in Natural Language Processing, pp. 670– 680, Copenhagen, Denmark, September 2017. Association for Computational Linguistics. doi: 10.18653/v1/D17-1070. URL https://www.aclweb.org/anthology/D17-1070.
+
+Alexis Conneau, Kartikay Khandelwal, Naman Goyal, Vishrav Chaudhary, Guillaume Wenzek, Francisco Guzman, Edouard Grave, Myle Ott, Luke Zettlemoyer, and Veselin Stoyanov. Un- ´ supervised cross-lingual representation learning at scale. In Dan Jurafsky, Joyce Chai, Natalie Schluter, and Joel R. Tetreault (eds.), Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, ACL 2020, Online, July 5-10, 2020, pp. 8440–8451. Association for Computational Linguistics, 2020. URL https://www.aclweb.org/anthology/2020. acl-main.747/.
+
+Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. BERT: Pre-training of deep bidirectional transformers for language understanding. 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), pp. 4171–4186, Minneapolis, Minnesota, June 2019. Association for Computational Linguistics. doi: 10.18653/v1/N19-1423. URL https: //www.aclweb.org/anthology/N19-1423.
+
+John M Giorgi, Osvald Nitski, Gary D Bader, and Bo Wang. Declutr: Deep contrastive learning for unsupervised textual representations. arXiv preprint arXiv:2006.03659, 2020.
+
+Jean-Bastien Grill, Florian Strub, Florent Altche, Corentin Tallec, Pierre H Richemond, Elena ´ Buchatskaya, Carl Doersch, Bernardo Avila Pires, Zhaohan Daniel Guo, Mohammad Gheshlaghi Azar, et al. Bootstrap your own latent: A new approach to self-supervised learning. arXiv preprint arXiv:2006.07733, 2020.
+
+Felix Hill, Kyunghyun Cho, and Anna Korhonen. Learning distributed representations of sentences from unlabelled data. In Proceedings of the 2016 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pp. 1367–1377, San Diego, California, June 2016a. Association for Computational Linguistics. doi: 10.18653/ v1/N16-1162. URL https://www.aclweb.org/anthology/N16-1162.
+
+Felix Hill, Kyunghyun Cho, and Anna Korhonen. Learning distributed representations of sentences from unlabelled data. arXiv preprint arXiv:1602.03483, 2016b.
+
+Tieleman Hinton. Lecture 6.5 - rmsprop, coursera: Neural networks for machine learning. 2012.
+
+Tim Isbister and Magnus Sahlgren. Why not simply translate? a first swedish evaluation benchmark for semantic similarity, 2020.
+
+Ryan Kiros, Yukun Zhu, Russ R Salakhutdinov, Richard Zemel, Raquel Urtasun, Antonio Torralba, and Sanja Fidler. Skip-thought vectors. In C. Cortes, N. D. Lawrence, D. D. Lee, M. Sugiyama, and R. Garnett (eds.), Advances in Neural Information Processing Systems 28, pp. 3294–3302. Curran Associates, Inc., 2015. URL http://papers.nips.cc/paper/ 5950-skip-thought-vectors.pdf.
+
+Quoc Le and Tomas Mikolov. Distributed representations of sentences and documents. In International conference on machine learning, pp. 1188–1196, 2014.
+
+Nelson F. Liu, Matt Gardner, Yonatan Belinkov, Matthew E. Peters, and Noah A. Smith. Linguistic knowledge and transferability of contextual representations. 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), pp. 1073–1094, Minneapolis, Minnesota, June 2019a. Association for Computational Linguistics. doi: 10.18653/v1/N19-1112. URL https://www.aclweb.org/anthology/N19-1112.
+
+Y. Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, M. Lewis, Luke Zettlemoyer, and Veselin Stoyanov. Roberta: A robustly optimized bert pretraining approach. ArXiv, abs/1907.11692, 2019b.
+
+Lajanugen Logeswaran and Honglak Lee. An efficient framework for learning sentence representations. In International Conference on Learning Representations, 2018. URL https: //openreview.net/forum?id $\equiv$ rJvJXZb0W.
+
+Amil Merchant, Elahe Rahimtoroghi, Ellie Pavlick, and Ian Tenney. What happens to bert embeddings during fine-tuning?, 2020.
+
+Nils Reimers and Iryna Gurevych. Sentence-BERT: Sentence embeddings using Siamese BERTnetworks. In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing (EMNLPIJCNLP), pp. 3982–3992, Hong Kong, China, November 2019. Association for Computational Linguistics. doi: 10.18653/v1/D19-1410. URL https://www.aclweb.org/anthology/ D19-1410.
+
+D. E. Rumelhart, G. E. Hinton, and R. J. Williams. Learning Internal Representations by Error Propagation, pp. 318–362. MIT Press, Cambridge, MA, USA, 1986. ISBN 026268053X.
+
+David E. Rumelhart, Geoffrey E. Hinton, and Ronald J. Williams. Learning Representations by Back-Propagating Errors, pp. 696–699. MIT Press, Cambridge, MA, USA, 1988. ISBN 0262010976.
+
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Ł ukasz Kaiser, and Illia Polosukhin. Attention is all you need. In I. Guyon, U. V. Luxburg, S. Bengio, H. Wallach, R. Fergus, S. Vishwanathan, and R. Garnett (eds.), Advances in Neural Information Processing Systems 30, pp. 5998–6008. Curran Associates, Inc., 2017. URL http://papers.nips.cc/paper/7181-attention-is-all-you-need.pdf.
+
+Alex Wang, Amanpreet Singh, Julian Michael, Felix Hill, Omer Levy, and Samuel R. Bowman. GLUE: A multi-task benchmark and analysis platform for natural language understanding. In International Conference on Learning Representations, 2019. URL https://openreview. net/forum?id $\equiv$ rJ4km2R5t7.
+
+B. Wang and C. . J. Kuo. SBERT-WK: A sentence embedding method by dissecting BERT-based word models. IEEE/ACM Transactions on Audio, Speech, and Language Processing, 28:2146– 2157, 2020.
+
+Bin Wang and C-C Jay Kuo. Sbert-wk: A sentence embedding method by dissecting bert-based word models. arXiv preprint arXiv:2002.06652, 2020.
+
+John Wieting, Mohit Bansal, Kevin Gimpel, and Karen Livescu. Towards universal paraphrastic sentence embeddings. arXiv preprint arXiv:1511.08198, 2015.
+
+Thomas Wolf, Lysandre Debut, Victor Sanh, Julien Chaumond, Clement Delangue, Anthony Moi, Pierric Cistac, Tim Rault, R’emi Louf, Morgan Funtowicz, and Jamie Brew. Huggingface’s transformers: State-of-the-art natural language processing. ArXiv, abs/1910.03771, 2019.
+
+Zhilin Yang, Zihang Dai, Yiming Yang, Jaime Carbonell, Russ R Salakhutdinov, and Quoc V Le. Xlnet: Generalized autoregressive pretraining for language understanding. In H. Wallach, H. Larochelle, A. Beygelzimer, F. d'Alche-Buc, E. Fox, and ´ R. Garnett (eds.), Advances in Neural Information Processing Systems 32, pp. 5753– 5763. Curran Associates, Inc., 2019. URL http://papers.nips.cc/paper/ 8812-xlnet-generalized-autoregressive-pretraining-for-language-understanding. pdf.
+
+Jason Yosinski, Jeff Clune, Yoshua Bengio, and Hod Lipson. How transferable are features in deep neural networks? In Z. Ghahramani, M. Welling, C. Cortes, N. Lawrence, and K. Q. Weinberger (eds.), Advances in Neural Information Processing Systems, volume 27, pp. 3320–3328. Curran Associates, Inc., 2014. URL https://proceedings.neurips.cc/paper/2014/file/ 375c71349b295fbe2dcdca9206f20a06-Paper.pdf.
+
+Yukun Zhu, Ryan Kiros, Rich Zemel, Ruslan Salakhutdinov, Raquel Urtasun, Antonio Torralba, and Sanja Fidler. Aligning books and movies: Towards story-like visual explanations by watching movies and reading books. In The IEEE International Conference on Computer Vision (ICCV), December 2015.
+
+A APPENDIX
+
+A.1 VISUAL EXAMPLE OF CONTRASTIVE TENSION
+
+![](images/0b670557da5f1f2e9749718778a20bb5a0fa2216c68e6711c8662284a7ef41f6.jpg)  
+Figure 4: CT follows an architecture similar to a siamese network, but with independent models. Both models are updated based on a contrastive loss on the unnormalized dot product
+
+Figure 4 demonstrates how CT is applied when $K \ = \ 7$ which yields 1 positive sentence pair $( S _ { A } , S _ { A } )$ where the models are trained to maximize the dot product, and 7 negative sentence pairs $( S _ { A } , S _ { B } ) , ( S _ { A } , S _ { C } ) \dots ( S _ { A } , S _ { H } )$ where the models are trained to minimize the dot product. As all sentence pairs are included into the same batch, the loss for all $K + 1$ sentence pairs are calculated before updating the models parameters.
+
+# A.2 MODEL NAMING CONVENTION
+
+Throughout the paper we sequentially apply different fine-tuning objectives on pre-trained transformer models, i.e no pre-training is performed during fine-tuning and no two fine-tuning tasks are applied in parallel. The terms ”Distil”, ”Base” and ”Large” are used as descriptors of the pretrained model’s size and in the case of ”Distil” also its pre-training objective.
+
+The two main fine-tuning tasks we consider is CT and the Siamese NLI task of InferSent and SBERT. When a model has been tuned towards the Siamese NLI task an additional $^ { \prime \prime } S _ { ^ { \prime } } { } ^ { , , }$ is added as a prefix to the model base. When a model has been trained with the CT training objective ”-CT” is added as suffix to the model name. It is strictly the case that when both these tasks are applied to a model, the NLI task is applied before to the CT objective.
+
+For example the model ”S-BERT-Distil-CT”, is a distilled BERT model that has been fine-tuned towards the S-BERT NLI task, before finally tuned with the CT training objective.
+
+# A.3 LEARNING RATE SCHEDULE
+
+Hyperparameter search concluded that $2 e ^ { - } 6$ was a stable learning rate for applying CT to pre-trained BERT models. However, we found it possible to speedup learning during the early training stages by using a higher learning rate, leading us to the step-wise learning rate schedule seen in table 5. We found no significant difference in the end result when applying the learning rate schedule and when training for a longer period with a smaller learning rate.
+
+Table 5: Step-wise learning schedule applied for all training with Contrastive Tension.   
+
+<table><tr><td rowspan=1 colspan=1>N #Updates</td><td rowspan=1 colspan=1>Learning Rate</td></tr><tr><td rowspan=1 colspan=1>N&lt;500</td><td rowspan=1 colspan=1>1e-5</td></tr><tr><td rowspan=1 colspan=1>N&lt;1000</td><td rowspan=1 colspan=1>8e-6</td></tr><tr><td rowspan=1 colspan=1>N&lt;1500</td><td rowspan=1 colspan=1>6e-6</td></tr><tr><td rowspan=1 colspan=1>N&lt;2000</td><td rowspan=1 colspan=1>4e-6</td></tr><tr><td rowspan=1 colspan=1>2000≤N</td><td rowspan=1 colspan=1>2e-6</td></tr></table>
+
+# A.4 REPRODUCIBILITY OF PREVIOUS WORK
+
+There exists a discrepancy regarding the reported STS scores between various previous works (Reimers & Gurevych, 2019; Wang & Kuo, 2020). As mentioned, we perform all our STS evaluation with the SentEval framework of Conneau & Kiela (2018), the following are our observations and experiences as we compare with reported results of Reimers & Gurevych (2019), and the follow up work of Wang & Kuo (2020).
+
+For the English Unsupervised STS tasks of SemEval 2012-2016 we found that:
+
+1. Our results for BERT, S-BERT and S-BERT-WK are consistent with the work of Wang & Kuo (2020). (Although they do not report results for S-BERT-Large-WK). 2. Reimers & Gurevych (2019) report the highest STS score for the S-BERT models but the lowest for BERT. Which when compared gives an average Spearman difference of 3.9 for S-BERT-Base, 3.4 for S-BERT-Large and $- 1 . 4 5$ for BERT.
+
+3. No one agrees upon the scores of either InferSent or USE.
+
+When evaluating towards the Supervised STS tasks of STS-b test set we found that:
+
+1. Our Spearman results for S-BERT-Base and S-BERT-Large, prior to fine-tuning, are consistent with the work of Reimers & Gurevych (2019). Differing with less than 0.05 points. 2. Using the official S-BERT code to fine-tune the released S-BERT-Large model, with the described hyperparameters, yields worse results than reported by Reimers & Gurevych (2019), both when evaluating with SentEval or the included evaluation script.
+
+Finally, we note that the official S-BERT implementation continuously evaluates towards the STSb validation set throughout the NLI training, saving the copy that performs best. This makes all models trained with this setup invalid for the unsupervised STS tasks, as the STS-b validation set is a collection of samples from these tests. This is not to say that this is the setup that was used for the results reported by Reimers & Gurevych (2019), but something that future researchers should be aware of.
+
+# B
+
+Additional Experiments and Results
+
+# B.1 ADDITIONAL UNSUPERVISED STS
+
+In order to give further insights on the performance of CT we report unsupervised STS results from $1 0 \ \mathrm { C T }$ training runs per considered pre-trained model. Since CT trains two models in parallel this results in $1 0 ~ \mathrm { C T }$ model pairs i.e. 20 models per considered pre-trained model. Table 6 show the worst/best performing model and the average performance of all 20 models, completely disregarding which models were paired during training. Table 7 showcases how two paired CT models tend to differ in regards to the mean unsupervised STS score, showing the min, max and average difference over the 10 training runs.
+
+It is apparent that out of the models whom have not been tuned towards the NLI task, BERT-Distil$C T$ showcases the most stable performance, with very little variation between the worst and best performing model compared to both BERT-Base-CT and BERT-Large-CT who show a lower worst possible score. If this discrepancy in performance stability is due to model size or that BERT-Distil is trained via distillation is left for future work. Applying CT to a model who has been tuned towards an NLI task seemingly produces both more stable and better results.
+
+Table 6: Pearson and Spearman correlation (x100) on various unsupervised semantic textual similarity tasks.   
+
+<table><tr><td></td><td>STS12</td><td>STS13</td><td>STS14</td><td>STS15</td><td>STS16</td><td>Avg.</td></tr><tr><td>WorstPerformingModel</td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>BERT-Distil-CT</td><td>66.69/66.23</td><td>72.44/73.72</td><td>76.04/73.09</td><td>77.61/78.20</td><td>77.51/78.08</td><td>73.86/73.86</td></tr><tr><td>BERT-Base-CT</td><td>62.04 /62.65</td><td>65.23 / 65.50</td><td>71.62 /68.85</td><td>75.48/75.90</td><td>74.69 /75.66</td><td>69.81/ 69.71</td></tr><tr><td>BERT-Large-CT</td><td>63.82/65.12</td><td>72.14 / 72.21</td><td>72.20 /69.40</td><td>72.58 /73.02</td><td>73.25 /74.33</td><td>70.80 / 70.82</td></tr><tr><td>S-BERT-Distil-CT</td><td>68.96/67.51</td><td>72.02/72.74</td><td>77.30/75.44</td><td>78.31/79.73</td><td>74.80/77.54</td><td>74.28/74.59</td></tr><tr><td>S-BERT-Base-CT</td><td>68.09 /67.69</td><td>72.54 / 73.35</td><td>77.25 /75.80</td><td>77.93 / 78.99</td><td>74.59 /76.61</td><td>74.08 / 74.49</td></tr><tr><td>S-BERT-Large-CT</td><td>70.37 /68.94</td><td>74.70 / 74.90</td><td>78.36/76.36</td><td>79.22 /80.29</td><td>74.66 /77.23</td><td>75.46 / 75.54</td></tr><tr><td>BestPerformingModel</td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>BERT-Distil-CT</td><td>68.14/67.22</td><td>73.48/74.04</td><td>77.03/73.45</td><td>77.88/78.56</td><td>76.54/78.15</td><td>74.61/74.28</td></tr><tr><td>BERT-Base-CT</td><td>68.20 /68.56</td><td>74.33 /74.50</td><td>76.76 /73.33</td><td>78.71 /79.29</td><td>78.10 /79.15</td><td>75.22 /74.97</td></tr><tr><td>BERT-Large-CT</td><td>69.26 /69.03</td><td>76.90 / 77.19</td><td>77.71/ 74.50</td><td>79.08 / 79.58</td><td>79.16 /80.07</td><td>76.42/76.07</td></tr><tr><td>S-BERT-Distil-CT</td><td>70.04/68.25</td><td>76.78/76.98</td><td>79.69/66.68</td><td>79.66/80.37</td><td>77.54/79.63</td><td>76.74/76.58</td></tr><tr><td>S-BERT-Base-CT</td><td>69.59 / 68.20</td><td>74.38 /75.18</td><td>78.30 / 76.56</td><td>79.71/ 80.54</td><td>75.71 / 77.58</td><td>75.54 / 75.64</td></tr><tr><td>S-BERT-Large-CT</td><td>71.72 / 69.96</td><td>77.09 / 77.17</td><td>78.61 / 76.73</td><td>80.50 / 81.45</td><td>76.38 / 78.43</td><td>76.86 /76.75</td></tr><tr><td>MeanPerformance</td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>BERT-Distil-CT</td><td>67.69/67.10</td><td>72.84/73.95</td><td>76.54/73.29</td><td>77.66/78.27</td><td>76.53/78.15</td><td>74.25/74.15</td></tr><tr><td>BERT-Base-CT</td><td>64.46 /64.74</td><td>68.11/68.34</td><td>73.14 / 70.24</td><td>76.66 /77.09</td><td>75.85 /76.84</td><td>71.64 / 71.46</td></tr><tr><td>BERT-Large-CT</td><td>67.25 /67.80</td><td>74.57 /74.70</td><td>75.84 / 72.73</td><td>77.41 /77.89</td><td>77.22 /78.21</td><td>74.46 /74.27</td></tr><tr><td>S-BERT-Distil-CT</td><td>69.75/68.14</td><td>74.58/75.05</td><td>77.98/76.19</td><td>78.63/79.77</td><td>75.82/78.23</td><td>75.35/75.48</td></tr><tr><td>S-BERT-Base-CT</td><td>69.10 / 68.38</td><td>73.61/74.36</td><td>77.90 / 76.27</td><td>78.88/79.88</td><td>75.06 /77.11</td><td>74.91/75.20</td></tr><tr><td>S-BERT-Large-CT</td><td>71.37 /69.70</td><td>75.56 /75.80</td><td>78.60 /77.02</td><td>79.99 / 80.98</td><td>75.96 /78.06</td><td>76.30 / 76.31</td></tr></table>
+
+Table 7: Min, max and mean difference between CT paired models in Pearson and Spearman correlation $( \mathrm { x } 1 0 0 )$ in regards to the mean score of the unsupervised semantic textual similarity tasks.   
+
+<table><tr><td></td><td>MINDifference</td><td>MAXDifference</td><td>MEANDifference</td></tr><tr><td>BERT-Distil-CT BERT-Base-CT</td><td>0.06/0.04</td><td>0.55/0.29</td><td>0.31/0.17</td></tr><tr><td>BERT-Large-CT</td><td>0.05 /0.00</td><td>1.71 / 1.36</td><td>0.75 /0.51</td></tr><tr><td>S-BERT-Distil-CT</td><td>0.03 /0.02</td><td>4.49 / 3.43</td><td>1.26 /1.13</td></tr><tr><td>S-BERT-Base-CT</td><td>0.31/0.11</td><td>1.52 / 1.25</td><td>0.88/0.76</td></tr><tr><td></td><td>0.23/0.09</td><td>1.03 / 0.90</td><td>0.58 /0.33</td></tr><tr><td>S-BERT-Large-CT</td><td>0.00 /0.04</td><td>0.81 / 0.92</td><td>0.38 / 0.33</td></tr></table>
+
+# B.2 DOWNSTREAM & PROBING TASKS
+
+To comply with previous work, we evaluate CT on the various set of downstream tasks supplied by the SentEval package (Conneau & Kiela, 2018). As results in table 8 show, we find only minor improvements when using the representations from the fine-tuned models compared to BERT. SBERT produces a minor improvement for most non semantic related downstream tasks and CT performs slightly better on the semantic related tasks SICK-R and STS-b. Interestingly, the results from table 2 show that BERT-CT, S-BERT and S-BERT-CT all perform better on the STS-b test set when not training an extra linear classifier.
+
+Additionally we evaluate towards the fine grained analysis tasks supplied by SentEval. The results in table 9 clearly show that S-BERT’s NLI fine-tuning objective decreases the score in all tests compared to BERT. CT also clearly decreases the performance on all tests except the Bigram Shift task, where this is done to a smaller degree.
+
+Table 8: Results on the downstream tasks supplied with the SentEval package. For the semantic related tasks SICK-R and STS-b, the Pearson correlation (x100) is reported.   
+
+<table><tr><td></td><td>CR</td><td>MR</td><td>MPQA</td><td>SUBJ</td><td>SST2</td><td>SST5</td><td>TREC</td><td>MRPC</td><td>SICK-E</td><td>SICK-R</td><td>STS-b</td><td>AVG</td></tr><tr><td>BERT-Distil</td><td>85.96</td><td>79.98</td><td>88.42</td><td>95.14</td><td>85.39</td><td>45.93</td><td>90.60</td><td>74.14</td><td>81.69</td><td>83.74</td><td>69.53</td><td>80.05</td></tr><tr><td>BERT-Base</td><td>86.96</td><td>81.33</td><td>88.07</td><td>95.03</td><td>85.94</td><td>46.74</td><td>90.60</td><td>73.74</td><td>79.50</td><td>80.47</td><td>65.40</td><td>79.44</td></tr><tr><td>BERT-Large</td><td>88.74</td><td>84.33</td><td>86.64</td><td>95.27</td><td>79.29</td><td>50.32</td><td>91.40</td><td>71.65</td><td>75.28</td><td>77.09</td><td>66.22</td><td>78.75</td></tr><tr><td>BERT-Distil-NLI</td><td>88.37</td><td>80.83</td><td>95.50</td><td>82.54</td><td>86.99</td><td>47.47</td><td>85.60</td><td>76.12</td><td>83.15</td><td>84.72</td><td>75.90</td><td>80.11</td></tr><tr><td>BERT-Base-NLI</td><td>89.24</td><td>82.65</td><td>89.61</td><td>93.84</td><td>88.36</td><td>47.38</td><td>85.20</td><td>75.07</td><td>82.04</td><td>84.24</td><td>73.05</td><td>80.97</td></tr><tr><td>BERT-Large-NLI</td><td>90.52</td><td>84.36</td><td>90.30</td><td>94.32</td><td>90.72</td><td>50.05</td><td>86.80</td><td>76.52</td><td>83.05</td><td>84.94</td><td>75.02</td><td>82.42</td></tr><tr><td>OurContributions</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>BERT-Distil-CT</td><td>84.00</td><td>78.51</td><td>88.62</td><td>93.83</td><td>83.47</td><td>45.34</td><td>87.60</td><td>74.61</td><td>81.96</td><td>85.06</td><td>74.45</td><td>79.77</td></tr><tr><td>BERT-Base-CT</td><td>84.00</td><td>79.84</td><td>88.06</td><td>94.10</td><td>82.43</td><td>45.25</td><td>89.20</td><td>73.80</td><td>80.80</td><td>84.30</td><td>73.69</td><td>79.59</td></tr><tr><td>BERT-Large-CT</td><td>86.81</td><td>82.38</td><td>88.31</td><td>94.34</td><td>87.75</td><td>46.56</td><td>88.00</td><td>73.10</td><td>81.49</td><td>84.93</td><td>76.50</td><td>80.92</td></tr><tr><td>BERT-Distil-NLI-CT</td><td>87.68</td><td>80.74</td><td>89.33</td><td>92.59</td><td>86.27</td><td>46.97</td><td>85.80</td><td>75.59</td><td>82.81</td><td>84.91</td><td>77.68</td><td>80.94</td></tr><tr><td>BERT-Base-NLI-CT</td><td>88.66</td><td>81.83</td><td>89.79</td><td>93.72</td><td>87.91</td><td>47.83</td><td>83.00</td><td>74.43</td><td>82.42</td><td>85.32</td><td>77.42</td><td>81.12</td></tr><tr><td>BERT-Large-NLI-CT</td><td>89.56</td><td>82.56</td><td>90.20</td><td>83.08</td><td>88.85</td><td>48.60</td><td>87.20</td><td>74.43</td><td>82.77</td><td>84.88</td><td>77.49</td><td>80.87</td></tr></table>
+
+Table 9: Results on the fine grained analysis tasks tasks supplied with the SentEval package.   
+
+<table><tr><td></td><td>Length</td><td>WC</td><td>Depth</td><td>TopConst</td><td>BShift</td><td>Tense</td><td>SubjNum</td><td>ObjNum</td><td>OddManOut</td><td>CoordInv</td><td>AVG</td></tr><tr><td>BERT-Distil</td><td>88.29</td><td>67.39</td><td>39.68</td><td>76.03</td><td>86.81</td><td>88.89</td><td>86.06</td><td>83.15</td><td>63.19</td><td>65.09</td><td>74.46</td></tr><tr><td>BERT-Base</td><td>81.99</td><td>61.20</td><td>36.19</td><td>77.63</td><td>88.76</td><td>88.23</td><td>84.98</td><td>82.11</td><td>66.69</td><td>69.94</td><td>73.77</td></tr><tr><td>BERT-Large</td><td>70.82</td><td>55.26</td><td>33.35</td><td>68.86</td><td>90.29</td><td>88.31</td><td>81.67</td><td>80.37</td><td>69.29</td><td>71.23</td><td>70.95</td></tr><tr><td>BERT-Distil-NLI</td><td>71.23</td><td>61.76</td><td>31.83</td><td>58.75</td><td>70.41</td><td>85.11</td><td>79.02</td><td>77.71</td><td>57.93</td><td>59.10</td><td>65.29</td></tr><tr><td>BERT-Base-NLI</td><td>72.12</td><td>58.65</td><td>31.14</td><td>60.50</td><td>76.02</td><td>86.81</td><td>78.38</td><td>77.08</td><td>62.97</td><td>63.78</td><td>66.29</td></tr><tr><td>BERT-Large-NLI</td><td>59.79</td><td>54.47</td><td>29.63</td><td>57.98</td><td>76.28</td><td>84.36</td><td>76.34</td><td>73.65</td><td>64.28</td><td>65.71</td><td>64.25</td></tr><tr><td>OurContributions</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>BERT-Distil-CT</td><td>81.86</td><td>74.49</td><td>37.78</td><td>69.76</td><td>80.38</td><td>88.54</td><td>83.76</td><td>80.86</td><td>60.91</td><td>59.94</td><td>71.83</td></tr><tr><td>BERT-Base-CT</td><td>77.68</td><td>80.69</td><td>34.21</td><td>68.32</td><td>85.70</td><td>88.03</td><td>83.70</td><td>80.35</td><td>64.93</td><td>64.97</td><td>72.86</td></tr><tr><td>BERT-Large-CT</td><td>64.85</td><td>65.93</td><td>30.97</td><td>64.75</td><td>86.59</td><td>87.9</td><td>81.17</td><td>80.85</td><td>68.04</td><td>67.37</td><td>69.84</td></tr><tr><td>BERT-Distil-NLI-CT</td><td>72.55</td><td>67.84</td><td>33.29</td><td>62.61</td><td>72.49</td><td>86.20</td><td>82.01</td><td>78.84</td><td>58.40</td><td>59.61</td><td>67.38</td></tr><tr><td>BERT-Base-NLI-CT</td><td>71.44</td><td>66.42</td><td>32.19</td><td>61.45</td><td>77.61</td><td>87.87</td><td>80.10</td><td>78.45</td><td>63.21</td><td>63.83</td><td>68.26</td></tr><tr><td>BERT-Large-NLI-CT</td><td>59.26</td><td>64.85</td><td>29.11</td><td>58.54</td><td>75.79</td><td>83.05</td><td>76.98</td><td>74.17</td><td>62.88</td><td>63.63</td><td>64.83</td></tr></table>
+
+# B.3 GLUE BENCHMARK
+
+We evaluate our BERT-Base-CT model on the General Language Understanding Evaluation (GLUE) benchmark (Wang et al., 2019), and compare with BERT-Base and S-BERT-Base. Following Devlin et al. (2019), we chose the best performing model on the validation set for each combination of learning rate (among 5e-5, 4e-5, 3e-5, 2e-5 for BERT-base and among 5e-5, 4e-5, 3e-5, 2e-5, 1e-5, 2e-6 for the other models), model and task. For all GLUE tasks, all models are fine-tuned using a batch size of 32 for three epochs.
+
+The results presented in Table 10 demonstrates that BERT performs the best, with a slight margin, on near all tasks. Exception being the STS-b task, where both S-BERT and BERT-CT see a slight improvement over BERT. However, as depicted in Table 2 both S-BERT and BERT-CT attain higher test scores with the embedding based approach, compared to feeding both sentences to the same model as is done in the GLUE tasks.
+
+Table 10: GLUE Test results, returned by the GLUE evaluation server (https:// gluebenchmark.com/leaderboard). Following Devlin et al. (2019), the WNLI set has been excluded from the computation of the average score. F1 score is reported for QQP and MRPC, Spearman correlation $( \mathrm { x } 1 0 0 )$ for STS-b and accuracy is reported for the rest of the tasks.
+
+<table><tr><td></td><td>MNLI-(m/mm)</td><td>QQP</td><td>QNLI</td><td>SST-2</td><td>CoLA</td><td>STS-b</td><td>MRPC</td><td>RTE</td><td>Average</td></tr><tr><td>BERT-Base</td><td>84.2/83.6</td><td>71.3</td><td>90.6</td><td>91.7</td><td>51.9</td><td>83.6</td><td>87.8</td><td>65.0</td><td>78.8</td></tr><tr><td>S-BERT-Base</td><td>83.9/83.1</td><td>71.3</td><td>90.5</td><td>90.9</td><td>47.0</td><td>84.7</td><td>85.3</td><td>61.6</td><td>77.6</td></tr><tr><td>BERT-Base-CT</td><td>82.3/81.9</td><td>70.1</td><td>89.7</td><td>91.3</td><td>48.8</td><td>84.0</td><td>84.4</td><td>61.1</td><td>77.0</td></tr></table>
+
+![](images/fa73c37adfdbfa4f1e7a2fd0411e3bafa9a2678166f4c332e0b3397fa895ceb7.jpg)  
+Figure 5: Layer-wise unsupervised STS performance on the STS-b test set. $\mathrm { X }$ -axis denotes the layers of the depicted model and the Y-axis denotes the Spearman correlation $( \mathrm { x } 1 0 0 )$ . Color is a redundant indicator of the Spearman correlation and the value 50 is included for visual comparison.
+
+![](images/4c7773c1299d00504f5e85b63689c74ddf7a1543ba4700d4e584ae3800544cce.jpg)  
+Figure 6: Layer-wise unsupervised STS performance on the STS-b test set. $\mathrm { X }$ -axis denotes the layers of the depicted model and the Y-axis denotes the Spearman correlation $( \mathrm { x } 1 0 0 )$ . Color is a redundant indicator of the Spearman correlation and the value 50 is included for visual comparison.
+
+# C EXPERIMENT SETUP
+
+# C.1 MODEL CHECKPOINTS
+
+All models and checkpoints where implemented and loaded using the Huggingface API (Wolf et al., 2019). The various model checkpoints used throughout the experiments of this paper are available in Table 11.
+
+Table 11: Model checkpoints used in these experiments.   
+
+<table><tr><td>Model Name</td><td>Parameters</td><td>URL</td></tr><tr><td colspan="3">EnglishBertModels</td></tr><tr><td>Bert-Distil Bert-Base</td><td>66M</td><td>huggingface.co/distilbert-base-uncased</td></tr><tr><td></td><td>110 M</td><td>huggingface.co/bert-base-uncased</td></tr><tr><td>Bert-Large</td><td>340M</td><td>huggingface.co/distilbert-base-uncased</td></tr><tr><td>S-Bert-Distil</td><td>66M</td><td>Anonymous Upload</td></tr><tr><td>S-Bert-Base</td><td>110M</td><td>https://huggingface.co/sentence-transformers/bert-base-nli-mean-tokens</td></tr><tr><td>S-Bert-Large Multilingual Models</td><td>340M</td><td>https://huggingface.co/sentence-transformers/bert-large-nli-mean-tokens</td></tr><tr><td colspan="3"></td></tr><tr><td>Arabic Bert-Base Spanish Bert-Base</td><td>110M</td><td>huggingface.co/asafaya/bert-base-arabic</td></tr><tr><td>Swedish Bert-Base</td><td>110M</td><td>https://huggingface.co/dccuchile/bert-base-spanish-wwm-uncased</td></tr><tr><td>Russian Bert-Base</td><td>110 M</td><td>https://huggingface.co/KB/bert-base-swedish-cased</td></tr><tr><td>Multilingual Bert-Base</td><td>110M</td><td>https://huggingface.co/DeepPavlov/rubert-base-cased</td></tr><tr><td>XLM-R</td><td>110 M</td><td>https://huggingface.co/bert-base-multilingual-cased</td></tr><tr><td>AdditionalModels</td><td>571M</td><td>https://huggingface.co/xlm-mlm-10o-1280</td></tr><tr><td colspan="3">Albert-Base</td></tr><tr><td>Albert-Large Electra-Base</td><td>11 M 17M</td><td>https://huggingface.co/albert-base-vl https://huggingface.co/albert-large-vl</td></tr><tr><td></td><td>110 M</td><td>https://huggingface.co/google/electra-base-discriminator</td></tr><tr><td>Electra-Large</td><td>340M</td><td>https://huggingface.co/google/electra-large-discriminator</td></tr><tr><td>GPT2-Small</td><td>117M</td><td>https://huggingface.co/gpt2</td></tr><tr><td>GPT2-Medium</td><td>345M</td><td>https://huggingface.co/gpt2-medium</td></tr><tr><td>GPT2-Large</td><td>774 M</td><td></td></tr><tr><td>GPT2-XL</td><td>1558M</td><td>https://huggingface.co/gpt2-large</td></tr><tr><td>RoBerta-Base</td><td>125M</td><td>https://huggingface.co/gpt2-xl https://huggingface.co/roberta-base</td></tr><tr><td>RoBerta-Large</td><td>355M</td><td>https://huggingface.co/roberta-large</td></tr><tr><td>XLNet-Base</td><td>110 M</td><td>https://huggingface.co/xlnet-base-cased</td></tr><tr><td>XLNet-Large</td><td>340M</td><td>https://huggingface.co/xlnet-large-cased</td></tr><tr><td></td><td></td><td></td></tr></table>
+
+# C.2 WIKIPEDIA DUMPS
+
+All Wikipedia text data was pre-processed using the WikiExtractor provided by Attardi (2015). The dump files used as text corpora throughout the experiments of this paper are available in Table 12.
+
+Table 12: Wikipedia dumps used in these experiments.   
+
+<table><tr><td>Language</td><td>URL</td></tr><tr><td>Arabic</td><td>https://dumps.wikimedia.org/arwiki/20200820/arwiki-20200820-pages-articles-multistream.xml.bz2</td></tr><tr><td>English</td><td>https://dumps.wikimedia.org/enwiki/20200820/enwiki-20200820-pages-articles-multistream.xml.bz2</td></tr><tr><td>Russian</td><td>https://dumps.wikimedia.org/ruwiki/20200820/ruwiki-20200820-pages-articles-multistream.xml.bz2</td></tr><tr><td>Spanish</td><td>https://dumps.wikimedia.org/eswiki/20200820/eswiki-20200820-pages-articles-multistream.xml.bz2</td></tr><tr><td>Swedish</td><td>https://umps.wikimedia.org/svwiki/20200820/svwiki-20200820-pages-articles-multistream.xml.bz2</td></tr></table>

parse/train/fATZNtA1-V0/fATZNtA1-V0.md

@@ -0,0 +1,251 @@
+# Neural-PIL: Neural Pre-Integrated Lighting for Reflectance Decomposition
+
+Mark Boss University of Tübingen
+
+Varun Jampani Google Research
+
+Raphael Braun University of Tübingen
+
+Ce Liu∗ Microsoft Azure AI
+
+Jonathan T. Barron Google Research
+
+Hendrik P. A. Lensch University of Tübingen
+
+# Abstract
+
+Decomposing a scene into its shape, reflectance and illumination is a fundamental problem in computer vision and graphics. Neural approaches such as NeRF have achieved remarkable success in view synthesis, but do not explicitly perform decomposition and instead operate exclusively on radiance (the product of reflectance and illumination). Extensions to NeRF, such as NeRD, can perform decomposition but struggle to accurately recover detailed illumination, thereby significantly limiting realism. We propose a novel reflectance decomposition network that can estimate shape, BRDF and per-image illumination given a set of object images captured under varying illumination. Our key technique is a novel illumination integration network called Neural-PIL that replaces a costly illumination integral operation in the rendering with a simple network query. In addition, we also learn deep low-dimensional priors on BRDF and illumination representations using novel smooth manifold auto-encoders. Our decompositions can result in considerably better BRDF and light estimates enabling more accurate novel view-synthesis and relighting compared to prior art. Project page: https://markboss.me/publication/2021-neural-pil/
+
+# 1 Introduction
+
+Inverse rendering is the task of decomposing a scene into its underlying physical properties, such as geometry and materials. Recovering these properties is useful for several vision and graphics applications such as view synthesis [10, 11, 51, 57], relighting [4, 10, 11, 23, 24, 38, 51, 58], and object insertion [7, 21, 38]. In this work, we aim to recover the 3D shape and spatiallyvarying bidirectional reflectance distribution function (SVBRDF) of an object imaged under different illumination conditions, as shown in Fig. 1. Estimating shape, illumination, and SVBRDF from 2D images is a highly ill-posed problem, as an observed pixel may appear dark either due to a dark surface material, or due to the incident light at that surface being reduced or absent.
+
+Our approach follows the recent success of coordinate-based scene representation networks [14, 40, 43, 44, 46, 49] in representing 3D scenes for high-quality view-synthesis [44, 49]. These models decompose the scene into models of shape and radiance (emitted light), thereby enabling view synthesis. However, performing complete inverse rendering requires that radiance is decomposed further, into illumination and material appearances (SVBRDF) [6, 11, 51, 63]. A key component in learning these neural SVBRDF decomposition networks is the differentiable rendering [10, 11, 63] that generates images and gradients for the estimated lighting and SVBRDF parameters. These methods leverage traditional rendering techniques within modern deep learning frameworks to enable backpropagation. This is often expensive, as rendering requires computing integrals over the incoming light at each 3D location in the scene. As a remedy, recent works [11, 63] approximate the incident light by spherical Gaussians (SG), thereby accelerating the illumination integration. However, these SG representations lack the capacity required to model or recover the shape and material properties of highly reflective objects or images in complex natural environments.
+
+![](images/3322d8f3f3c7e7fb4cbba33c19771ffc071bf1180b7649102bf69f06234ca082.jpg)  
+Figure 1: Problem setting. Our neural-PIL based technique decomposes images observed under unknown illumination into high-quality BRDF, shape and illuminations. This allows us to then synthesize novel views (targets shown in insets) and perform relighting or illumination transfer.
+
+In this work, we aim to replace the costly illumination integration step within these rendering approaches with a learned network. Inspired by the real-time graphics literature on image-based lighting [28], we propose a novel pre-integrated lighting (PIL) network that converts the illumination integration process used in rendering into a simple network query. Our neural-PIL takes as input a latent vector representation for the environment map, the surface roughness, and an incident ray direction, and from them predicts an integrated illumination estimate. This query-based approach for light integration results in efficient rendering and thereby simplifies and accelerates rendering and optimization. This neural light representation is also significantly more expressive than the more commonly used SG representation, thereby enabling higher-fidelity renderings. The architecture of our neural-PIL uses conditional multi-layer perceptrons (MLP) with FiLM layers [12]. Fig. 2 illustrates this illumination pre-integration for different surface roughness levels.
+
+In addition, we also present a smooth manifold auto-encoder (SMAE), based on interpolating auto-encoders [5], that can learn effective low-dimensional representations of light and BRDFs. This learned low-dimensional space serves as a strong regularizer or prior for constraining the solution space of BRDFs and illumination. These constraints are critical, due to the ill-posedness of our problem setting. The smoothness of this manifold enables stable and effective gradientbased optimization of BRDF and light parameters. The neural-PIL, light-SMAE, and BRDF-SMAE networks are pre-trained on a dataset with high-quality environment maps (illumination) and materials (BRDFs). We integrate these component networks into our decomposition framework, in which we optimize a 3D neural volume with shape and SVBRDF while also optimizing per-image illuminations.
+
+We perform an empirical analysis on synthetic datasets, along with qualitative and quantitative visual results on real-world datasets. We demonstrate that our decomposition network using our neural-PIL can estimate more accurate shape and material properties compared to prior art. The 3D assets with material properties produced by our model can be used to generate high-quality relighting and view-synthesis results with finer details compared to existing approaches.
+
+# 2 Related Work
+
+Coordinate-based MLPs allow spatial information to be stored within the weights of a neural network, thereby allowing the retrieval of information solely by querying coordinates [14, 43, 46, 52]. These methods have been combined with neural volume rendering [40] to enable photorealistic results on novel view synthesis, well-exemplified by NeRF [44]. In NeRF, a coordinate-based model is used to model a field of volumetric density and color, and renderings are produced by ray-marching through that neural volume. Though NeRF is capable of photorealistic renderings, it has many limitations that have been explored by recent work, such as: no relighting capabilities [6, 11, 42, 51, 63], long training times [39, 54], long inference times [11, 25, 31, 39, 60], extraction of 3D geometry and materials [11], and generalization [12, 54, 64]. This work addresses some of these challenges that enables relighting, extracts a conventional 3D geometry and material estimate, and enables real-time rendering (as our 3D assets are compatible with existing real-time rendering engines). The concurrent works of NeRD [11], NeRV [51] and PhySG [63] are most clostly related to ours. These methods decomposes the scene into shape and analytical SVBRDF parameters. However, NeRV requires known illumination, and NeRD and PhySG employ a spherical Gaussian (SG) model, which is not capable of modeling detailed illumination patterns.
+
+![](images/461da304e2ed51afcf24ac7325a29d9f74fe6435e455c68a68cfc26f262c717e.jpg)  
+Figure 2: Pre-integrated lighting. As the roughness of the material increases, the reflected radiance depends on a larger region of the environment map. Brute-force integrals over the environment map are expensive, hence we propose a coordinate-based MLP that is trained to directly output the integrated illumination values conditioned on the surface roughness and view direction.
+
+BRDF estimation is a challenging research problem that aims to estimate the appearance of a physical material. For the highest accuracy results, measurements are performed under controlled laboratory conditions with known view and light positions [3, 9, 32, 33, 34], but this does not allow for the on-site capture of materials. Casual capture methods aim to solve this constraint by only requiring a camera, and sometimes a known light source. Often, machine learning techniques are leveraged to reduce the ambiguity through the use of data-drive priors and large datasets of BRDFs. Additional constraints from planar surfaces viewed under camera flash illumination are considered for single-shot [1, 16, 26, 36, 47], few-shot [1] or multi-shot [2, 9, 17, 18, 20] estimation. This casual setup can be extended to estimating the BRDF and shape of objects [6, 7, 8, 10, 30, 45, 47, 62] or scenes [38, 48]. Most of these methods are based on known active illumination. A limited number of light sources — most often a single one — are assumed to be responsible for the majority of illumination in a scene. Relying on only natural, uncontrolled illumination adds several additional challenges due to the drastically increased ambiguity across shape, illumination and BRDFs. Often these challenges are reduced by keeping the specular albedo non-spatially-varying, or by removing it entirely [35, 59, 63]. Other approaches require temporal traces and limit the casual capture setup [19, 56].
+
+Illumination estimation from a single image is an inherently challenging problem. The task is inherently linked to BRDF estimation, as illumination affects appearance and is only indirectly observable from its interactions with surface materials. These two tasks are often solved in conjunction, sometimes by decomposing a single object into shape, reflectance, and a global set of spherical Gaussians (SGs) [11, 63]. Chen et al. [13] leverage a deep prior of environment maps with homogeneous materials, using an invertible neural BRDF model. Li et al. [38] decompose an entire scene into a simplified BRDF model with hemispherical SGs per point in the scene. The image of the environment in the background may be incorporated into prediction, shifting the problem to completion of the HDR environment map from sparse observations [21, 50, 55]. We not only learn a deep prior but a rendering aware network which is capable of integrating the environment illumination for a specific surface roughness enabling rendering the entire hemisphere of incoming light with a single evaluation.
+
+# 3 Method
+
+Given an image collection of an object captured under varying illumination conditions and camera viewpoints, we aim to jointly estimate the object’s 3D shape and spatially-varying BRDF, as well as the illumination conditions of each image. Our input consists of a set of $q$ images with $s$ pixels each: $C _ { j } \in \mathbb { R } ^ { s \times 3 } ; j \in \{ 1 , \dots , q \}$ along with per-pixel masks $M _ { j } \in \{ 0 , 1 \} ^ { s \times 1 }$ indicating which pixels belong to the object. Our goal is to learn a neural 3D volume $\nu$ where, at each point $\pmb { x } \in \mathbb { R } ^ { 3 }$ , we estimate the BRDF parameters for the Cook-Torrance model [15] $\mathbf { b } \in \mathbb { R } ^ { 7 }$ (diffuse $b _ { d } \in \mathbb { R } ^ { 3 }$ , specular $b _ { s } ~ \in \mathbb { R } ^ { 3 }$ , roughness $b _ { r } \in \mathbb { R }$ ), unit-length surface normal $\textbf { \em n } \in \mathbb { R } ^ { 3 }$ and optical density $\sigma \in \mathbb { R }$ . In addition, we also estimate latent vectors representing per-image illumination $z ^ { l } \in \mathbb { R } ^ { 1 2 \bar { 8 } }$ . This problem statement corresponds to the practical application of recovering a 3D model of some real-world object (for e.g., a statue or landmark) that has been photographed by different people at different times.
+
+# 3.1 Preliminaries
+
+Brief overview of neural radiance fields (NeRF). Our method is based on NeRF [44] which creates a neural volume for novel view synthesis using two Multi-Layer-Perceptrons (MLPs). The first MLP learns a coarse representation, which samples the 3D volume in a fixed sampling pattern, and the second MLP uses this knowledge to sample the volume in high-density areas at a finer resolution. The output of the MLP is a view-dependent color $\boldsymbol { c } \in \mathbb { R } ^ { 3 }$ and optical density $\sigma \in \mathbb { R }$ for each given 3D location $\pmb { x } \in \mathbb { R } ^ { 3 }$ and view direction $\ b { d } \in \mathbb { R } ^ { 3 }$ . In order to render the output color $\hat { \pmb { c } } \in \mathbb { R } ^ { 3 }$ for a camera ray $r ( t ) = o + t d$ , with ray origin $\mathbf { o } \in \mathbb { R } ^ { 3 }$ and view direction $^ d$ , we approximate (via numerical quadrature) the integral $\begin{array} { r } { \hat { c } ( \pmb { r } ) = \int _ { t _ { n } } ^ { t _ { f } } T ( t ) \sigma ( t ) \pmb { c } ( t ) d t } \end{array}$ with $\begin{array} { r } { T ( t ) = \exp ( - \int _ { t _ { n } } ^ { t } \sigma ( t ) d t ) } \end{array}$ , using the near and far bounds of the ray $t _ { n }$ and $t _ { f }$ respectively [44].
+
+Image formation and image-based lighting. NeRF directly models view-dependent color $\hat { c }$ at each 3D location. Thus, a simple image formation process that integrates the color information along camera rays is sufficient to render images. In contrast, we want to explicitly estimate an object material decomposition at each 3D location. We therefore must use a more explicit rendering formulation that relates image formation to BRDFs and illumination. The rendering equation [27] estimates the radiance $L _ { o } ~ \in \mathbb { R } ^ { 3 }$ at $_ { \textbf { \em x } }$ along the outgoing view direction $\omega _ { o } ~ \in ~ \mathbb { R } ^ { 3 }$ $( \omega _ { o } ~ = ~ - d )$ : $\begin{array} { r } { L _ { o } ( \pmb { x } , \pmb { \omega } _ { o } ) = \int _ { \Omega } f _ { r } ( \pmb { x } , \pmb { \omega } _ { i } , \pmb { \omega } _ { o } ; \pmb { b } ) L _ { i } ( \pmb { x } , \pmb { \omega } _ { i } ) ( \pmb { \omega } _ { i } \cdot \pmb { n } ) d \omega _ { i } } \end{array}$ , where $f _ { r }$ is the BRDF evaluation, $L _ { i } \in \mathbb { R } ^ { 3 }$ is incoming light, and $\boldsymbol { \omega } _ { i } \in \mathbb { R } ^ { 3 }$ is the incoming light direction. Using this single bounce rendering formulation, and ignoring exposure variation and tone-mapping, $L _ { o }$ is equivalent to NeRF’s color $\hat { c }$ . The formulation can be split into diffuse and specular components:
+
+$$
+L _ { o } ( \pmb { x } , \omega _ { o } ) = \underbrace { \frac { b _ { d } } { \pi } \int _ { \Omega } L _ { i } ( \pmb { x } , \omega _ { i } ) ( \omega _ { i } \cdot \pmb { n } ) d \omega _ { i } } _ { \mathrm { d i f f u s e } } + \underbrace { \int _ { \Omega } f _ { s } ( \pmb { x } , \omega _ { i } , \omega _ { o } ; \pmb { b } _ { s } , b _ { r } ) L _ { i } ( \pmb { x } , \omega _ { i } ) ( \omega _ { i } \cdot \pmb { n } ) d \omega _ { i } } _ { \mathrm { s p e c u l a r } }
+$$
+
+where $f _ { s }$ now only represents the specular portion of the BRDF evaluation. Following Karis et al. [28], several parts of this integration can be pre-computed [29]:
+
+$$
+L _ { o } ( \pmb { x } , \omega _ { o } ) \approx \underbrace { (  { b _ { d } } / \pi ) \tilde { L } _ { i } ( n , 1 ) } _ { \mathrm { d i f f u s e } } + \underbrace { b _ { s } ( F _ { 0 } ( \omega _ { o } , n ) B _ { 0 } ( \omega _ { o } \cdot n , b _ { r } ) + B _ { 1 } ( \omega _ { o } \cdot n , b _ { r } ) ) \tilde { L } _ { i } ( \omega _ { r } , b _ { r } ) } _ { \mathrm { s p e c u l a r } }
+$$
+
+The illumination is now pre-integrated as: $\begin{array} { r } { \tilde { L } _ { i } ( \omega _ { r } , b _ { r } ) = \int _ { \Omega } D ( b _ { r } , \omega _ { i } , \omega _ { r } ) L _ { i } ( \pmb { x } , \omega _ { i } ) d \omega _ { i } } \end{array}$ which only depends on the mirrored view direction $\omega _ { r }$ (which subsumes the surface normal $\textbf { \em n }$ ) and the roughness $b _ { r }$ , where $D$ describes the microfacet distribution [53]. This light pre-integration is illustrated in Fig. 2. Note that the same pre-integrated $\tilde { L } _ { i } ( \omega _ { r } , b _ { r } )$ is queried twice: the diffuse part captures the entire hemisphere and therefore is parameterized by the surface normal $\mathbf { \boldsymbol { n } } \in \mathbb { R } ^ { 3 }$ and a diffuse roughness of 1. The specular part looks up $\tilde { L } _ { i } ( \omega _ { r } , b _ { r } )$ for the reflected view direction $\omega _ { r } \in \mathbb { R } ^ { 3 }$ and the specular roughness $b _ { r }$ . While the pre-integration already considers the microfacet distribution $D$ , one must also account for shadowing, masking, and the Fresnel term. As shown in Karis et al. [28], these remaining parts can be pre-computed into two 2D lookup textures (LUT) $B _ { 0 }$ and $B _ { 1 }$ indexed by $( { \boldsymbol \omega } _ { o } \cdot { \boldsymbol n } )$ and the roughness $b _ { r }$ . These are combined with the Fresnel term at normal incidence $\bar { F _ { 0 } } ( \omega _ { o } , \pmb { n } ) = ( 1 - \omega _ { o } \cdot \bar { \pmb { h } } ) ^ { 5 }$ with $\pmb { h } = \| \pmb { \omega } _ { i } + \pmb { \omega } _ { o } \|$ .
+
+This pre-integration approach replaces the complex integration during shading with a set of simple additions and multiplications. We have integrated the core idea of this approach into an efficient differentiable neural rendering framework, which allows for the optimization of geometry, BRDF, and illumination simultaneously via standard backpropagation. We further reduce the computational complexity by mimicking the pre-integration of $\tilde { L } _ { i } ( \omega _ { r } , b _ { r } )$ with a simple query through our NeuralPIL that operates directly on a neural representation of the illumination, as we will now explain.
+
+# 3.2 Decomposition with Neural-PIL
+
+Fig. 3 shows the neural decomposition architecture which closely follows the architectures of NeRF [44] and NeRD [11], but with some key differences. The coarse network learns a view and illumination-dependent color whereas the fine network decomposes the scene into BRDF parameters.
+
+![](images/00dde815248b9977dee0cd1a2924db7c1f14f6ab002384eff30aefdc88858d48.jpg)  
+Figure 3: Decomposition with Neural-PIL architecture. (a) Similar to NeRF-W[42] our coarse network uses a latent illumination estimate to predict a view-dependent color and density. (b) Pre-trained networks restrict the possible BRDF representation (BRDF-SMAE) and the incident lighting (PIL) to lower-dimensional spaces. A single evaluation of Neural-PIL returns a pre-filtered illumination cone according to surface roughness. Using that, the BRDF estimate, and a surface normal (the unit-norm gradient of our density estimate), we render the shaded color $^ c$ .
+
+![](images/72bbfc09b00722afb36ce50d1b63cfb049a87a6961a8c95aa883edb4985eefe4.jpg)
+
+Coarse network. Like in NeRF [44], the aim of the coarse network is to obtain rough point density that helps in finer sampling for the following decomposition network. As illustrated in Figure 3a, the coarse network takes 3D location $_ { \textbf { \em x } }$ , view direction $\omega _ { o }$ and illumination embedding $z ^ { l }$ as input and predicts point density $\sigma$ and color $^ c$ at $_ { \textbf { \em x } }$ . In contrast to NeRF, which estimates view-conditioned colors, we estimate both view and illumination conditioned colors, as our input images can be captured under varying illumination. Refer to the supplement for architecture details.
+
+Decomposition network. The decomposition network estimates density $\sigma$ and BRDF embedding $z ^ { b } \in \mathbb { R } ^ { \bar { 4 } }$ at each 3D location $_ { \textbf { \em x } }$ in the implicit volume. As illustrated in Figure 3b, the conditional network in the coarse network is replaced by explicit rendering in the decomposition network. There are two key innovations in the decomposition network: 1) Use a novel pre-integrated light (PIL) network that results in efficient rendering while also representing the illumination with high fidelity. 2) We learn smooth low-dimensional manifolds to represent illumination and BRDF parameters, which serve as strong priors. We will now explain our rendering process, the Neural-PIL, and the smooth manifold auto-encoders (SMAE).
+
+Rendering process. For rendering, we use the rendering formulation in Equation 2. We estimate normal $\textbf { \em n }$ at $_ { \textbf { \em x } }$ by computing the gradient $\nabla \sigma _ { x }$ of the density w.r.t. the input position (by passing gradients through the decomposition network). We also convert the BRDF embedding $z ^ { b }$ into BRDF parameters $^ { b }$ with our BRDF-SMAE. Unlike NeRF [44], which integrates sample colors along the camera ray, we first compute the expected termination of each ray (similar to depth map) with the sample densities along the camera ray, and then do the rendering only at that point along each camera ray. At the ray termination positions, we compute the integrated illumination $\tilde { L } _ { i } ( \omega _ { r } , b _ { r } )$ and use Equation 2 for rendering with the estimated BRDF $^ { b }$ and normal $\textbf { \em n }$ .
+
+Neural-PIL. The integration of the incoming light is traditionally approximated by Monte Carlo sampling, in which illumination contributions from many directions are numerically integrated. The computation of the pre-integrated $\tilde { L } _ { i } ( \omega _ { r } , b _ { r } )$ also involves either this costly numerical accumulation, or a convolution performed on the complete environment map — though neither approach is practical within a differential rendering engine. We therefore learn a network that performs this light preintegration, thereby converting the costly integral computation into a simple network query. The architecture of the Neural-PIL is visualized in Fig. 4. The Neural-PIL takes as input the illumination embedding $z ^ { l }$ , the incoming light direction $\omega _ { r }$ and the roughness $b _ { r }$ at a point, and directly predicts the pre-integrated light $\tilde { L } _ { i } ( \omega _ { r } , b _ { r } )$ . The aim of the Neural-PIL is to first decode the illumination along the incoming mirror direction $\omega _ { r }$ from the given embedding $z ^ { l }$ and then mimic the light pre-integration process for the surface roughness $b _ { r }$ . Following this general intuition, the Neural-PIL takes $\omega _ { r }$ as input, and we condition the first few layers of the network with illumination $z ^ { l }$ , and condition a later layer with roughness $b _ { r }$ . The first few layers are intended to decode all required illumination information for the given direction, and the later layers are intended to perform light integration conditioned on the material roughness.
+
+![](images/2d4ab9da91de18457b9045f11a366f04c626d2e6a3bd438e89ef0f0381db0be4.jpg)  
+Figure 4: Neural-PIL. A coordinate-based MLP returns the pre-integrated radiance for the query direction, where roughness determines the integration footprint.
+
+![](images/8a08559326b2e7eb04e73a33f2b4c2b714c23a78a195408850a282fe1d4ced32.jpg)  
+Figure 5: Smooth manifold auto-encoder. By imposing specific losses on interpolations between input samples, our Smooth Manifold Autoencoder encourages a smooth embedding space.
+
+For the Neural-PIL design, we leverage a pi-GAN-like [12] architecture with FiLM-SIREN layers. Each FILM-SIREN layer [12] takes the modulating parameters (a scalar $\lambda _ { 0 }$ and two vectors $\beta$ and $\gamma )$ to modulate the output $\textbf {  { y } }$ of the earlier linear layer followed by sine computation as follows: $\phi ( \pmb { y } ) = \sin ( \lambda _ { 0 } \gamma \odot \pmb { y } + \beta )$ , where $\odot$ denotes a Hadamard product. In our Neural-PIL, we employ two mapping networks to predict modulating parameters $( \gamma , \beta )$ for the FiLM-SIREN layers. The first mapping network generates the modulating parameters for the first layers from the illumination embedding $\bar { z } ^ { l }$ , while the second one for the penultimate layer from the given roughness $b _ { r }$ .
+
+In addition to converting a costly light integration process in the rendering into a simple network query, our Neural-PIL has another key advantage. State-of-the-art differentiable rendering frameworks [11, 22, 38, 63] that work with BRDFs use either spherical Gaussian (SG) or spherical harmonic (SH) light representations, which both suffer from lack of fine details. Although one could represent fine illumination details with a large number of SG or SH bands, this parameter increase would also make the rendering prohibitively slow with high memory costs. In contrast, our Neural-PIL is an MLP that directly produces pre-integrated light required for the rendering. Our experiments also demonstrate that our Neural-PIL can represent finer details in illumination compared to SG representation (Sec. 4 - Fig. 6). See the supplementary for more Neural-PIL architecture details.
+
+Smooth manifold auto-encoder (SMAE). Since jointly estimating 3D shape, materials and lighting is a highly underconstrained problem, in order to converge to plausible solutions, we must regularize optimization towards likely illuminations and BRDFs. For this, we learn low-dimensional smooth manifolds that capture the data distribution of BRDFs and illuminations. In addition to acting as strong priors, optimizing on smooth manifolds (as opposed to directly optimizing on standard BRDF space, which need not be smooth) allows for more effective gradient-based optimization of reflectance decomposition for a given scene. Fig. 5 illustrates our SMAE that we use to learn separate low-dimensional manifolds to represent BRDF and illumination embeddings. Specifically, we use Interpolating Autoencoders [5] with several additional loss functions. The encoder network $E$ takes input $\pmb { p }$ (either BRDF or light environment map) and generates the latent embedding $_ { z }$ , which is then passed onto the decoder network $G$ that generates an input reconstruction $\pmb { p } ^ { \prime }$ . We then randomly sample two latent vectors from the mini-batch: $z _ { a }$ and $z _ { b }$ ; followed by sampling $m \in \mathbb { N }$ linearly interpolated embeddings that are uniformly spaced between $z _ { a }$ and $z _ { b }$ : $\{ z _ { n } ^ { \prime } \} | n = 1 , 2 , \ldots , m$ . We pass each of these interpolated latents $z _ { n } ^ { \prime }$ through the decoder $G$ and the encoder $E$ to obtain $\hat { p } _ { n } ^ { \prime }$ and $\hat { z } _ { n } ^ { \prime }$ , respectively. Using the four losses depicted in Fig. 5 the encoder and decoder networks are trained jointly. One is the standard reconstruction loss $\mathcal { L } _ { r }$ between input $\pmb { p }$ and reconstruction $\pmb { p } ^ { \prime }$ . In addition, we add a discriminator network on $\hat { p } _ { n } ^ { \prime }$ and use the standard adversarial loss ${ \mathcal { L } } _ { a }$ used in LSGAN [41], which ensures that the interpolated latent vectors can generate plausible data. We enforce a bijective mapping of the encoder and the decoder with a cyclic loss $\mathcal { L } _ { c }$ which is the $L _ { 2 }$ -loss between the interpolated latents $\{ z _ { n } ^ { \prime } \}$ and their re-estimated counterparts $\left\{ \hat { z } _ { n } ^ { \prime } \right\}$ . Lastly, to ensure that the learned embedding space is smooth, we impose a smoothness loss $\mathcal { L } _ { s }$ on the gradient of decoder
+
+$G$ w.r.t. the interpolating scalar value $\alpha$ : $\begin{array} { r } { \mathcal { L } _ { s } = 1 / m \sum _ { n } ( \nabla _ { \alpha } G ( z _ { n } ^ { \prime } ) ) ^ { 2 } } \end{array}$ . The total loss to train SMAE is a combination of the 4 losses: $\mathscr { L } = \mathscr { L } _ { r } + \lambda _ { 1 } \mathscr { L } _ { a } + \lambda _ { 2 } \mathscr { L } _ { c } + \lambda _ { 3 } \mathscr { L } _ { s }$ .
+
+Despite being only 7-dimensional, the space of the Cook-Torrence BRDF representation [15] that we use is too unconstrained for our task, and imposes strong correlations between the diffuse and specular terms of real-world materials. We therefore train a BRDF-SMAE with an MLP encoder and decoder that maps these 7D parameters into 4D latent embeddings $z ^ { b } \in \mathbb { R } ^ { 4 }$ using a dataset of real-world BRDF material collections [10]. Similarly, real-world illuminations exhibit significant statistical regularities: lights are more likely to be tinted blue or yellow, and brighter light is more likely to coming from above than below. To capture this regularity, we train a Light-SMAE with CNN encoder and decoder on a dataset of 320 environment maps from [61]. We then map the $1 2 8 \times 2 5 6$ 2D environment maps onto a 128-dimensional smooth latent space, $z ^ { l } \in \mathbb { R } ^ { 1 2 8 }$ . We provide more network and training details for BRDF-SMAE and Light-SMAE in the supplementary.
+
+Training. Since we have several networks in our decomposition learning pipeline, we will briefly explain the overall training protocol here with more details in the supplementary. We first train Light-SMAE and BRDF-SMAE with a dataset of environment maps and BRDFs respectively. The Neural-PIL network is then trained with the manifold created by the frozen Light-SAME encoder. This separation is mainly done to ease the memory requirements of training both networks jointly. With the frozen BRDF-SMAE’s decoder in the decomposition network and with Neural-PIL in the rendering step, we jointly optimize both the coarse network and the decomposition network for a given set of scene images. For stability, we only optimize the illumination embedding $z ^ { l }$ via decomposition network and we do not backpropagate the loss signal onto illumination in the coarse network. More training details can be found in the supplement.
+
+# 4 Experiments
+
+We evaluate our approach w.r.t. different baselines on the aspects of BRDF and light estimation, view synthesis, and relighting.
+
+Baselines. The closest work to ours is NeRD [11] which forms our primary comparison across different evaluations. To our knowledge, there exists no other published work that tackles the same problem of estimating shape, illumination and BRDF from images of varying illumination. For view synthesis, we also compare with NeRF [44]. For BRDF evaluations, we also compare with Li et al. [37] which does BRDF decomposition from a single image. In addition, we combine Li et al. [37] with NeRF [44] to create a baseline that is closer to our problem setting.
+
+Datasets. To enable the comparisons with NeRD [11], we use the publicly released dataset used in [11] which provides 3 synthetic (Chair, Globe, Car) and 4 real-world
+
+![](images/db6303814221f26998a35783dcffed6ee9bcb07b6294c98ea8e1e4d7c72ab72f.jpg)  
+Figure 6: Neural-PIL vs. spherical Gaussian (SG) vs. Monte-Carlo (MC) integration renderings. With known geometry and reflectance, we optimize using MC integration for the direct illumination, SGs as well as our latent illumination via Neural-PIL. This figure shows final renderings with the optimized light parameters, while the recovered illumination is shown in the insets. Despite Neural-PIL having fewer parameters, it is able to recover more detailed environment maps and thereby produce accurate renderings.
+
+scenes. Two real-world datasets consist of multi-view captures with fixed, unknown illumination (Cape), relatively varying illumination (Head) and two others where the illumination varies with each image (Gnome, MotherChild). In addition, we also present view synthesis results on datasets (Ship, Chair, Lego) used in NeRF [44].
+
+Fildelity of Neural-PIL. Since Neural-PIL forms the key component of our decomposition framework, we evaluate its learned light representation against a more commonly used spherical Gaussians (SG) representation. Additionally, we add a baseline which directly optimizes an environment map using Monte-Carlo (MC) integration. We render a simple metallic sphere using an unseen environment as shown in Fig. 6, with two different roughness levels 0.2 and 0.5. Assuming known roughness and shape, we optimize for SG illumination using the SG-based differentiable rendering used in NeRD [11]. Similarly, we optimize the latent illumination representation using our Neural-PIL-based renderer. For the MC baseline, we leverage BRDF importance sampling, which based on the surface roughness describes how the rays would likely scatter. Here, we cast 128 samples-per-pixel (spp) based on the BRDF towards the environment map with a resolution of $1 2 8 \times 2 5 6$ . The resulting estimated MC, SG illumination and Neural-PIL illuminations are shows in Fig. 6. Compared to the SG illumination model with 24 lobes and 168 parameters, our recovered illumination vector $z ^ { l }$ with only 128 dimensions captures more details, especially in the high-frequency light panels. This leads to a significantly reduced rendering error for both roughness values even though the illumination prediction is more ambiguous for rougher materials. While the MC integration could easily recover detailed highlights, the remaining areas are not recovered well. Besides the improved quality, Neural-PIL based rendering is also much faster. Rendering million samples with our Neural-PIL network takes just $1 . 8 6 \mathrm { m s }$ compared to $2 1 0 \mathrm { m s }$ rendering with 24 SGs. Table 1 shows average PSNR on 6 rendered spheres with more visual results similar to Fig. 6 in the supplements. Our method outperforms both baselines in reconstruction quality.
+
+![](images/96c1f4ca3d1b39ef62c6330cf3db7407ba13c909e10f636e5dc317a0b7f5b3cc.jpg)  
+Figure 7: Visual comparisons. (a) Our model produces more accurate BRDF and illumination estimates, which results in more faithful rendering results. (b) To evaluate view synthesis and relighting we keep the camera and light fixed (col 2), then move the camera (col 3), and then adjust the lighting (col 4). (c) Even when using a single illumination (the problem setting used by NeRF) our method produces shape estimates with fewer artifacts and more detail than both NeRF or NeRD.
+
+Ablation study. To showcase the effectiveness of our novel additions, we perform an ablation of the BRDF-SMAE. Table 2 shows the influence of the BRDF-SMAE on material estimation. These are the PSNR values on the 3 synthetic scenes under varying illumination. It is clear from the table that, especially in estimating the specular parameter, using BRDF-SMAE improves the results drastically. As this parameter is also tied to the diffuse color a degradation in performance is expected. The roughness parameter – even though it is uncorrelated to diffuse and specular – is also improved most likely due to improved color parameters. For the ablation of Neural PIL network, one can refer to NeRD [11] as a baseline that neither uses BRDF-SMAE nor Neural PIL. PSNR metrics in Table 3a shows that our method can result in better decomposition compared to [11].
+
+BRDF evaluations. Following the results in NeRD [11], Table 3a shows the BRDF estimation metrics for different techniques computed on the scenes Globe, Car and Chair. When compared with NeRD, our approach resulted in better diffuse and roughness parameters. Only the prediction of the specular parameter is worse compared to NeRD. This may be due to NeRD’s basecolor-metallic parameterization, which can reduce some ambiguity but also limits the space of expressible materials. A visual comparison is shown in Fig. 7a demonstrating clear visual improvements w.r.t. [37]. One can observe higher frequency details in the environment map using our approach compared to NeRD and the final renderings also show that our result is closer to GT rendering (top-right). Refer to the supplementary material for more visual results.
+
+Table 1: Better illumination estimates with Neural-PIL. Average PSNR with 6 rendered spheres shows that Neural-PIL achieves better PSNR over the spherical Gaussian (SG) and MonteCarlo integration (MC) baselines. More accurate illuminations also enables improved BRDF decomposition and relighting.   
+
+<table><tr><td>Roughness</td><td>MC</td><td>SGs</td><td>Neural-PIL (Ours)</td></tr><tr><td>0.2</td><td>34.88</td><td>31.57</td><td>35.76</td></tr><tr><td>0.5</td><td>35.14</td><td>28.98</td><td>35.28</td></tr></table>
+
+Table 2: Ablation study. Average PSNR of BRDF estimation on 3 synthetic scens under varying illumination demonstrates the positive influence of using the BRDF-SMAE to constrain the BRDF parameter space.   
+
+<table><tr><td>Parameter</td><td>w/o BRDF SMAE</td><td>Ours</td></tr><tr><td>Diffuse</td><td>11.87</td><td>20.22</td></tr><tr><td>Specular</td><td>9.24</td><td>16.84</td></tr><tr><td>Roughness</td><td>16.51</td><td>24.82</td></tr></table>
+
+(a) BRDF decomposition   
+
+<table><tr><td>PSNR↑</td><td>[37]</td><td>[37]+[44]</td><td>[11]</td><td>Ours</td></tr><tr><td>Diffuse</td><td>1.06</td><td>1.15</td><td>18.24</td><td>20.22</td></tr><tr><td>Specular</td><td></td><td></td><td>25.70</td><td>16.84</td></tr><tr><td>Roughness</td><td>17.18</td><td>17.28</td><td>15.00</td><td>24.82</td></tr></table>
+
+(b) View synthesis   
+
+<table><tr><td colspan="2">Synthetic Method PSNR↑SSIM↑PSNR↑SSIM↑</td><td colspan="2">Real-World</td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td>NeRF</td><td>34.24</td><td>0.97</td><td>23.34 0.85</td></tr><tr><td>NeRD</td><td>30.07</td><td>0.95</td><td>23.86 0.88 0.90</td></tr><tr><td>Ours</td><td>30.08</td><td>0.95</td><td>23.95</td></tr></table>
+
+(c) View synthesis and relighting   
+
+<table><tr><td colspan="2">Synthetic</td><td colspan="2">Real-World</td></tr><tr><td>MethodPSNR↑</td><td></td><td>SSIM↑1</td><td>PSNR↑SSIM↑</td></tr><tr><td>NeRF</td><td>21.05</td><td>0.89</td><td>20.11 0.87</td></tr><tr><td>NeRD</td><td>27.96</td><td>0.95 25.81</td><td>0.95</td></tr><tr><td>Ours</td><td>29.24</td><td>0.96 26.23</td><td>0.95</td></tr></table>
+
+Table 3: Comparisons with baselines. (a) A comparison against methods for BRDF decomposition under unknown illuminations, where we see that our model performs well (consistent with our improved relighting performance). (b) An evaluation of view-synthesis (without relighting) under a single illumination, where our model performs well despite this not being our primary task. (c) Here, input images are taken under different illumination conditions, so joint relighting and view synthesis are required. Our model outperforms both baselines by a significant margin: NeRF (which is not intended to address this task) but also NeRD (which targets this same problem statement).
+
+View synthesis and relighting. On the datasets with fixed illumination (Cape, NeRF-Ship, NeRFChair, NeRF-Lego), we can directly compare our renderings with existing novel view synthesis techniques (both NeRF [44] and NeRD [11] here). Table 3b shows novel view evaluation metrics on these datasets with fixed illumination. Results show that our results are better than NeRD showing the improved capture of view-dependent effects. NeRF still outperforms NeRD and our method in the synthetic fixed illumination setting, but is outperformed on the real-world fixed illumination dataset. However, the fixed illumination might in general limit the decomposition capabilities, as shadows do appear always at the same surface locations and therefore might not be correctly disentangled from the BRDF.
+
+On datasets with varying illumination across images (Gnome, MotherChild, Chair, Car, Globe, Head), we need to do both view synthesis and relighting to generate novel unseen test views. Table 3c displays the results on these datasets. NeRF [44] can not do relighting and is included as a weak baseline. The results are significantly better than NeRD and shows that our method can more faithfully estimate the underlying parameters resulting in better relighting under novel illumination conditions.
+
+Fig. 7b shows a couple of results with view synthesis and relighting. The renderings demonstrate realistic view synthesis including re-lighting. Fig. 7c shows novel view synthesis comparison with NeRF and NeRD on Cape scene captured with fixed illumination. Despite NeRF being a strong baseline it could not recover the complete surface due to the reflectiveness. On the other hand, our view synthesis results are more close to the GT on unseen views compared to both NeRF and NeRD.
+
+# 5 Conclusion
+
+We presented a novel reflectance decomposition technique that can estimate shape, per-image illumination and BRDF from images captured in unknown and varying illuminations. The key innovation is the neural-PIL network that can replace costly light integration during rendering with a simple network query resulting in a fast and practical differentiable rendering with high-fidelity illumination. In addition, we propose novel learning techniques with SMAEs that can learn effective low-dimensional smooth manifolds for both BRDF and light representations. Experiments on both synthetic and real-world scenes demonstrate superior decomposition results along with better novel view synthesis and relighting in comparison to prior art.
+
+Limitations. While our techniques make significant strides in the areas of differentiable rendering as well as shape and material decomposition, several challenges still remain in this complex problem setting. Our approach can not handle inter-reflections. Concurrent works such as NeRV [51] are capable of handling inter-reflections and shadowing but only for known illumination. Due to the large ambiguity between the interplay of all effects, solving everything jointly is an extremely challenging problem. Another limitation of our method is that we can not guarantee to converge to the correct underlying BRDF, reflectance and illumination. Our loss is only photometric and, therefore, we find one solution which explains all input images, e.g., adding a new input image might converge to a different representation, as new effects are visible. Also, while our neural-PIL network is capable of producing higher frequency illumination with fewer parameters compared to standard representations such as SGs, mirror-like reflections are still not possible and therefore can limit the reconstruction quality when mirror-like surfaces are present in the scene.
+
+Broader impact. As is generally the case in machine learning, biases in the data used during training may result in biases in the learned model. Our pre-trained networks for BRDFs and incident illumination serve as priors on materials and lighting conditions, and so any bias in the training data used for pre-training those models may result in bias in our estimations of materials and illumination. If the presented techniques were applied to human subjects (which we do not do here) the performance of the model might vary as a function of the subject’s skin color for skewed training distributions.
+
+The purpose of our model is to better enable the creation of highly accurate 3D models from photographs, which could then be used as visual effects in film or television, or in video games. Currently, the creation or acquisition of 3D assets is largely the domain of specialized CGI artists. Improved tools for automating this task may lower the barrier to entry into these careers, which may be seen as harming job opportunities for artists already working in this area. Despite this, we are hopeful that the commoditization of tools for 3D model acquisition will have a net positive impact by allowing a wider range of people to automatically construct high-fidelity 3D models from their image collections.
+
+# Acknowledgments and Disclosure of Funding
+
+This work has been funded by the Deutsche Forschungsgemeinschaft (DFG, German Research Foundation) under Germany’s Excellence Strategy – EXC number 2064/1 – Project number 390727645 and SFB 1233, TP 02 - Project number 276693517. It was supported by the German Federal Ministry of Education and Research (BMBF): Tübingen AI Center, FKZ: 01IS18039A.
+
+# References
+
+[1] Miika Aittala, Timo Aila, and Jaakko Lehtinen. Reflectance modeling by neural texture synthesis. In ACM Transactions on Graphics (ToG), 2018.   
+[2] Rachel Albert, Dorian Yao Chan, Dan B. Goldman, and James F. O’Brian. Approximate svBRDF estimation from mobile phone video. In Eurographics Symposium on Rendering, 2018.   
+[3] Louis-Philippe Asselin, Denis Laurendeau, and Jean-François Lalonde. Deep SVBRDF estimation on real materials. In International Conference on 3D Vision (3DV), 2020.   
+[4] Jonathan T. Barron and Jitendra Malik. Shape, illumination, and reflectance from shading. In IEEE Transactions on Pattern Analysis and Machine Intelligence (PAMI), 2015.   
+[5] David Berthelot, Colin Raffel, Aurko Roy, and Ian Goodfellow. Understanding and improving interpolation in autoencoders via an adversarial regularizer. International Conference on Learning Representations (ICLR), 2019.   
+[6] Sai Bi, Zexiang Xu, Pratul Srinivasan, Ben Mildenhall, Kalyan Sunkavalli, Miloš Hašan, Yannick Hold-Geoffroy, David Kriegman, and Ravi Ramamoorthi. Neural reflectance fields for appearance acquisition. ArXiv e-prints, 2020.   
+[7] Sai Bi, Zexiang Xu, Kalyan Sunkavalli, Miloš Hašan, Yannick Hold-Geoffroy, David Kriegman, and Ravi Ramamoorthi. Deep reflectance volumes: Relightable reconstructions from multi-view photometric images. In European Conference on Computer Vision (ECCV), 2020.   
+[8] Sai Bi, Zexiang Xu, Kalyan Sunkavalli, David Kriegman, and Ravi Ramamoorthi. Deep 3d capture: Geometry and reflectance from sparse multi-view images. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2020.   
+[9] Mark Boss, Fabian Groh, Sebastian Herholz, and Hendrik P. A. Lensch. Deep Dual Loss BRDF Parameter Estimation. In Workshop on Material Appearance Modeling, 2018.   
+[10] Mark Boss, Varun Jampani, Kihwan Kim, Hendrik P.A. Lensch, and Jan Kautz. Two-shot spatially-varying BRDF and shape estimation. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2020.   
+[11] Mark Boss, Raphael Braun, Varun Jampani, Jonathan T. Barron, Ce Liu, and Hendrik P.A. Lensch. NeRD: Neural reflectance decomposition from image collections. In IEEE International Conference on Computer Vision (ICCV), 2021.   
+[12] Eric Chan, Marco Monteiro, Petr Kellnhofer, Jiajun Wu, and Gordon Wetzstein. pi-GAN: Periodic implicit generative adversarial networks for 3D-aware image synthesis. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2021.   
+[13] Zhe Chen, Shohei Nobuhara, and Ko Nishino. Invertible neural BRDF for object inverse rendering. In European Conference on Computer Vision (ECCV), 2020.   
+[14] Zhiqin Chen and Hao Zhang. Learning implicit fields for generative shape modeling. IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2019.   
+[15] Robert L. Cook and Kenneth E. Torrance. A reflectance model for computer graphics. ACM Transactions on Graphics (ToG), 1982.   
+[16] Valentin Deschaintre, Miika Aitalla, Fredo Durand, George Drettakis, and Adrien Bousseau. Single-image SVBRDF capture with a rendering-aware deep network. In ACM Transactions on Graphics (ToG), 2018.   
+[17] Valentin Deschaintre, Miika Aitalla, Fredo Durand, George Drettakis, and Adrien Bousseau. Flexible SVBRDF capture with a multi-image deep network. In Eurographics Symposium on Rendering, 2019.   
+[18] Valentin Deschaintre, George Drettakis, and Adrien Bousseau. Guided fine-tuning for largescale material transfer. In Eurographics Symposium on Rendering, 2020.   
+[19] Yue Dong, Guojun Chen, Pieter Peers, Jianwen Zhang, and Xin Tong. Appearance-from-motion: Recovering spatially varying surface reflectance under unknown lighting. ACM Transactions on Graphics (SIGGRAPH ASIA), 2014.   
+[20] Duan Gao, Xiao Li, Yue Dong, Pieter Peers, and Xin Tong. Deep inverse rendering for highresolution SVBRDF estimation from an arbitrary number of images. In ACM Transactions on Graphics (SIGGRAPH), 2019.   
+[21] Marc-André Gardner, Kalyan Sunkavalli, Ersin Yumer, Xiaohui Shen, Emiliano Gambaretto, Christian Gagné, and Jean-François Lalonde. Learning to predict indoor illumination from a single image. ACM Transactions on Graphics (ToG), 2017.   
+[22] Marc-Andre Gardner, Yannick Hold-Geoffroy, Kalyan Sunkavalli, Christian Gagne, and JeanFrancois Lalonde. Deep parametric indoor lighting estimation. In IEEE International Conference on Computer Vision (ICCV), 2019.   
+[23] Dan B. Goldman, Brian Curless, Aaron Hertzmann, and Steven M. Seitz. Shape and spatiallyvarying BRDFs from photometric stereo. IEEE Transactions on Pattern Analysis and Machine Intelligence (PAMI), 2009.   
+[24] Tom Haber, Christian Fuchs, Phillipe Bekaer, Hans-Peter Seidel, Michael Goesele, and Hendrik P. A. Lensch. Relighting objects from image collections. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2009.   
+[25] Peter Hedman, Pratul P. Srinivasan, Ben Mildenhall, Jonathan T. Barron, and Paul Debevec. Baking neural radiance fields for real-time view synthesis. In IEEE International Conference on Computer Vision (ICCV), 2021.   
+[26] Philipp Henzler, Valentin Deschaintre, Niloy J Mitra, and Tobias Ritschel. Generative modelling of BRDF textures from flash images. ACM Transactions on Graphics (SIGGRAPH ASIA), 2021.   
+[27] James T. Kajiya. The rendering equation. In ACM Transactions on Graphics (SIGGRAPH), 1986.   
+[28] Brian Karis. Real shading in unreal engine 4. Technical report, Epic Games, 2013.   
+[29] Jan Kautz, Pere-Pau Vázquez Alcocer, Wolfgang Heidrich, and Hans-Peter Seidel. A unified approach to prefiltered environment maps. Eurographics Symposium on Rendering, 2000.   
+[30] Berk Kaya, Suryansh Kumar, Carlos Oliveira, Vittorio Ferrari, and Luc Van Gool. Uncalibrated neural inverse rendering for photometric stereo of general surfaces. In IEEE International Conference on Computer Vision (ICCV), 2021.   
+[31] Petr Kellnhofer, Lars Jebe, Andrew Jones, Ryan Spicer, Kari Pulli, and Gordon Wetzstein. Neural lumigraph rendering. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2021.   
+[32] Jason Lawrence, Szymon Rusinkiewicz, and Ravi Ramamoorthi. Efficient BRDF importance sampling using a factored representation. ACM Transactions on Graphics (ToG), 2004.   
+[33] Hendrik P. A. Lensch, Jan Kautz, Michael Gosele, and Hans-Peter Seidel. Image-based reconstruction of spatially varying materials. In Eurographics Conference on Rendering, 2001.   
+[34] Hendrik P.A. Lensch, Jochen Lang, M. Sa Asla, and Hans-Peter Seidel. Planned sampling of spatially varying BRDFs. In Computer Graphics Forum, 2003.   
+[35] Xiao Li, Yue Dong, Pieter Peers, and Xin Tong. Modeling surface appearance from a single photograph using self-augmented convolutional neural networks. In ACM Transactions on Graphics (ToG), 2017.   
+[36] Zhengqin Li, Kalyan Sunkavalli, and Manmohan Chandraker. Materials for masses: SVBRDF acquisition with a single mobile phone image. In European Conference on Computer Vision (ECCV), 2018.   
+[37] Zhengqin Li, Zexiang Xu, Ravi Ramamoorthi, Kalyan Sunkavalli, and Manmohan Chandraker. Learning to reconstruct shape and spatially-varying reflectance from a single image. In ACM Transactions on Graphics (SIGGRAPH ASIA), 2018.   
+[38] Zhengqin Li, Mohammad Shafiei, Ravi Ramamoorthi, Kalyan Sunkavalli, and Manmohan Chandraker. Inverse rendering for complex indoor scenes: Shape, spatially-varying lighting and SVBRDF from a single image. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2020.   
+[39] Lingjie Liu, Jiatao Gu, Kyaw Zaw Lin, Tat-Seng Chua, and Christian Theobalt. Neural sparse voxel fields. In Advances in Neural Information Processing Systems (NeurIPS), 2020.   
+[40] Stephen Lombardi, Tomas Simon, Jason Saragih, Gabriel Schwartz, Andreas Lehrmann, and Yaser Sheikh. Neural volumes: Learning dynamic renderable volumes from images. ACM Transactions on Graphics (ToG), 2019.   
+[41] Xudong Mao, Qing Li, Haoran Xie, Raymond Y.K. Lau, Zhen Wang, and Stephen Paul Smolley. Least squares generative adversarial networks. In IEEE International Conference on Computer Vision (ICCV), 2017.   
+[42] Ricardo Martin-Brualla, Noha Radwan, Mehdi S. M. Sajjadi, Jonathan T. Barron, Alexey Dosovitskiy, and Daniel Duckworth. NeRF in the Wild: Neural Radiance Fields for Unconstrained Photo Collections. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2021.
+
+[43] Lars Mescheder, Michael Oechsle, Michael Niemeyer, Sebastian Nowozin, and Andreas Geiger. Occupancy networks: Learning 3d reconstruction in function space. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2019.
+
+[44] Ben Mildenhall, Pratul Srinivasan, Matthew Tancik, Jonathan T. Barron, Ravi Ramamoorthi, and Ren Ng. NeRF: Representing scenes as neural radiance fields for view synthesis. In European Conference on Computer Vision (ECCV), 2020.
+
+[45] Giljoo Nam, Diego Gutierrez, and Min H. Kim. Practical SVBRDF acquisition of 3d objects with unstructured flash photography. In ACM Transactions on Graphics (SIGGRAPH ASIA), 2018.
+
+[46] Jeong Joon Park, Peter Florence, Julian Straub, Richard Newcombe, and Steven Lovegrove. Deepsdf: Learning continuous signed distance functions for shape representation. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2019.
+
+[47] Shen Sang and Manmohan Chandraker. Single-shot neural relighting and SVBRDF estimation. In European Conference on Computer Vision (ECCV), 2020.
+
+[48] Soumyadip Sengupta, Jinwei Gu, Kihwan Kim, Guilin Liu, David W. Jacobs, and Jan Kautz. Neural inverse rendering of an indoor scene from a single image. In IEEE International Conference on Computer Vision (ICCV), 2019.
+
+[49] Vincent Sitzmann, Julien N.P. Martel, Alexander W. Bergman, David B. Lindell, and Gordon Wetzstein. Implicit neural representations with periodic activation functions. In Advances in Neural Information Processing Systems (NeurIPS), 2020.
+
+[50] Shuran Song and Thomas Funkhouser. Neural illumination: Lighting prediction for indoor environments. IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2019.
+
+[51] Pratul P. Srinivasan, Boyang Deng, Xiuming Zhang, Matthew Tancik, Ben Mildenhall, and Jonathan T. Barron. NeRV: Neural reflectance and visibility fields for relighting and view synthesis. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2021.
+
+[52] 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. Advances in Neural Information Processing Systems (NeurIPS), 2020.
+
+[53] Bruce Walter, Stephen R. Marschner, Hongsong Li, and Kenneth E. Torrance. Microfacet models for refraction through rough surfaces. In Eurographics Symposium on Rendering, 2007.
+
+[54] Qianqian Wang, Zhicheng Wang, Kyle Genova, Pratul Srinivasan, Howard Zhou, Jonathan T. Barron, Ricardo Martin-Brualla, Noah Snavely, and Thomas Funkhouser. Ibrnet: Learning multi-view image-based rendering. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2021.
+
+[55] Henrique Weber, Prévost. Donald, and Jean-François Lalonde. Learning to estimate indoor lighting from 3d objects. In International Conference on 3D Vision (3DV), 2018.
+
+[56] Rui Xia, Yue Dong, Pieter Peers, and Xin Tong. Recovering shape and spatially-varying surface reflectance under unknown illumination. In ACM Transactions on Graphics (SIGGRAPH ASIA), 2016.
+
+[57] Zexiang Xu, Sai Bi, Kalyan Sunkavalli, Sunil Hadap, Hao Su, and Ravi Ramamoorthi. Deep view synthesis from sparse photometric images. ACM Transactions on Graphics (ToG), 2019.
+
+[58] Zexiang Xu et al. Deep image-based relighting from optimal sparse samples. ACM Transactions on Graphics (ToG), 2018.
+
+[59] Wenjie Ye, Xiao Li, Yue Dong, Pieter Peers, and Xin Tong. Single image surface appearance modeling with self-augmented cnns and inexact supervision. Computer Graphics Forum, 2018.
+
+[60] Alex Yu, Ruilong Li, Matthew Tancik, Hao Li, Ren Ng, and Angjoo Kanazawa. PlenOctrees for real-time rendering of neural radiance fields. In IEEE International Conference on Computer Vision (ICCV), 2021.   
+[61] Greg Zaal. Hdri haven, 2019. https://hdrihaven.com/.   
+[62] Jianzhao Zhang, Guojun Chen, Yue Dong, Jian Shi, Bob Zhang, and Enhua Wu. Deep inverse rendering for practical object appearance scan with uncalibrated illumination. In Advances in Computer Graphics, 2020.   
+[63] Kai Zhang, Fujun Luan, Qianqian Wang, Kavita Bala, and Noah Snavely. PhySG: Inverse rendering with spherical Gaussians for physics-based material editing and relighting. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2021.   
+[64] Yuxuan Zhang, Wenzheng Chen, Huan Ling, Jun Gao, Yinan Zhang, Antonio Torralba, and Sanja Fidler. Image GANs meet differentiable rendering for inverse graphics and interpretable 3d neural rendering. In International Conference on Learning Representations (ICLR), 2021.

parse/train/fATZNtA1-V0/fATZNtA1-V0_content_list.json

@@ -0,0 +1,1172 @@
+[
+    {
+        "type": "text",
+        "text": "Neural-PIL: Neural Pre-Integrated Lighting for Reflectance Decomposition ",
+        "text_level": 1,
+        "bbox": [
+            210,
+            122,
+            789,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Mark Boss University of Tübingen ",
+        "bbox": [
+            189,
+            227,
+            341,
+            255
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Varun Jampani Google Research ",
+        "bbox": [
+            366,
+            227,
+            478,
+            253
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Raphael Braun University of Tübingen ",
+        "bbox": [
+            501,
+            227,
+            655,
+            255
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Ce Liu∗ Microsoft Azure AI ",
+        "bbox": [
+            678,
+            226,
+            808,
+            253
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Jonathan T. Barron Google Research ",
+        "bbox": [
+            290,
+            275,
+            429,
+            303
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Hendrik P. A. Lensch University of Tübingen ",
+        "bbox": [
+            553,
+            275,
+            707,
+            303
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            339,
+            535,
+            356
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Decomposing a scene into its shape, reflectance and illumination is a fundamental problem in computer vision and graphics. Neural approaches such as NeRF have achieved remarkable success in view synthesis, but do not explicitly perform decomposition and instead operate exclusively on radiance (the product of reflectance and illumination). Extensions to NeRF, such as NeRD, can perform decomposition but struggle to accurately recover detailed illumination, thereby significantly limiting realism. We propose a novel reflectance decomposition network that can estimate shape, BRDF and per-image illumination given a set of object images captured under varying illumination. Our key technique is a novel illumination integration network called Neural-PIL that replaces a costly illumination integral operation in the rendering with a simple network query. In addition, we also learn deep low-dimensional priors on BRDF and illumination representations using novel smooth manifold auto-encoders. Our decompositions can result in considerably better BRDF and light estimates enabling more accurate novel view-synthesis and relighting compared to prior art. Project page: https://markboss.me/publication/2021-neural-pil/ ",
+        "bbox": [
+            233,
+            371,
+            766,
+            592
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            617,
+            310,
+            635
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Inverse rendering is the task of decomposing a scene into its underlying physical properties, such as geometry and materials. Recovering these properties is useful for several vision and graphics applications such as view synthesis [10, 11, 51, 57], relighting [4, 10, 11, 23, 24, 38, 51, 58], and object insertion [7, 21, 38]. In this work, we aim to recover the 3D shape and spatiallyvarying bidirectional reflectance distribution function (SVBRDF) of an object imaged under different illumination conditions, as shown in Fig. 1. Estimating shape, illumination, and SVBRDF from 2D images is a highly ill-posed problem, as an observed pixel may appear dark either due to a dark surface material, or due to the incident light at that surface being reduced or absent. ",
+        "bbox": [
+            174,
+            648,
+            825,
+            760
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Our approach follows the recent success of coordinate-based scene representation networks [14, 40, 43, 44, 46, 49] in representing 3D scenes for high-quality view-synthesis [44, 49]. These models decompose the scene into models of shape and radiance (emitted light), thereby enabling view synthesis. However, performing complete inverse rendering requires that radiance is decomposed further, into illumination and material appearances (SVBRDF) [6, 11, 51, 63]. A key component in learning these neural SVBRDF decomposition networks is the differentiable rendering [10, 11, 63] that generates images and gradients for the estimated lighting and SVBRDF parameters. These methods leverage traditional rendering techniques within modern deep learning frameworks to enable backpropagation. This is often expensive, as rendering requires computing integrals over the incoming light at each 3D location in the scene. As a remedy, recent works [11, 63] approximate the incident light by spherical Gaussians (SG), thereby accelerating the illumination integration. However, these SG representations lack the capacity required to model or recover the shape and material properties of highly reflective objects or images in complex natural environments. ",
+        "bbox": [
+            174,
+            766,
+            825,
+            877
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/3322d8f3f3c7e7fb4cbba33c19771ffc071bf1180b7649102bf69f06234ca082.jpg",
+        "image_caption": [
+            "Figure 1: Problem setting. Our neural-PIL based technique decomposes images observed under unknown illumination into high-quality BRDF, shape and illuminations. This allows us to then synthesize novel views (targets shown in insets) and perform relighting or illumination transfer. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            97,
+            810,
+            222
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            284,
+            825,
+            353
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we aim to replace the costly illumination integration step within these rendering approaches with a learned network. Inspired by the real-time graphics literature on image-based lighting [28], we propose a novel pre-integrated lighting (PIL) network that converts the illumination integration process used in rendering into a simple network query. Our neural-PIL takes as input a latent vector representation for the environment map, the surface roughness, and an incident ray direction, and from them predicts an integrated illumination estimate. This query-based approach for light integration results in efficient rendering and thereby simplifies and accelerates rendering and optimization. This neural light representation is also significantly more expressive than the more commonly used SG representation, thereby enabling higher-fidelity renderings. The architecture of our neural-PIL uses conditional multi-layer perceptrons (MLP) with FiLM layers [12]. Fig. 2 illustrates this illumination pre-integration for different surface roughness levels. ",
+        "bbox": [
+            174,
+            359,
+            825,
+            511
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In addition, we also present a smooth manifold auto-encoder (SMAE), based on interpolating auto-encoders [5], that can learn effective low-dimensional representations of light and BRDFs. This learned low-dimensional space serves as a strong regularizer or prior for constraining the solution space of BRDFs and illumination. These constraints are critical, due to the ill-posedness of our problem setting. The smoothness of this manifold enables stable and effective gradientbased optimization of BRDF and light parameters. The neural-PIL, light-SMAE, and BRDF-SMAE networks are pre-trained on a dataset with high-quality environment maps (illumination) and materials (BRDFs). We integrate these component networks into our decomposition framework, in which we optimize a 3D neural volume with shape and SVBRDF while also optimizing per-image illuminations. ",
+        "bbox": [
+            174,
+            517,
+            825,
+            642
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We perform an empirical analysis on synthetic datasets, along with qualitative and quantitative visual results on real-world datasets. We demonstrate that our decomposition network using our neural-PIL can estimate more accurate shape and material properties compared to prior art. The 3D assets with material properties produced by our model can be used to generate high-quality relighting and view-synthesis results with finer details compared to existing approaches. ",
+        "bbox": [
+            174,
+            648,
+            825,
+            718
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            738,
+            321,
+            756
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Coordinate-based MLPs allow spatial information to be stored within the weights of a neural network, thereby allowing the retrieval of information solely by querying coordinates [14, 43, 46, 52]. These methods have been combined with neural volume rendering [40] to enable photorealistic results on novel view synthesis, well-exemplified by NeRF [44]. In NeRF, a coordinate-based model is used to model a field of volumetric density and color, and renderings are produced by ray-marching through that neural volume. Though NeRF is capable of photorealistic renderings, it has many limitations that have been explored by recent work, such as: no relighting capabilities [6, 11, 42, 51, 63], long training times [39, 54], long inference times [11, 25, 31, 39, 60], extraction of 3D geometry and materials [11], and generalization [12, 54, 64]. This work addresses some of these challenges that enables relighting, extracts a conventional 3D geometry and material estimate, and enables real-time rendering (as our 3D assets are compatible with existing real-time rendering engines). The concurrent works of NeRD [11], NeRV [51] and PhySG [63] are most clostly related to ours. These methods decomposes the scene into shape and analytical SVBRDF parameters. However, NeRV requires known illumination, and NeRD and PhySG employ a spherical Gaussian (SG) model, which is not capable of modeling detailed illumination patterns. ",
+        "bbox": [
+            174,
+            772,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/461da304e2ed51afcf24ac7325a29d9f74fe6435e455c68a68cfc26f262c717e.jpg",
+        "image_caption": [
+            "Figure 2: Pre-integrated lighting. As the roughness of the material increases, the reflected radiance depends on a larger region of the environment map. Brute-force integrals over the environment map are expensive, hence we propose a coordinate-based MLP that is trained to directly output the integrated illumination values conditioned on the surface roughness and view direction. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            93,
+            815,
+            151
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            247,
+            825,
+            318
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "BRDF estimation is a challenging research problem that aims to estimate the appearance of a physical material. For the highest accuracy results, measurements are performed under controlled laboratory conditions with known view and light positions [3, 9, 32, 33, 34], but this does not allow for the on-site capture of materials. Casual capture methods aim to solve this constraint by only requiring a camera, and sometimes a known light source. Often, machine learning techniques are leveraged to reduce the ambiguity through the use of data-drive priors and large datasets of BRDFs. Additional constraints from planar surfaces viewed under camera flash illumination are considered for single-shot [1, 16, 26, 36, 47], few-shot [1] or multi-shot [2, 9, 17, 18, 20] estimation. This casual setup can be extended to estimating the BRDF and shape of objects [6, 7, 8, 10, 30, 45, 47, 62] or scenes [38, 48]. Most of these methods are based on known active illumination. A limited number of light sources — most often a single one — are assumed to be responsible for the majority of illumination in a scene. Relying on only natural, uncontrolled illumination adds several additional challenges due to the drastically increased ambiguity across shape, illumination and BRDFs. Often these challenges are reduced by keeping the specular albedo non-spatially-varying, or by removing it entirely [35, 59, 63]. Other approaches require temporal traces and limit the casual capture setup [19, 56]. ",
+        "bbox": [
+            173,
+            327,
+            825,
+            546
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Illumination estimation from a single image is an inherently challenging problem. The task is inherently linked to BRDF estimation, as illumination affects appearance and is only indirectly observable from its interactions with surface materials. These two tasks are often solved in conjunction, sometimes by decomposing a single object into shape, reflectance, and a global set of spherical Gaussians (SGs) [11, 63]. Chen et al. [13] leverage a deep prior of environment maps with homogeneous materials, using an invertible neural BRDF model. Li et al. [38] decompose an entire scene into a simplified BRDF model with hemispherical SGs per point in the scene. The image of the environment in the background may be incorporated into prediction, shifting the problem to completion of the HDR environment map from sparse observations [21, 50, 55]. We not only learn a deep prior but a rendering aware network which is capable of integrating the environment illumination for a specific surface roughness enabling rendering the entire hemisphere of incoming light with a single evaluation. ",
+        "bbox": [
+            173,
+            555,
+            825,
+            720
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Method ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            748,
+            269,
+            765
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Given an image collection of an object captured under varying illumination conditions and camera viewpoints, we aim to jointly estimate the object’s 3D shape and spatially-varying BRDF, as well as the illumination conditions of each image. Our input consists of a set of $q$ images with $s$ pixels each: $C _ { j } \\in \\mathbb { R } ^ { s \\times 3 } ; j \\in \\{ 1 , \\dots , q \\}$ along with per-pixel masks $M _ { j } \\in \\{ 0 , 1 \\} ^ { s \\times 1 }$ indicating which pixels belong to the object. Our goal is to learn a neural 3D volume $\\nu$ where, at each point $\\pmb { x } \\in \\mathbb { R } ^ { 3 }$ , we estimate the BRDF parameters for the Cook-Torrance model [15] $\\mathbf { b } \\in \\mathbb { R } ^ { 7 }$ (diffuse $b _ { d } \\in \\mathbb { R } ^ { 3 }$ , specular $b _ { s } ~ \\in \\mathbb { R } ^ { 3 }$ , roughness $b _ { r } \\in \\mathbb { R }$ ), unit-length surface normal $\\textbf { \\em n } \\in \\mathbb { R } ^ { 3 }$ and optical density $\\sigma \\in \\mathbb { R }$ . In addition, we also estimate latent vectors representing per-image illumination $z ^ { l } \\in \\mathbb { R } ^ { 1 2 \\bar { 8 } }$ . This problem statement corresponds to the practical application of recovering a 3D model of some real-world object (for e.g., a statue or landmark) that has been photographed by different people at different times. ",
+        "bbox": [
+            174,
+            785,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            92,
+            825,
+            119
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 Preliminaries ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            135,
+            307,
+            150
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Brief overview of neural radiance fields (NeRF). Our method is based on NeRF [44] which creates a neural volume for novel view synthesis using two Multi-Layer-Perceptrons (MLPs). The first MLP learns a coarse representation, which samples the 3D volume in a fixed sampling pattern, and the second MLP uses this knowledge to sample the volume in high-density areas at a finer resolution. The output of the MLP is a view-dependent color $\\boldsymbol { c } \\in \\mathbb { R } ^ { 3 }$ and optical density $\\sigma \\in \\mathbb { R }$ for each given 3D location $\\pmb { x } \\in \\mathbb { R } ^ { 3 }$ and view direction $\\ b { d } \\in \\mathbb { R } ^ { 3 }$ . In order to render the output color $\\hat { \\pmb { c } } \\in \\mathbb { R } ^ { 3 }$ for a camera ray $r ( t ) = o + t d$ , with ray origin $\\mathbf { o } \\in \\mathbb { R } ^ { 3 }$ and view direction $^ d$ , we approximate (via numerical quadrature) the integral $\\begin{array} { r } { \\hat { c } ( \\pmb { r } ) = \\int _ { t _ { n } } ^ { t _ { f } } T ( t ) \\sigma ( t ) \\pmb { c } ( t ) d t } \\end{array}$ with $\\begin{array} { r } { T ( t ) = \\exp ( - \\int _ { t _ { n } } ^ { t } \\sigma ( t ) d t ) } \\end{array}$ , using the near and far bounds of the ray $t _ { n }$ and $t _ { f }$ respectively [44]. ",
+        "bbox": [
+            173,
+            161,
+            825,
+            292
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Image formation and image-based lighting. NeRF directly models view-dependent color $\\hat { c }$ at each 3D location. Thus, a simple image formation process that integrates the color information along camera rays is sufficient to render images. In contrast, we want to explicitly estimate an object material decomposition at each 3D location. We therefore must use a more explicit rendering formulation that relates image formation to BRDFs and illumination. The rendering equation [27] estimates the radiance $L _ { o } ~ \\in \\mathbb { R } ^ { 3 }$ at $_ { \\textbf { \\em x } }$ along the outgoing view direction $\\omega _ { o } ~ \\in ~ \\mathbb { R } ^ { 3 }$ $( \\omega _ { o } ~ = ~ - d )$ : $\\begin{array} { r } { L _ { o } ( \\pmb { x } , \\pmb { \\omega } _ { o } ) = \\int _ { \\Omega } f _ { r } ( \\pmb { x } , \\pmb { \\omega } _ { i } , \\pmb { \\omega } _ { o } ; \\pmb { b } ) L _ { i } ( \\pmb { x } , \\pmb { \\omega } _ { i } ) ( \\pmb { \\omega } _ { i } \\cdot \\pmb { n } ) d \\omega _ { i } } \\end{array}$ , where $f _ { r }$ is the BRDF evaluation, $L _ { i } \\in \\mathbb { R } ^ { 3 }$ is incoming light, and $\\boldsymbol { \\omega } _ { i } \\in \\mathbb { R } ^ { 3 }$ is the incoming light direction. Using this single bounce rendering formulation, and ignoring exposure variation and tone-mapping, $L _ { o }$ is equivalent to NeRF’s color $\\hat { c }$ . The formulation can be split into diffuse and specular components: ",
+        "bbox": [
+            173,
+            299,
+            826,
+            440
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4251ebce2a1842c0f8c4ca0844a081af30f45af06d7598a5d49fcd629fb0ee2f.jpg",
+        "text": "$$\nL _ { o } ( \\pmb { x } , \\omega _ { o } ) = \\underbrace { \\frac { b _ { d } } { \\pi } \\int _ { \\Omega } L _ { i } ( \\pmb { x } , \\omega _ { i } ) ( \\omega _ { i } \\cdot \\pmb { n } ) d \\omega _ { i } } _ { \\mathrm { d i f f u s e } } + \\underbrace { \\int _ { \\Omega } f _ { s } ( \\pmb { x } , \\omega _ { i } , \\omega _ { o } ; \\pmb { b } _ { s } , b _ { r } ) L _ { i } ( \\pmb { x } , \\omega _ { i } ) ( \\omega _ { i } \\cdot \\pmb { n } ) d \\omega _ { i } } _ { \\mathrm { s p e c u l a r } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            197,
+            444,
+            784,
+            497
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $f _ { s }$ now only represents the specular portion of the BRDF evaluation. Following Karis et al. [28], several parts of this integration can be pre-computed [29]: ",
+        "bbox": [
+            173,
+            502,
+            825,
+            530
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9375eb4ead309831370a9552c6c7d171152ee480c8eb9d1c7d964e7c6ffb4a5a.jpg",
+        "text": "$$\nL _ { o } ( \\pmb { x } , \\omega _ { o } ) \\approx \\underbrace { (  { b _ { d } } / \\pi ) \\tilde { L } _ { i } ( n , 1 ) } _ { \\mathrm { d i f f u s e } } + \\underbrace { b _ { s } ( F _ { 0 } ( \\omega _ { o } , n ) B _ { 0 } ( \\omega _ { o } \\cdot n , b _ { r } ) + B _ { 1 } ( \\omega _ { o } \\cdot n , b _ { r } ) ) \\tilde { L } _ { i } ( \\omega _ { r } , b _ { r } ) } _ { \\mathrm { s p e c u l a r } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            196,
+            534,
+            785,
+            574
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The illumination is now pre-integrated as: $\\begin{array} { r } { \\tilde { L } _ { i } ( \\omega _ { r } , b _ { r } ) = \\int _ { \\Omega } D ( b _ { r } , \\omega _ { i } , \\omega _ { r } ) L _ { i } ( \\pmb { x } , \\omega _ { i } ) d \\omega _ { i } } \\end{array}$ which only depends on the mirrored view direction $\\omega _ { r }$ (which subsumes the surface normal $\\textbf { \\em n }$ ) and the roughness $b _ { r }$ , where $D$ describes the microfacet distribution [53]. This light pre-integration is illustrated in Fig. 2. Note that the same pre-integrated $\\tilde { L } _ { i } ( \\omega _ { r } , b _ { r } )$ is queried twice: the diffuse part captures the entire hemisphere and therefore is parameterized by the surface normal $\\mathbf { \\boldsymbol { n } } \\in \\mathbb { R } ^ { 3 }$ and a diffuse roughness of 1. The specular part looks up $\\tilde { L } _ { i } ( \\omega _ { r } , b _ { r } )$ for the reflected view direction $\\omega _ { r } \\in \\mathbb { R } ^ { 3 }$ and the specular roughness $b _ { r }$ . While the pre-integration already considers the microfacet distribution $D$ , one must also account for shadowing, masking, and the Fresnel term. As shown in Karis et al. [28], these remaining parts can be pre-computed into two 2D lookup textures (LUT) $B _ { 0 }$ and $B _ { 1 }$ indexed by $( { \\boldsymbol \\omega } _ { o } \\cdot { \\boldsymbol n } )$ and the roughness $b _ { r }$ . These are combined with the Fresnel term at normal incidence $\\bar { F _ { 0 } } ( \\omega _ { o } , \\pmb { n } ) = ( 1 - \\omega _ { o } \\cdot \\bar { \\pmb { h } } ) ^ { 5 }$ with $\\pmb { h } = \\| \\pmb { \\omega } _ { i } + \\pmb { \\omega } _ { o } \\|$ . ",
+        "bbox": [
+            173,
+            579,
+            825,
+            738
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "This pre-integration approach replaces the complex integration during shading with a set of simple additions and multiplications. We have integrated the core idea of this approach into an efficient differentiable neural rendering framework, which allows for the optimization of geometry, BRDF, and illumination simultaneously via standard backpropagation. We further reduce the computational complexity by mimicking the pre-integration of $\\tilde { L } _ { i } ( \\omega _ { r } , b _ { r } )$ with a simple query through our NeuralPIL that operates directly on a neural representation of the illumination, as we will now explain. ",
+        "bbox": [
+            173,
+            742,
+            826,
+            829
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 Decomposition with Neural-PIL ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            843,
+            434,
+            858
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Fig. 3 shows the neural decomposition architecture which closely follows the architectures of NeRF [44] and NeRD [11], but with some key differences. The coarse network learns a view and illumination-dependent color whereas the fine network decomposes the scene into BRDF parameters. ",
+        "bbox": [
+            174,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/00dde815248b9977dee0cd1a2924db7c1f14f6ab002384eff30aefdc88858d48.jpg",
+        "image_caption": [
+            "Figure 3: Decomposition with Neural-PIL architecture. (a) Similar to NeRF-W[42] our coarse network uses a latent illumination estimate to predict a view-dependent color and density. (b) Pre-trained networks restrict the possible BRDF representation (BRDF-SMAE) and the incident lighting (PIL) to lower-dimensional spaces. A single evaluation of Neural-PIL returns a pre-filtered illumination cone according to surface roughness. Using that, the BRDF estimate, and a surface normal (the unit-norm gradient of our density estimate), we render the shaded color $^ c$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            108,
+            434,
+            248
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/72bbfc09b00722afb36ce50d1b63cfb049a87a6961a8c95aa883edb4985eefe4.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            473,
+            107,
+            803,
+            255
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Coarse network. Like in NeRF [44], the aim of the coarse network is to obtain rough point density that helps in finer sampling for the following decomposition network. As illustrated in Figure 3a, the coarse network takes 3D location $_ { \\textbf { \\em x } }$ , view direction $\\omega _ { o }$ and illumination embedding $z ^ { l }$ as input and predicts point density $\\sigma$ and color $^ c$ at $_ { \\textbf { \\em x } }$ . In contrast to NeRF, which estimates view-conditioned colors, we estimate both view and illumination conditioned colors, as our input images can be captured under varying illumination. Refer to the supplement for architecture details. ",
+        "bbox": [
+            174,
+            395,
+            825,
+            479
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Decomposition network. The decomposition network estimates density $\\sigma$ and BRDF embedding $z ^ { b } \\in \\mathbb { R } ^ { \\bar { 4 } }$ at each 3D location $_ { \\textbf { \\em x } }$ in the implicit volume. As illustrated in Figure 3b, the conditional network in the coarse network is replaced by explicit rendering in the decomposition network. There are two key innovations in the decomposition network: 1) Use a novel pre-integrated light (PIL) network that results in efficient rendering while also representing the illumination with high fidelity. 2) We learn smooth low-dimensional manifolds to represent illumination and BRDF parameters, which serve as strong priors. We will now explain our rendering process, the Neural-PIL, and the smooth manifold auto-encoders (SMAE). ",
+        "bbox": [
+            174,
+            487,
+            825,
+            598
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Rendering process. For rendering, we use the rendering formulation in Equation 2. We estimate normal $\\textbf { \\em n }$ at $_ { \\textbf { \\em x } }$ by computing the gradient $\\nabla \\sigma _ { x }$ of the density w.r.t. the input position (by passing gradients through the decomposition network). We also convert the BRDF embedding $z ^ { b }$ into BRDF parameters $^ { b }$ with our BRDF-SMAE. Unlike NeRF [44], which integrates sample colors along the camera ray, we first compute the expected termination of each ray (similar to depth map) with the sample densities along the camera ray, and then do the rendering only at that point along each camera ray. At the ray termination positions, we compute the integrated illumination $\\tilde { L } _ { i } ( \\omega _ { r } , b _ { r } )$ and use Equation 2 for rendering with the estimated BRDF $^ { b }$ and normal $\\textbf { \\em n }$ . ",
+        "bbox": [
+            174,
+            606,
+            825,
+            718
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Neural-PIL. The integration of the incoming light is traditionally approximated by Monte Carlo sampling, in which illumination contributions from many directions are numerically integrated. The computation of the pre-integrated $\\tilde { L } _ { i } ( \\omega _ { r } , b _ { r } )$ also involves either this costly numerical accumulation, or a convolution performed on the complete environment map — though neither approach is practical within a differential rendering engine. We therefore learn a network that performs this light preintegration, thereby converting the costly integral computation into a simple network query. The architecture of the Neural-PIL is visualized in Fig. 4. The Neural-PIL takes as input the illumination embedding $z ^ { l }$ , the incoming light direction $\\omega _ { r }$ and the roughness $b _ { r }$ at a point, and directly predicts the pre-integrated light $\\tilde { L } _ { i } ( \\omega _ { r } , b _ { r } )$ . The aim of the Neural-PIL is to first decode the illumination along the incoming mirror direction $\\omega _ { r }$ from the given embedding $z ^ { l }$ and then mimic the light pre-integration process for the surface roughness $b _ { r }$ . Following this general intuition, the Neural-PIL takes $\\omega _ { r }$ as input, and we condition the first few layers of the network with illumination $z ^ { l }$ , and condition a later layer with roughness $b _ { r }$ . The first few layers are intended to decode all required illumination information for the given direction, and the later layers are intended to perform light integration conditioned on the material roughness. ",
+        "bbox": [
+            173,
+            727,
+            825,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/2d4ab9da91de18457b9045f11a366f04c626d2e6a3bd438e89ef0f0381db0be4.jpg",
+        "image_caption": [
+            "Figure 4: Neural-PIL. A coordinate-based MLP returns the pre-integrated radiance for the query direction, where roughness determines the integration footprint. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            192,
+            90,
+            465,
+            238
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/8a08559326b2e7eb04e73a33f2b4c2b714c23a78a195408850a282fe1d4ced32.jpg",
+        "image_caption": [
+            "Figure 5: Smooth manifold auto-encoder. By imposing specific losses on interpolations between input samples, our Smooth Manifold Autoencoder encourages a smooth embedding space. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            517,
+            93,
+            807,
+            236
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            351,
+            825,
+            378
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For the Neural-PIL design, we leverage a pi-GAN-like [12] architecture with FiLM-SIREN layers. Each FILM-SIREN layer [12] takes the modulating parameters (a scalar $\\lambda _ { 0 }$ and two vectors $\\beta$ and $\\gamma )$ to modulate the output $\\textbf {  { y } }$ of the earlier linear layer followed by sine computation as follows: $\\phi ( \\pmb { y } ) = \\sin ( \\lambda _ { 0 } \\gamma \\odot \\pmb { y } + \\beta )$ , where $\\odot$ denotes a Hadamard product. In our Neural-PIL, we employ two mapping networks to predict modulating parameters $( \\gamma , \\beta )$ for the FiLM-SIREN layers. The first mapping network generates the modulating parameters for the first layers from the illumination embedding $\\bar { z } ^ { l }$ , while the second one for the penultimate layer from the given roughness $b _ { r }$ . ",
+        "bbox": [
+            174,
+            385,
+            825,
+            483
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In addition to converting a costly light integration process in the rendering into a simple network query, our Neural-PIL has another key advantage. State-of-the-art differentiable rendering frameworks [11, 22, 38, 63] that work with BRDFs use either spherical Gaussian (SG) or spherical harmonic (SH) light representations, which both suffer from lack of fine details. Although one could represent fine illumination details with a large number of SG or SH bands, this parameter increase would also make the rendering prohibitively slow with high memory costs. In contrast, our Neural-PIL is an MLP that directly produces pre-integrated light required for the rendering. Our experiments also demonstrate that our Neural-PIL can represent finer details in illumination compared to SG representation (Sec. 4 - Fig. 6). See the supplementary for more Neural-PIL architecture details. ",
+        "bbox": [
+            173,
+            488,
+            825,
+            613
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Smooth manifold auto-encoder (SMAE). Since jointly estimating 3D shape, materials and lighting is a highly underconstrained problem, in order to converge to plausible solutions, we must regularize optimization towards likely illuminations and BRDFs. For this, we learn low-dimensional smooth manifolds that capture the data distribution of BRDFs and illuminations. In addition to acting as strong priors, optimizing on smooth manifolds (as opposed to directly optimizing on standard BRDF space, which need not be smooth) allows for more effective gradient-based optimization of reflectance decomposition for a given scene. Fig. 5 illustrates our SMAE that we use to learn separate low-dimensional manifolds to represent BRDF and illumination embeddings. Specifically, we use Interpolating Autoencoders [5] with several additional loss functions. The encoder network $E$ takes input $\\pmb { p }$ (either BRDF or light environment map) and generates the latent embedding $_ { z }$ , which is then passed onto the decoder network $G$ that generates an input reconstruction $\\pmb { p } ^ { \\prime }$ . We then randomly sample two latent vectors from the mini-batch: $z _ { a }$ and $z _ { b }$ ; followed by sampling $m \\in \\mathbb { N }$ linearly interpolated embeddings that are uniformly spaced between $z _ { a }$ and $z _ { b }$ : $\\{ z _ { n } ^ { \\prime } \\} | n = 1 , 2 , \\ldots , m$ . We pass each of these interpolated latents $z _ { n } ^ { \\prime }$ through the decoder $G$ and the encoder $E$ to obtain $\\hat { p } _ { n } ^ { \\prime }$ and $\\hat { z } _ { n } ^ { \\prime }$ , respectively. Using the four losses depicted in Fig. 5 the encoder and decoder networks are trained jointly. One is the standard reconstruction loss $\\mathcal { L } _ { r }$ between input $\\pmb { p }$ and reconstruction $\\pmb { p } ^ { \\prime }$ . In addition, we add a discriminator network on $\\hat { p } _ { n } ^ { \\prime }$ and use the standard adversarial loss ${ \\mathcal { L } } _ { a }$ used in LSGAN [41], which ensures that the interpolated latent vectors can generate plausible data. We enforce a bijective mapping of the encoder and the decoder with a cyclic loss $\\mathcal { L } _ { c }$ which is the $L _ { 2 }$ -loss between the interpolated latents $\\{ z _ { n } ^ { \\prime } \\}$ and their re-estimated counterparts $\\left\\{ \\hat { z } _ { n } ^ { \\prime } \\right\\}$ . Lastly, to ensure that the learned embedding space is smooth, we impose a smoothness loss $\\mathcal { L } _ { s }$ on the gradient of decoder ",
+        "bbox": [
+            173,
+            621,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "$G$ w.r.t. the interpolating scalar value $\\alpha$ : $\\begin{array} { r } { \\mathcal { L } _ { s } = 1 / m \\sum _ { n } ( \\nabla _ { \\alpha } G ( z _ { n } ^ { \\prime } ) ) ^ { 2 } } \\end{array}$ . The total loss to train SMAE is a combination of the 4 losses: $\\mathscr { L } = \\mathscr { L } _ { r } + \\lambda _ { 1 } \\mathscr { L } _ { a } + \\lambda _ { 2 } \\mathscr { L } _ { c } + \\lambda _ { 3 } \\mathscr { L } _ { s }$ . ",
+        "bbox": [
+            173,
+            90,
+            823,
+            121
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Despite being only 7-dimensional, the space of the Cook-Torrence BRDF representation [15] that we use is too unconstrained for our task, and imposes strong correlations between the diffuse and specular terms of real-world materials. We therefore train a BRDF-SMAE with an MLP encoder and decoder that maps these 7D parameters into 4D latent embeddings $z ^ { b } \\in \\mathbb { R } ^ { 4 }$ using a dataset of real-world BRDF material collections [10]. Similarly, real-world illuminations exhibit significant statistical regularities: lights are more likely to be tinted blue or yellow, and brighter light is more likely to coming from above than below. To capture this regularity, we train a Light-SMAE with CNN encoder and decoder on a dataset of 320 environment maps from [61]. We then map the $1 2 8 \\times 2 5 6$ 2D environment maps onto a 128-dimensional smooth latent space, $z ^ { l } \\in \\mathbb { R } ^ { 1 2 8 }$ . We provide more network and training details for BRDF-SMAE and Light-SMAE in the supplementary. ",
+        "bbox": [
+            173,
+            126,
+            825,
+            265
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Training. Since we have several networks in our decomposition learning pipeline, we will briefly explain the overall training protocol here with more details in the supplementary. We first train Light-SMAE and BRDF-SMAE with a dataset of environment maps and BRDFs respectively. The Neural-PIL network is then trained with the manifold created by the frozen Light-SAME encoder. This separation is mainly done to ease the memory requirements of training both networks jointly. With the frozen BRDF-SMAE’s decoder in the decomposition network and with Neural-PIL in the rendering step, we jointly optimize both the coarse network and the decomposition network for a given set of scene images. For stability, we only optimize the illumination embedding $z ^ { l }$ via decomposition network and we do not backpropagate the loss signal onto illumination in the coarse network. More training details can be found in the supplement. ",
+        "bbox": [
+            173,
+            272,
+            825,
+            410
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            435,
+            312,
+            453
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We evaluate our approach w.r.t. different baselines on the aspects of BRDF and light estimation, view synthesis, and relighting. ",
+        "bbox": [
+            174,
+            472,
+            460,
+            513
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Baselines. The closest work to ours is NeRD [11] which forms our primary comparison across different evaluations. To our knowledge, there exists no other published work that tackles the same problem of estimating shape, illumination and BRDF from images of varying illumination. For view synthesis, we also compare with NeRF [44]. For BRDF evaluations, we also compare with Li et al. [37] which does BRDF decomposition from a single image. In addition, we combine Li et al. [37] with NeRF [44] to create a baseline that is closer to our problem setting. ",
+        "bbox": [
+            174,
+            522,
+            460,
+            715
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Datasets. To enable the comparisons with NeRD [11], we use the publicly released dataset used in [11] which provides 3 synthetic (Chair, Globe, Car) and 4 real-world ",
+        "bbox": [
+            174,
+            723,
+            459,
+            779
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/db6303814221f26998a35783dcffed6ee9bcb07b6294c98ea8e1e4d7c72ab72f.jpg",
+        "image_caption": [
+            "Figure 6: Neural-PIL vs. spherical Gaussian (SG) vs. Monte-Carlo (MC) integration renderings. With known geometry and reflectance, we optimize using MC integration for the direct illumination, SGs as well as our latent illumination via Neural-PIL. This figure shows final renderings with the optimized light parameters, while the recovered illumination is shown in the insets. Despite Neural-PIL having fewer parameters, it is able to recover more detailed environment maps and thereby produce accurate renderings. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            477,
+            486,
+            815,
+            616
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "scenes. Two real-world datasets consist of multi-view captures with fixed, unknown illumination (Cape), relatively varying illumination (Head) and two others where the illumination varies with each image (Gnome, MotherChild). In addition, we also present view synthesis results on datasets (Ship, Chair, Lego) used in NeRF [44]. ",
+        "bbox": [
+            174,
+            779,
+            825,
+            833
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Fildelity of Neural-PIL. Since Neural-PIL forms the key component of our decomposition framework, we evaluate its learned light representation against a more commonly used spherical Gaussians (SG) representation. Additionally, we add a baseline which directly optimizes an environment map using Monte-Carlo (MC) integration. We render a simple metallic sphere using an unseen environment as shown in Fig. 6, with two different roughness levels 0.2 and 0.5. Assuming known roughness and shape, we optimize for SG illumination using the SG-based differentiable rendering used in NeRD [11]. Similarly, we optimize the latent illumination representation using our Neural-PIL-based renderer. For the MC baseline, we leverage BRDF importance sampling, which based on the surface roughness describes how the rays would likely scatter. Here, we cast 128 samples-per-pixel (spp) based on the BRDF towards the environment map with a resolution of $1 2 8 \\times 2 5 6$ . The resulting estimated MC, SG illumination and Neural-PIL illuminations are shows in Fig. 6. Compared to the SG illumination model with 24 lobes and 168 parameters, our recovered illumination vector $z ^ { l }$ with only 128 dimensions captures more details, especially in the high-frequency light panels. This leads to a significantly reduced rendering error for both roughness values even though the illumination prediction is more ambiguous for rougher materials. While the MC integration could easily recover detailed highlights, the remaining areas are not recovered well. Besides the improved quality, Neural-PIL based rendering is also much faster. Rendering million samples with our Neural-PIL network takes just $1 . 8 6 \\mathrm { m s }$ compared to $2 1 0 \\mathrm { m s }$ rendering with 24 SGs. Table 1 shows average PSNR on 6 rendered spheres with more visual results similar to Fig. 6 in the supplements. Our method outperforms both baselines in reconstruction quality. ",
+        "bbox": [
+            174,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/96c1f4ca3d1b39ef62c6330cf3db7407ba13c909e10f636e5dc317a0b7f5b3cc.jpg",
+        "image_caption": [
+            "Figure 7: Visual comparisons. (a) Our model produces more accurate BRDF and illumination estimates, which results in more faithful rendering results. (b) To evaluate view synthesis and relighting we keep the camera and light fixed (col 2), then move the camera (col 3), and then adjust the lighting (col 4). (c) Even when using a single illumination (the problem setting used by NeRF) our method produces shape estimates with fewer artifacts and more detail than both NeRF or NeRD. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            87,
+            812,
+            320
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            438,
+            825,
+            645
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Ablation study. To showcase the effectiveness of our novel additions, we perform an ablation of the BRDF-SMAE. Table 2 shows the influence of the BRDF-SMAE on material estimation. These are the PSNR values on the 3 synthetic scenes under varying illumination. It is clear from the table that, especially in estimating the specular parameter, using BRDF-SMAE improves the results drastically. As this parameter is also tied to the diffuse color a degradation in performance is expected. The roughness parameter – even though it is uncorrelated to diffuse and specular – is also improved most likely due to improved color parameters. For the ablation of Neural PIL network, one can refer to NeRD [11] as a baseline that neither uses BRDF-SMAE nor Neural PIL. PSNR metrics in Table 3a shows that our method can result in better decomposition compared to [11]. ",
+        "bbox": [
+            173,
+            654,
+            825,
+            779
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "BRDF evaluations. Following the results in NeRD [11], Table 3a shows the BRDF estimation metrics for different techniques computed on the scenes Globe, Car and Chair. When compared with NeRD, our approach resulted in better diffuse and roughness parameters. Only the prediction of the specular parameter is worse compared to NeRD. This may be due to NeRD’s basecolor-metallic parameterization, which can reduce some ambiguity but also limits the space of expressible materials. A visual comparison is shown in Fig. 7a demonstrating clear visual improvements w.r.t. [37]. One can observe higher frequency details in the environment map using our approach compared to NeRD and the final renderings also show that our result is closer to GT rendering (top-right). Refer to the supplementary material for more visual results. ",
+        "bbox": [
+            174,
+            786,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/7473bbfc1c007ce132ae83ac12898c3fecd3ca41628db0feb6f3514f2e2dc3af.jpg",
+        "table_caption": [
+            "Table 1: Better illumination estimates with Neural-PIL. Average PSNR with 6 rendered spheres shows that Neural-PIL achieves better PSNR over the spherical Gaussian (SG) and MonteCarlo integration (MC) baselines. More accurate illuminations also enables improved BRDF decomposition and relighting. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Roughness</td><td>MC</td><td>SGs</td><td>Neural-PIL (Ours)</td></tr><tr><td>0.2</td><td>34.88</td><td>31.57</td><td>35.76</td></tr><tr><td>0.5</td><td>35.14</td><td>28.98</td><td>35.28</td></tr></table>",
+        "bbox": [
+            202,
+            93,
+            468,
+            140
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/4c942229a7e9ab4f98f32c874cc024837b0e9147b60b18247b3e11cc0b4c575f.jpg",
+        "table_caption": [
+            "Table 2: Ablation study. Average PSNR of BRDF estimation on 3 synthetic scens under varying illumination demonstrates the positive influence of using the BRDF-SMAE to constrain the BRDF parameter space. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Parameter</td><td>w/o BRDF SMAE</td><td>Ours</td></tr><tr><td>Diffuse</td><td>11.87</td><td>20.22</td></tr><tr><td>Specular</td><td>9.24</td><td>16.84</td></tr><tr><td>Roughness</td><td>16.51</td><td>24.82</td></tr></table>",
+        "bbox": [
+            560,
+            88,
+            782,
+            145
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/b710835ebd9b1f3759a6f40322d69db6939a8988eca60e8b7afbe1e2c0d581ef.jpg",
+        "table_caption": [
+            "(a) BRDF decomposition "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>PSNR↑</td><td>[37]</td><td>[37]+[44]</td><td>[11]</td><td>Ours</td></tr><tr><td>Diffuse</td><td>1.06</td><td>1.15</td><td>18.24</td><td>20.22</td></tr><tr><td>Specular</td><td></td><td></td><td>25.70</td><td>16.84</td></tr><tr><td>Roughness</td><td>17.18</td><td>17.28</td><td>15.00</td><td>24.82</td></tr></table>",
+        "bbox": [
+            194,
+            285,
+            383,
+            330
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/bf4cd0fa2b8a4cec60f2979f89fd4acc2c56ed5b197e8ba2edc797542f470b13.jpg",
+        "table_caption": [
+            "(b) View synthesis "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">Synthetic Method PSNR↑SSIM↑PSNR↑SSIM↑</td><td colspan=\"2\">Real-World</td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td>NeRF</td><td>34.24</td><td>0.97</td><td>23.34 0.85</td></tr><tr><td>NeRD</td><td>30.07</td><td>0.95</td><td>23.86 0.88 0.90</td></tr><tr><td>Ours</td><td>30.08</td><td>0.95</td><td>23.95</td></tr></table>",
+        "bbox": [
+            400,
+            285,
+            591,
+            340
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/78e341b77b18d7dacf6c4f50026dc5b77045bf64d34e68f20102d4cebfb5b5f5.jpg",
+        "table_caption": [
+            "(c) View synthesis and relighting "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">Synthetic</td><td colspan=\"2\">Real-World</td></tr><tr><td>MethodPSNR↑</td><td></td><td>SSIM↑1</td><td>PSNR↑SSIM↑</td></tr><tr><td>NeRF</td><td>21.05</td><td>0.89</td><td>20.11 0.87</td></tr><tr><td>NeRD</td><td>27.96</td><td>0.95 25.81</td><td>0.95</td></tr><tr><td>Ours</td><td>29.24</td><td>0.96 26.23</td><td>0.95</td></tr></table>",
+        "bbox": [
+            606,
+            285,
+            802,
+            340
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Table 3: Comparisons with baselines. (a) A comparison against methods for BRDF decomposition under unknown illuminations, where we see that our model performs well (consistent with our improved relighting performance). (b) An evaluation of view-synthesis (without relighting) under a single illumination, where our model performs well despite this not being our primary task. (c) Here, input images are taken under different illumination conditions, so joint relighting and view synthesis are required. Our model outperforms both baselines by a significant margin: NeRF (which is not intended to address this task) but also NeRD (which targets this same problem statement). ",
+        "bbox": [
+            173,
+            345,
+            825,
+            443
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "View synthesis and relighting. On the datasets with fixed illumination (Cape, NeRF-Ship, NeRFChair, NeRF-Lego), we can directly compare our renderings with existing novel view synthesis techniques (both NeRF [44] and NeRD [11] here). Table 3b shows novel view evaluation metrics on these datasets with fixed illumination. Results show that our results are better than NeRD showing the improved capture of view-dependent effects. NeRF still outperforms NeRD and our method in the synthetic fixed illumination setting, but is outperformed on the real-world fixed illumination dataset. However, the fixed illumination might in general limit the decomposition capabilities, as shadows do appear always at the same surface locations and therefore might not be correctly disentangled from the BRDF. ",
+        "bbox": [
+            174,
+            465,
+            825,
+            589
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "On datasets with varying illumination across images (Gnome, MotherChild, Chair, Car, Globe, Head), we need to do both view synthesis and relighting to generate novel unseen test views. Table 3c displays the results on these datasets. NeRF [44] can not do relighting and is included as a weak baseline. The results are significantly better than NeRD and shows that our method can more faithfully estimate the underlying parameters resulting in better relighting under novel illumination conditions. ",
+        "bbox": [
+            174,
+            597,
+            825,
+            666
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Fig. 7b shows a couple of results with view synthesis and relighting. The renderings demonstrate realistic view synthesis including re-lighting. Fig. 7c shows novel view synthesis comparison with NeRF and NeRD on Cape scene captured with fixed illumination. Despite NeRF being a strong baseline it could not recover the complete surface due to the reflectiveness. On the other hand, our view synthesis results are more close to the GT on unseen views compared to both NeRF and NeRD. ",
+        "bbox": [
+            174,
+            671,
+            825,
+            741
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            766,
+            299,
+            782
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We presented a novel reflectance decomposition technique that can estimate shape, per-image illumination and BRDF from images captured in unknown and varying illuminations. The key innovation is the neural-PIL network that can replace costly light integration during rendering with a simple network query resulting in a fast and practical differentiable rendering with high-fidelity illumination. In addition, we propose novel learning techniques with SMAEs that can learn effective low-dimensional smooth manifolds for both BRDF and light representations. Experiments on both synthetic and real-world scenes demonstrate superior decomposition results along with better novel view synthesis and relighting in comparison to prior art. ",
+        "bbox": [
+            174,
+            800,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Limitations. While our techniques make significant strides in the areas of differentiable rendering as well as shape and material decomposition, several challenges still remain in this complex problem setting. Our approach can not handle inter-reflections. Concurrent works such as NeRV [51] are capable of handling inter-reflections and shadowing but only for known illumination. Due to the large ambiguity between the interplay of all effects, solving everything jointly is an extremely challenging problem. Another limitation of our method is that we can not guarantee to converge to the correct underlying BRDF, reflectance and illumination. Our loss is only photometric and, therefore, we find one solution which explains all input images, e.g., adding a new input image might converge to a different representation, as new effects are visible. Also, while our neural-PIL network is capable of producing higher frequency illumination with fewer parameters compared to standard representations such as SGs, mirror-like reflections are still not possible and therefore can limit the reconstruction quality when mirror-like surfaces are present in the scene. ",
+        "bbox": [
+            174,
+            90,
+            825,
+            257
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Broader impact. As is generally the case in machine learning, biases in the data used during training may result in biases in the learned model. Our pre-trained networks for BRDFs and incident illumination serve as priors on materials and lighting conditions, and so any bias in the training data used for pre-training those models may result in bias in our estimations of materials and illumination. If the presented techniques were applied to human subjects (which we do not do here) the performance of the model might vary as a function of the subject’s skin color for skewed training distributions. ",
+        "bbox": [
+            174,
+            265,
+            825,
+            348
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The purpose of our model is to better enable the creation of highly accurate 3D models from photographs, which could then be used as visual effects in film or television, or in video games. Currently, the creation or acquisition of 3D assets is largely the domain of specialized CGI artists. Improved tools for automating this task may lower the barrier to entry into these careers, which may be seen as harming job opportunities for artists already working in this area. Despite this, we are hopeful that the commoditization of tools for 3D model acquisition will have a net positive impact by allowing a wider range of people to automatically construct high-fidelity 3D models from their image collections. ",
+        "bbox": [
+            174,
+            354,
+            825,
+            465
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments and Disclosure of Funding ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            484,
+            553,
+            502
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This work has been funded by the Deutsche Forschungsgemeinschaft (DFG, German Research Foundation) under Germany’s Excellence Strategy – EXC number 2064/1 – Project number 390727645 and SFB 1233, TP 02 - Project number 276693517. It was supported by the German Federal Ministry of Education and Research (BMBF): Tübingen AI Center, FKZ: 01IS18039A. ",
+        "bbox": [
+            174,
+            508,
+            825,
+            564
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            592,
+            266,
+            608
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[1] Miika Aittala, Timo Aila, and Jaakko Lehtinen. Reflectance modeling by neural texture synthesis. In ACM Transactions on Graphics (ToG), 2018.   \n[2] Rachel Albert, Dorian Yao Chan, Dan B. Goldman, and James F. O’Brian. Approximate svBRDF estimation from mobile phone video. In Eurographics Symposium on Rendering, 2018.   \n[3] Louis-Philippe Asselin, Denis Laurendeau, and Jean-François Lalonde. Deep SVBRDF estimation on real materials. In International Conference on 3D Vision (3DV), 2020.   \n[4] Jonathan T. Barron and Jitendra Malik. Shape, illumination, and reflectance from shading. In IEEE Transactions on Pattern Analysis and Machine Intelligence (PAMI), 2015.   \n[5] David Berthelot, Colin Raffel, Aurko Roy, and Ian Goodfellow. Understanding and improving interpolation in autoencoders via an adversarial regularizer. International Conference on Learning Representations (ICLR), 2019.   \n[6] Sai Bi, Zexiang Xu, Pratul Srinivasan, Ben Mildenhall, Kalyan Sunkavalli, Miloš Hašan, Yannick Hold-Geoffroy, David Kriegman, and Ravi Ramamoorthi. Neural reflectance fields for appearance acquisition. ArXiv e-prints, 2020.   \n[7] Sai Bi, Zexiang Xu, Kalyan Sunkavalli, Miloš Hašan, Yannick Hold-Geoffroy, David Kriegman, and Ravi Ramamoorthi. Deep reflectance volumes: Relightable reconstructions from multi-view photometric images. In European Conference on Computer Vision (ECCV), 2020.   \n[8] Sai Bi, Zexiang Xu, Kalyan Sunkavalli, David Kriegman, and Ravi Ramamoorthi. Deep 3d capture: Geometry and reflectance from sparse multi-view images. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2020.   \n[9] Mark Boss, Fabian Groh, Sebastian Herholz, and Hendrik P. A. Lensch. Deep Dual Loss BRDF Parameter Estimation. In Workshop on Material Appearance Modeling, 2018.   \n[10] Mark Boss, Varun Jampani, Kihwan Kim, Hendrik P.A. Lensch, and Jan Kautz. Two-shot spatially-varying BRDF and shape estimation. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2020.   \n[11] Mark Boss, Raphael Braun, Varun Jampani, Jonathan T. Barron, Ce Liu, and Hendrik P.A. Lensch. NeRD: Neural reflectance decomposition from image collections. In IEEE International Conference on Computer Vision (ICCV), 2021.   \n[12] Eric Chan, Marco Monteiro, Petr Kellnhofer, Jiajun Wu, and Gordon Wetzstein. pi-GAN: Periodic implicit generative adversarial networks for 3D-aware image synthesis. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2021.   \n[13] Zhe Chen, Shohei Nobuhara, and Ko Nishino. Invertible neural BRDF for object inverse rendering. In European Conference on Computer Vision (ECCV), 2020.   \n[14] Zhiqin Chen and Hao Zhang. Learning implicit fields for generative shape modeling. IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2019.   \n[15] Robert L. Cook and Kenneth E. Torrance. A reflectance model for computer graphics. ACM Transactions on Graphics (ToG), 1982.   \n[16] Valentin Deschaintre, Miika Aitalla, Fredo Durand, George Drettakis, and Adrien Bousseau. Single-image SVBRDF capture with a rendering-aware deep network. In ACM Transactions on Graphics (ToG), 2018.   \n[17] Valentin Deschaintre, Miika Aitalla, Fredo Durand, George Drettakis, and Adrien Bousseau. Flexible SVBRDF capture with a multi-image deep network. In Eurographics Symposium on Rendering, 2019.   \n[18] Valentin Deschaintre, George Drettakis, and Adrien Bousseau. Guided fine-tuning for largescale material transfer. In Eurographics Symposium on Rendering, 2020.   \n[19] Yue Dong, Guojun Chen, Pieter Peers, Jianwen Zhang, and Xin Tong. Appearance-from-motion: Recovering spatially varying surface reflectance under unknown lighting. ACM Transactions on Graphics (SIGGRAPH ASIA), 2014.   \n[20] Duan Gao, Xiao Li, Yue Dong, Pieter Peers, and Xin Tong. Deep inverse rendering for highresolution SVBRDF estimation from an arbitrary number of images. In ACM Transactions on Graphics (SIGGRAPH), 2019.   \n[21] Marc-André Gardner, Kalyan Sunkavalli, Ersin Yumer, Xiaohui Shen, Emiliano Gambaretto, Christian Gagné, and Jean-François Lalonde. Learning to predict indoor illumination from a single image. ACM Transactions on Graphics (ToG), 2017.   \n[22] Marc-Andre Gardner, Yannick Hold-Geoffroy, Kalyan Sunkavalli, Christian Gagne, and JeanFrancois Lalonde. Deep parametric indoor lighting estimation. In IEEE International Conference on Computer Vision (ICCV), 2019.   \n[23] Dan B. Goldman, Brian Curless, Aaron Hertzmann, and Steven M. Seitz. Shape and spatiallyvarying BRDFs from photometric stereo. IEEE Transactions on Pattern Analysis and Machine Intelligence (PAMI), 2009.   \n[24] Tom Haber, Christian Fuchs, Phillipe Bekaer, Hans-Peter Seidel, Michael Goesele, and Hendrik P. A. Lensch. Relighting objects from image collections. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2009.   \n[25] Peter Hedman, Pratul P. Srinivasan, Ben Mildenhall, Jonathan T. Barron, and Paul Debevec. Baking neural radiance fields for real-time view synthesis. In IEEE International Conference on Computer Vision (ICCV), 2021.   \n[26] Philipp Henzler, Valentin Deschaintre, Niloy J Mitra, and Tobias Ritschel. Generative modelling of BRDF textures from flash images. ACM Transactions on Graphics (SIGGRAPH ASIA), 2021.   \n[27] James T. Kajiya. The rendering equation. In ACM Transactions on Graphics (SIGGRAPH), 1986.   \n[28] Brian Karis. Real shading in unreal engine 4. Technical report, Epic Games, 2013.   \n[29] Jan Kautz, Pere-Pau Vázquez Alcocer, Wolfgang Heidrich, and Hans-Peter Seidel. A unified approach to prefiltered environment maps. Eurographics Symposium on Rendering, 2000.   \n[30] Berk Kaya, Suryansh Kumar, Carlos Oliveira, Vittorio Ferrari, and Luc Van Gool. Uncalibrated neural inverse rendering for photometric stereo of general surfaces. In IEEE International Conference on Computer Vision (ICCV), 2021.   \n[31] Petr Kellnhofer, Lars Jebe, Andrew Jones, Ryan Spicer, Kari Pulli, and Gordon Wetzstein. Neural lumigraph rendering. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2021.   \n[32] Jason Lawrence, Szymon Rusinkiewicz, and Ravi Ramamoorthi. Efficient BRDF importance sampling using a factored representation. ACM Transactions on Graphics (ToG), 2004.   \n[33] Hendrik P. A. Lensch, Jan Kautz, Michael Gosele, and Hans-Peter Seidel. Image-based reconstruction of spatially varying materials. In Eurographics Conference on Rendering, 2001.   \n[34] Hendrik P.A. Lensch, Jochen Lang, M. Sa Asla, and Hans-Peter Seidel. Planned sampling of spatially varying BRDFs. In Computer Graphics Forum, 2003.   \n[35] Xiao Li, Yue Dong, Pieter Peers, and Xin Tong. Modeling surface appearance from a single photograph using self-augmented convolutional neural networks. In ACM Transactions on Graphics (ToG), 2017.   \n[36] Zhengqin Li, Kalyan Sunkavalli, and Manmohan Chandraker. Materials for masses: SVBRDF acquisition with a single mobile phone image. In European Conference on Computer Vision (ECCV), 2018.   \n[37] Zhengqin Li, Zexiang Xu, Ravi Ramamoorthi, Kalyan Sunkavalli, and Manmohan Chandraker. Learning to reconstruct shape and spatially-varying reflectance from a single image. In ACM Transactions on Graphics (SIGGRAPH ASIA), 2018.   \n[38] Zhengqin Li, Mohammad Shafiei, Ravi Ramamoorthi, Kalyan Sunkavalli, and Manmohan Chandraker. Inverse rendering for complex indoor scenes: Shape, spatially-varying lighting and SVBRDF from a single image. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2020.   \n[39] Lingjie Liu, Jiatao Gu, Kyaw Zaw Lin, Tat-Seng Chua, and Christian Theobalt. Neural sparse voxel fields. In Advances in Neural Information Processing Systems (NeurIPS), 2020.   \n[40] Stephen Lombardi, Tomas Simon, Jason Saragih, Gabriel Schwartz, Andreas Lehrmann, and Yaser Sheikh. Neural volumes: Learning dynamic renderable volumes from images. ACM Transactions on Graphics (ToG), 2019.   \n[41] Xudong Mao, Qing Li, Haoran Xie, Raymond Y.K. Lau, Zhen Wang, and Stephen Paul Smolley. Least squares generative adversarial networks. In IEEE International Conference on Computer Vision (ICCV), 2017.   \n[42] Ricardo Martin-Brualla, Noha Radwan, Mehdi S. M. Sajjadi, Jonathan T. Barron, Alexey Dosovitskiy, and Daniel Duckworth. NeRF in the Wild: Neural Radiance Fields for Unconstrained Photo Collections. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2021. ",
+        "bbox": [
+            179,
+            616,
+            826,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            49,
+            828,
+            921
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            70,
+            826,
+            917
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[43] Lars Mescheder, Michael Oechsle, Michael Niemeyer, Sebastian Nowozin, and Andreas Geiger. Occupancy networks: Learning 3d reconstruction in function space. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2019. ",
+        "bbox": [
+            171,
+            90,
+            825,
+            133
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[44] Ben Mildenhall, Pratul Srinivasan, Matthew Tancik, Jonathan T. Barron, Ravi Ramamoorthi, and Ren Ng. NeRF: Representing scenes as neural radiance fields for view synthesis. In European Conference on Computer Vision (ECCV), 2020. ",
+        "bbox": [
+            173,
+            143,
+            821,
+            188
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[45] Giljoo Nam, Diego Gutierrez, and Min H. Kim. Practical SVBRDF acquisition of 3d objects with unstructured flash photography. In ACM Transactions on Graphics (SIGGRAPH ASIA), 2018. ",
+        "bbox": [
+            171,
+            196,
+            823,
+            239
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[46] Jeong Joon Park, Peter Florence, Julian Straub, Richard Newcombe, and Steven Lovegrove. Deepsdf: Learning continuous signed distance functions for shape representation. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2019. ",
+        "bbox": [
+            171,
+            250,
+            823,
+            292
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[47] Shen Sang and Manmohan Chandraker. Single-shot neural relighting and SVBRDF estimation. In European Conference on Computer Vision (ECCV), 2020. ",
+        "bbox": [
+            169,
+            301,
+            825,
+            332
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[48] Soumyadip Sengupta, Jinwei Gu, Kihwan Kim, Guilin Liu, David W. Jacobs, and Jan Kautz. Neural inverse rendering of an indoor scene from a single image. In IEEE International Conference on Computer Vision (ICCV), 2019. ",
+        "bbox": [
+            171,
+            342,
+            825,
+            385
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[49] Vincent Sitzmann, Julien N.P. Martel, Alexander W. Bergman, David B. Lindell, and Gordon Wetzstein. Implicit neural representations with periodic activation functions. In Advances in Neural Information Processing Systems (NeurIPS), 2020. ",
+        "bbox": [
+            173,
+            393,
+            823,
+            438
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[50] Shuran Song and Thomas Funkhouser. Neural illumination: Lighting prediction for indoor environments. IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2019. ",
+        "bbox": [
+            171,
+            446,
+            823,
+            477
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[51] Pratul P. Srinivasan, Boyang Deng, Xiuming Zhang, Matthew Tancik, Ben Mildenhall, and Jonathan T. Barron. NeRV: Neural reflectance and visibility fields for relighting and view synthesis. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2021. ",
+        "bbox": [
+            173,
+            486,
+            823,
+            530
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[52] 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. Advances in Neural Information Processing Systems (NeurIPS), 2020. ",
+        "bbox": [
+            174,
+            539,
+            826,
+            597
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[53] Bruce Walter, Stephen R. Marschner, Hongsong Li, and Kenneth E. Torrance. Microfacet models for refraction through rough surfaces. In Eurographics Symposium on Rendering, 2007. ",
+        "bbox": [
+            171,
+            606,
+            823,
+            636
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[54] Qianqian Wang, Zhicheng Wang, Kyle Genova, Pratul Srinivasan, Howard Zhou, Jonathan T. Barron, Ricardo Martin-Brualla, Noah Snavely, and Thomas Funkhouser. Ibrnet: Learning multi-view image-based rendering. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2021. ",
+        "bbox": [
+            173,
+            645,
+            826,
+            702
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[55] Henrique Weber, Prévost. Donald, and Jean-François Lalonde. Learning to estimate indoor lighting from 3d objects. In International Conference on 3D Vision (3DV), 2018. ",
+        "bbox": [
+            171,
+            712,
+            823,
+            742
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[56] Rui Xia, Yue Dong, Pieter Peers, and Xin Tong. Recovering shape and spatially-varying surface reflectance under unknown illumination. In ACM Transactions on Graphics (SIGGRAPH ASIA), 2016. ",
+        "bbox": [
+            173,
+            751,
+            823,
+            794
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[57] Zexiang Xu, Sai Bi, Kalyan Sunkavalli, Sunil Hadap, Hao Su, and Ravi Ramamoorthi. Deep view synthesis from sparse photometric images. ACM Transactions on Graphics (ToG), 2019. ",
+        "bbox": [
+            171,
+            804,
+            825,
+            834
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[58] Zexiang Xu et al. Deep image-based relighting from optimal sparse samples. ACM Transactions on Graphics (ToG), 2018. ",
+        "bbox": [
+            171,
+            843,
+            823,
+            872
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[59] Wenjie Ye, Xiao Li, Yue Dong, Pieter Peers, and Xin Tong. Single image surface appearance modeling with self-augmented cnns and inexact supervision. Computer Graphics Forum, 2018. ",
+        "bbox": [
+            174,
+            882,
+            823,
+            911
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[60] Alex Yu, Ruilong Li, Matthew Tancik, Hao Li, Ren Ng, and Angjoo Kanazawa. PlenOctrees for real-time rendering of neural radiance fields. In IEEE International Conference on Computer Vision (ICCV), 2021.   \n[61] Greg Zaal. Hdri haven, 2019. https://hdrihaven.com/.   \n[62] Jianzhao Zhang, Guojun Chen, Yue Dong, Jian Shi, Bob Zhang, and Enhua Wu. Deep inverse rendering for practical object appearance scan with uncalibrated illumination. In Advances in Computer Graphics, 2020.   \n[63] Kai Zhang, Fujun Luan, Qianqian Wang, Kavita Bala, and Noah Snavely. PhySG: Inverse rendering with spherical Gaussians for physics-based material editing and relighting. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2021.   \n[64] Yuxuan Zhang, Wenzheng Chen, Huan Ling, Jun Gao, Yinan Zhang, Antonio Torralba, and Sanja Fidler. Image GANs meet differentiable rendering for inverse graphics and interpretable 3d neural rendering. In International Conference on Learning Representations (ICLR), 2021. ",
+        "bbox": [
+            171,
+            90,
+            828,
+            311
+        ],
+        "page_idx": 13
+    }
+]